updated version

* CMake modifications and Config file generation

* CMake minor style changes

* Get rid of commented lines, fix indentation

* Respect Windows conventions for CMake config directory, Fix error with Config Version file, Export CMake package

* Add CMake option for use of ENTT_COMPILE_OPTIONS, Add CMake option for using libc++, Remove  from EnTT target and move it to test targets

* Fix indentation

* Fix indentation (again)

* Fix Windows problems with compile option -Wall in not using it on Windows

* Improved generator expression
The problem with -Wall is not due to the platform but due to the compiler MSVC

* Set compatibility for ConfigVersion file to AnyNewerVersion, Add PATH_VARS CMAKE_INSTALL_INCLUDE_DIR of configure_package_config_file, Remove redundant options, correct target_include_directory for INSTALL_INTERFACE, set the Version in EnTTConfig file and check CMake version

* Add missing closing brace, Add a special config file for the build tree

.gitignore

@@ -1,2 +1 @@
-# QtCreator
 *.user

.travis.yml

@@ -11,6 +11,13 @@ matrix:
         sources: ['ubuntu-toolchain-r-test']
         packages: ['g++-6']
     env: COMPILER=g++-6
+  - os: linux
+    compiler: gcc
+    addons:
+      apt:
+        sources: ['ubuntu-toolchain-r-test']
+        packages: ['g++-7']
+    env: COMPILER=g++-7
   - os: linux
     compiler: clang
     addons:
@@ -18,23 +25,34 @@ matrix:
         sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-4.0']
         packages: ['clang-4.0', 'libstdc++-4.9-dev']
     env: COMPILER=clang++-4.0
+  - os: linux
+    compiler: clang
+    addons:
+      apt:
+        sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-5.0']
+        packages: ['clang-5.0', 'libstdc++-4.9-dev']
+    env: COMPILER=clang++-5.0
   - os: osx
     osx_image: xcode8.3
     compiler: clang
     env: COMPILER=clang++
+  - os: osx
+    osx_image: xcode9.4
+    compiler: clang
+    env: COMPILER=clang++
   - os: linux
     compiler: gcc
     addons:
       apt:
         sources: ['ubuntu-toolchain-r-test']
-        packages: ['g++-6']
+        packages: ['g++-7']
     env:
-      - COMPILER=g++-6
+      - COMPILER=g++-7
       - CXXFLAGS="-O0 --coverage -fno-inline -fno-inline-small-functions -fno-default-inline"
     before_script:
       - pip install --user cpp-coveralls
     after_success:
-      - coveralls --gcov gcov-6 --gcov-options '\-lp' --root ${TRAVIS_BUILD_DIR} --build-root ${TRAVIS_BUILD_DIR}/build --extension cpp --extension hpp --exclude deps --include src
+      - coveralls --gcov gcov-7 --gcov-options '\-lp' --root ${TRAVIS_BUILD_DIR} --build-root ${TRAVIS_BUILD_DIR}/build --extension cpp --extension hpp --exclude deps --include src
 
 notifications:
   email:
@@ -51,5 +69,12 @@ install:
 
 script:
 - mkdir -p build && cd build
-- cmake -DCMAKE_BUILD_TYPE=Release .. && make -j4
+- cmake .. && make -j4
 - CTEST_OUTPUT_ON_FAILURE=1 make test
+
+deploy:
+  provider: script
+  script: scripts/update_packages.sh $TRAVIS_TAG
+  on:
+    tags: true
+    condition: “$TRAVIS_BRANCH” = “$TRAVIS_TAG”

AUTHORS

@@ -5,3 +5,7 @@ Michele Caini aka skypjack
 # Contributors
 
 Paolo Monteverde aka morbo84
+David Nerjes aka DavidHamburg
+Indi Kernick aka Kerndog73
+Malte Müller-Rowold aka m-waka
+Richard Caseres aka richardbmx

CMakeLists.txt

@@ -2,7 +2,7 @@
 # EnTT
 #
 
-cmake_minimum_required(VERSION 3.2)
+cmake_minimum_required(VERSION 3.7.2)
 
 #
 # Building in-tree is not allowed (we take care of your craziness).
@@ -16,7 +16,9 @@ endif()
 # Project configuration
 #
 
-project(entt VERSION 1.1.0)
+project(EnTT VERSION 2.7.3)
+
+include(GNUInstallDirs)
 
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Debug)
@@ -29,63 +31,191 @@ set(PROJECT_AUTHOR_EMAIL "michele.caini@gmail.com")
 
 message("*")
 message("* ${PROJECT_NAME} v${PROJECT_VERSION} (${CMAKE_BUILD_TYPE})")
-message("* Copyright (c) 2017 ${PROJECT_AUTHOR} <${PROJECT_AUTHOR_EMAIL}>")
+message("* Copyright (c) 2017-2018 ${PROJECT_AUTHOR} <${PROJECT_AUTHOR_EMAIL}>")
 message("*")
 
+option(USE_LIBCPP "Use libc++ by adding -stdlib=libc++ flag if availbale." ON)
+option(USE_ASAN "Use address sanitizer by adding -fsanitize=address -fno-omit-frame-pointer flags" OFF)
+option(USE_COMPILE_OPTIONS "Use compile options from EnTT." ON)
+
 #
-# Compile stuff
+# Compiler stuff
 #
 
-set(CMAKE_CXX_STANDARD 14)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+if(NOT MSVC AND USE_LIBCPP)
+    include(CheckCXXSourceCompiles)
+    include(CMakePushCheckState)
 
-if(NOT MSVC)
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wall -Wconversion")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DRELEASE")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g -DDEBUG")
+    cmake_push_check_state()
 
-    if (CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-        # it seems that -O3 ruins the performance when using clang ...
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O2")
-    else()
-        # ... on the other side, GCC is incredibly comfortable with it.
-        set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
+    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -stdlib=libc++")
+
+    check_cxx_source_compiles("
+        #include<type_traits>
+        int main() { return std::is_same<int, int>::value ? 0 : 1; }
+    " HAS_LIBCPP)
+
+    if(NOT HAS_LIBCPP)
+        message(WARNING "The option USE_LIBCPP is set (by default) but libc++ is not available. The flag will not be added to the target.")
     endif()
+
+    cmake_pop_check_state()
 endif()
 
 #
-# CMake configuration
+# Add EnTT target
 #
 
-set(PROJECT_CMAKE_IN ${entt_SOURCE_DIR}/cmake/in)
-set(PROJECT_DEPS_DIR ${entt_SOURCE_DIR}/deps)
-set(PROJECT_SRC_DIR ${entt_SOURCE_DIR}/src)
+add_library(EnTT INTERFACE)
 
-set(PROJECT_RUNTIME_OUTPUT_DIRECTORY bin)
+target_include_directories(
+    EnTT INTERFACE
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
+    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+target_compile_definitions(
+    EnTT
+    INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:DEBUG>
+    INTERFACE $<$<AND:$<CONFIG:Release>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:RELEASE>
+)
+
+if(USE_ASAN)
+    target_compile_options(EnTT INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-fsanitize=address -fno-omit-frame-pointer>)
+    target_link_libraries(EnTT INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-fsanitize=address -fno-omit-frame-pointer>)
+endif()
+
+if(USE_COMPILE_OPTIONS)
+    target_compile_options(
+        EnTT
+        INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-O0 -g>
+        # it seems that -O3 ruins a bit the performance when using clang ...
+        INTERFACE $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:Clang>>:-O2>
+        # ... on the other side, GCC is incredibly comfortable with it.
+        INTERFACE $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:GNU>>:-O3>
+    )
+endif()
+
+if(HAS_LIBCPP)
+    target_compile_options(EnTT BEFORE INTERFACE -stdlib=libc++)
+endif()
+
+target_compile_features(EnTT INTERFACE cxx_std_14)
 
 #
-# Enable test support using ctest-like interface
+# Install EnTT
+#
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+    set(CUSTOM_INSTALL_CONFIGDIR cmake)
+else()
+    set(CUSTOM_INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/entt)
+endif()
+
+install(DIRECTORY src/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+install(TARGETS EnTT EXPORT EnTTTargets)
+
+export(EXPORT EnTTTargets FILE ${EnTT_BINARY_DIR}/EnTTTargets.cmake)
+
+install(
+    EXPORT EnTTTargets
+    FILE EnTTTargets.cmake
+    DESTINATION ${CUSTOM_INSTALL_CONFIGDIR}
+)
+
+#
+# Build tree package config file
+#
+
+configure_file(cmake/in/EnTTBuildConfig.cmake.in EnTTConfig.cmake @ONLY)
+
+include(CMakePackageConfigHelpers)
+
+#
+# Install tree package config file
+#
+
+configure_package_config_file(
+    cmake/in/EnTTConfig.cmake.in
+    ${CUSTOM_INSTALL_CONFIGDIR}/EnTTConfig.cmake
+    INSTALL_DESTINATION ${CUSTOM_INSTALL_CONFIGDIR}
+    PATH_VARS CMAKE_INSTALL_INCLUDEDIR
+    NO_CHECK_REQUIRED_COMPONENTS_MACRO
+)
+
+write_basic_package_version_file(
+    ${EnTT_BINARY_DIR}/EnTTConfigVersion.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY AnyNewerVersion
+)
+
+install(
+    FILES
+        ${EnTT_BINARY_DIR}/${CUSTOM_INSTALL_CONFIGDIR}/EnTTConfig.cmake
+        ${EnTT_BINARY_DIR}/EnTTConfigVersion.cmake
+    DESTINATION ${CUSTOM_INSTALL_CONFIGDIR}
+)
+
+export(PACKAGE EnTT)
+
+#
+# Tests
 #
 
 option(BUILD_TESTING "Enable testing with ctest." ON)
 
-#
-# build testing stuff if required
-#
-
 if(BUILD_TESTING)
     set(THREADS_PREFER_PTHREAD_FLAG ON)
     find_package(Threads REQUIRED)
 
-    # gtest, gtest_main, gmock and gmock_main targets are available from now on
-    set(GOOGLETEST_DEPS_DIR ${PROJECT_DEPS_DIR}/googletest)
-    configure_file(${PROJECT_CMAKE_IN}/googletest.in ${GOOGLETEST_DEPS_DIR}/CMakeLists.txt)
-    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY ${GOOGLETEST_DEPS_DIR})
-    execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${GOOGLETEST_DEPS_DIR})
-    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-    add_subdirectory(${GOOGLETEST_DEPS_DIR}/src ${GOOGLETEST_DEPS_DIR}/build)
+    option(FIND_GTEST_PACKAGE "Enable finding gtest package." OFF)
+
+    if(FIND_GTEST_PACKAGE)
+        find_package(GTest REQUIRED)
+    else()
+        # gtest, gtest_main, gmock and gmock_main targets are available from now on
+        set(GOOGLETEST_DEPS_DIR ${EnTT_SOURCE_DIR}/deps/googletest)
+        configure_file(${EnTT_SOURCE_DIR}/cmake/in/googletest.in ${GOOGLETEST_DEPS_DIR}/CMakeLists.txt)
+        execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY ${GOOGLETEST_DEPS_DIR})
+        execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${GOOGLETEST_DEPS_DIR})
+        set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+        add_subdirectory(${GOOGLETEST_DEPS_DIR}/src ${GOOGLETEST_DEPS_DIR}/build)
+        add_library(GTest::Main ALIAS gtest_main)
+    endif()
+
+    option(BUILD_BENCHMARK "Build benchmark." OFF)
+    option(BUILD_MOD "Build mod example." OFF)
+    option(BUILD_SNAPSHOT "Build snapshot example." OFF)
 
     enable_testing()
     add_subdirectory(test)
 endif()
+
+#
+# Documentation
+#
+
+option(BUILD_DOCS "Enable building with documentation." OFF)
+
+if(BUILD_DOCS)
+    find_package(Doxygen 1.8)
+
+    if(DOXYGEN_FOUND)
+        add_subdirectory(docs)
+    endif()
+endif()
+
+#
+# AOB
+#
+
+add_custom_target(
+    entt_aob
+    SOURCES
+        appveyor.yml
+        AUTHORS
+        LICENSE
+        README.md
+        TODO
+        .travis.yml
+)

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Michele Caini
+Copyright (c) 2017-2018 Michele Caini
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,23 +1,86 @@
-# EnTT - Entity-Component System in modern C++
+![EnTT: Gaming meets modern C++](https://user-images.githubusercontent.com/1812216/42513718-ee6e98d0-8457-11e8-9baf-8d83f61a3097.png)
 
-[![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/uvw)
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+[![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/entt)
 [![Build status](https://ci.appveyor.com/api/projects/status/rvhaabjmghg715ck?svg=true)](https://ci.appveyor.com/project/skypjack/entt)
 [![Coverage Status](https://coveralls.io/repos/github/skypjack/entt/badge.svg?branch=master)](https://coveralls.io/github/skypjack/entt?branch=master)
+[![Gitter chat](https://badges.gitter.im/skypjack/entt.png)](https://gitter.im/skypjack/entt)
 [![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=W2HF9FESD5LJY&lc=IT&item_name=Michele%20Caini&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted)
 
+# Table of Contents
+
+* [Introduction](#introduction)
+  * [Code Example](#code-example)
+  * [Motivation](#motivation)
+  * [Performance](#performance)
+* [Build Instructions](#build-instructions)
+  * [Requirements](#requirements)
+  * [Library](#library)
+  * [Documentation](#documentation)
+  * [Tests](#tests)
+* [Packaging Tools](#packaging-tools)
+* [EnTT in Action](#entt-in-action)
+* [Contributors](#contributors)
+* [License](#license)
+* [Support](#support)
+  * [Donation](#donation)
+  * [Hire me](#hire-me)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
 # Introduction
 
-`EnTT` is a header-only, tiny and easy to use Entity-Component System in modern C++.<br/>
-_ECS_ is an architectural pattern used mostly in game development. For further details:
+`EnTT` is a header-only, tiny and easy to use entity-component system (and much
+more) written in modern C++ and even
+[used by Mojang in Minecraft](https://minecraft.net/en-us/attribution/).<br/>
+The entity-component-system (also known as _ECS_) is an architectural pattern
+used mostly in game development. For further details:
 
 * [Entity Systems Wiki](http://entity-systems.wikidot.com/)
 * [Evolve Your Hierarchy](http://cowboyprogramming.com/2007/01/05/evolve-your-heirachy/)
 * [ECS on Wikipedia](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system)
 
+A long time ago, the sole entity-component system was part of the project. After
+a while the codebase has grown and more and more classes have become part of the
+repository.<br/>
+Here is a brief, yet incomplete list of what it offers today:
+
+* Statically generated integer identifiers for types (assigned either at
+  compile-time or at runtime).
+* A constexpr utility for human readable resource identifiers.
+* A minimal configuration system built on top of the monostate pattern.
+* An incredibly fast entity-component system based on sparse sets, with its own
+  views and a _pay for what you use_ policy to adjust performance and memory
+  usage according to users' requirements.
+* A lot of facilities built on top of the entity-component system to help
+  developers and avoid reinventing the wheel (ie dependencies, snapshot, actor
+  class for those who aren't confident with the architecture and so on).
+* The smallest and most basic implementation of a service locator ever seen.
+* A cooperative scheduler for processes of any type.
+* All what is needed for resource management (cache, loaders, handles).
+* Delegates, signal handlers (with built-in support for collectors) and a tiny
+  event dispatcher.
+* A general purpose event emitter, that is a CRTP idiom based class template.
+* An event dispatcher for immediate and delayed events to integrate in loops.
+* ...
+* Any other business.
+
+Consider it a work in progress. The whole API is also fully documented in-code
+for those who are brave enough to read it.
+
+Currently, `EnTT` is tested on Linux, Microsoft Windows and OS X. It has proven
+to work also on both Android and iOS.<br/>
+Most likely it will not be problematic on other systems as well, but has not
+been sufficiently tested so far.
+
 ## Code Example
 
 ```cpp
-#include <registry.hpp>
+#include <entt/entt.hpp>
+#include <cstdint>
 
 struct Position {
     float x;
@@ -29,469 +92,304 @@ struct Velocity {
     float dy;
 };
 
-using ECS = entt::DefaultRegistry<Position, Velocity>;
+void update(entt::DefaultRegistry &registry) {
+    auto view = registry.view<Position, Velocity>();
+
+    for(auto entity: view) {
+        // gets only the components that are going to be used ...
+
+        auto &velocity = view.get<Velocity>(entity);
+
+        velocity.dx = 0.;
+        velocity.dy = 0.;
+
+        // ...
+    }
+}
+
+void update(std::uint64_t dt, entt::DefaultRegistry &registry) {
+    registry.view<Position, Velocity>().each([dt](auto entity, auto &position, auto &velocity) {
+        // gets all the components of the view at once ...
+
+        position.x += velocity.dx * dt;
+        position.y += velocity.dy * dt;
+
+        // ...
+    });
+}
 
 int main() {
-    ECS ecs;
+    entt::DefaultRegistry registry;
+    std::uint64_t dt = 16;
 
     for(auto i = 0; i < 10; ++i) {
-        auto entity = ecs.create();
-        ecs.assign<Position>(entity, i * 1.f, i * 1.f);
-        if(i % 2 == 0) { ecs.assign<Velocity>(entity, i * .1f, i * .1f); }
+        auto entity = registry.create();
+        registry.assign<Position>(entity, i * 1.f, i * 1.f);
+        if(i % 2 == 0) { registry.assign<Velocity>(entity, i * .1f, i * .1f); }
     }
 
-    // single component view
+    update(dt, registry);
+    update(registry);
 
-    for(auto entity: ecs.view<Position>()) {
-        auto &position = ecs.get<Position>(entity);
-        // ...
-    }
-
-    // multi component view
-
-    for(auto entity: ecs.view<Position, Velocity>()) {
-        auto &position = ecs.get<Position>(entity);
-        auto &velocity = ecs.get<Velocity>(entity);
-        // ...
-    }
-
-    ecs.reset();
+    // ...
 }
 ```
 
 ## Motivation
 
-I started working on `EnTT` because of the wrong reason: my goal was to beat another well known open source _ECS_ in terms of performance.
-I did it, of course, but it wasn't much satisfying. Actually it wasn't satisfying at all. The fastest and nothing more, fairly little indeed.
-When I realized it, I tried hard to keep intact the great performance and to add all the features I want to see in my _ECS_ at the same time.
+I started working on `EnTT` because of the wrong reason: my goal was to design
+an entity-component system that beated another well known open source solution
+in terms of performance and used (possibly) less memory in the average
+case.<br/>
+In the end, I did it, but it wasn't much satisfying. Actually it wasn't
+satisfying at all. The fastest and nothing more, fairly little indeed. When I
+realized it, I tried hard to keep intact the great performance of `EnTT` and to
+add all the features I wanted to see in *my own library* at the same time.
 
-Today `EnTT` is finally what I was looking for: still faster than its _rivals_, a really good API and an amazing set of features.
+Nowadays, `EnTT` is finally what I was looking for: still faster than its
+_competitors_, lower memory usage in the average case, a really good API and an
+amazing set of features. And even more, of course.
 
-### Performance
+## Performance
 
-As it stands right now, `EnTT` is just fast enough for my requirements if compared to my first choice (that was already amazingly fast indeed).<br/>
-Here is a comparision between the two (both of them compiled with GCC 7.2.0 on a Dell XPS 13 out of the mid 2014):
+As it stands right now, `EnTT` is just fast enough for my requirements if
+compared to my first choice (it was already amazingly fast actually).<br/>
+Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a
+Dell XPS 13 out of the mid 2014):
 
-| Benchmark | EntityX (experimental/compile_time) | EnTT |
+| Benchmark | EntityX (compile-time) | EnTT |
 |-----------|-------------|-------------|
-| Creating 10M entities | 0.177225s | **0.0881921s** |
-| Destroying 10M entities | 0.066419s | **0.0552661s** |
-| Iterating over 10M entities, unpacking one component | 0.0104935s | **8.8e-08s** |
-| Iterating over 10M entities, unpacking two components | 0.00835546s | **0.00323798s** |
-| Iterating over 10M entities, unpacking two components, half of the entities have all the components | 0.00772169s | **0.00162265s** |
-| Iterating over 10M entities, unpacking two components, one of the entities has all the components | 0.00751099s | **5.17e-07s** |
-| Iterating over 10M entities, unpacking five components | 0.00863762s | **0.00323384s** |
-| Iterating over 10M entities, unpacking ten components | 0.0105657s | **0.00323742s** |
-| Iterating over 10M entities, unpacking ten components, half of the entities have all the components | 0.00880251s | **0.00164593s** |
-| Iterating over 10M entities, unpacking ten components, one of the entities has all the components | 0.0067667s | **5.38e-07s** |
-| Iterating over 50M entities, unpacking one component | 0.0530271s | **7.7e-08s** |
-| Iterating over 50M entities, unpacking two components | 0.056233s | **0.0161715s** |
+| Create 1M entities | 0.0147s | **0.0046s** |
+| Destroy 1M entities | 0.0053s | **0.0045s** |
+| 1M entities, one component | 0.0012s | **1.9e-07s** |
+| 1M entities, two components | 0.0012s | **3.8e-07s** |
+| 1M entities, two components<br/>Half of the entities have all the components | 0.0009s | **3.8e-07s** |
+| 1M entities, two components<br/>One of the entities has all the components | 0.0008s | **1.0e-06s** |
+| 1M entities, five components | 0.0010s | **7.0e-07s** |
+| 1M entities, ten components | 0.0011s | **1.2e-06s** |
+| 1M entities, ten components<br/>Half of the entities have all the components | 0.0010s | **1.2e-06s** |
+| 1M entities, ten components<br/>One of the entities has all the components | 0.0008s | **1.2e-06s** |
+| Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0036s** |
+| Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0005s** |
+| Sort 150k entities, one component<br/>Arrays are almost sorted, std::sort | - | **0.0035s** |
+| Sort 150k entities, one component<br/>Arrays are almost sorted, insertion sort | - | **0.0007s** |
 
-`EnTT` includes its own tests and benchmarks. See [benchmark.cpp](https://github.com/skypjack/entt/blob/master/test/benchmark.cpp) for further details.<br/>
-On Github users can find also a [benchmark suite](https://github.com/abeimler/ecs_benchmark) that compares a bunch of different projects, one of which is `EnTT`.
+Note: The default version of `EntityX` (`master` branch) wasn't added to the
+comparison because it's already much slower than its compile-time counterpart.
 
-Of course, probably I'll try to get out of `EnTT` more features and better performance in the future, mainly for fun.<br/>
-If you want to contribute and/or have any suggestion, feel free to make a PR or open an issue to discuss your idea.
+Pretty interesting, aren't them? In fact, these benchmarks are the same used by
+`EntityX` to show _how fast it is_. To be honest, they aren't so good and these
+results shouldn't be taken much seriously (they are completely unrealistic
+indeed).<br/>
+The proposed entity-component system is incredibly fast to iterate entities,
+this is a fact. The compiler can make a lot of optimizations because of how
+`EnTT` works, even more when components aren't used at all. This is exactly the
+case for these benchmarks. On the other hand and if we consider real world
+cases, `EnTT` is in the middle between a bit and much faster than the other
+solutions around when users also access the components and not just the
+entities, although it is not as fast as reported by these benchmarks.<br/>
+This is why they are completely wrong and cannot be used to evaluate any of the
+entity-component systems.
+
+If you decide to use `EnTT`, choose it because of its API, features and
+performance, not because there is a benchmark somewhere that makes it seem the
+fastest.
+
+Probably I'll try to get out of `EnTT` more features and even better performance
+in the future, mainly for fun.<br/>
+If you want to contribute and/or have any suggestion, feel free to make a PR or
+open an issue to discuss your idea.
 
 # Build Instructions
 
 ## Requirements
 
-To be able to use `EnTT`, users must provide a full-featured compiler that supports at least C++14.<br/>
-CMake version 3.2 or later is mandatory to compile the tests, users don't have to install it otherwise.
+To be able to use `EnTT`, users must provide a full-featured compiler that
+supports at least C++14.<br/>
+The requirements below are mandatory to compile the tests and to extract the
+documentation:
+
+* CMake version 3.2 or later.
+* Doxygen version 1.8 or later.
 
 ## Library
 
-`EnTT` is a header-only library. This means that including the `registry.hpp` header is enough to use it.<br/>
-It's a matter of adding the following line at the top of a file:
+`EnTT` is a header-only library. This means that including the `entt.hpp` header
+is enough to include the library as a whole and use it. For those who are
+interested only in the entity-component system, consider to include the sole
+`entity/registry.hpp` header instead.<br/>
+It's a matter of adding the following line to the top of a file:
 
 ```cpp
-#include <registry.hpp>
+#include <entt/entt.hpp>
 ```
 
-Then pass the proper `-I` argument to the compiler to add the `src` directory to the include paths.
+Use the line below to include only the entity-component system instead:
+
+```cpp
+#include <entt/entity/registry.hpp>
+```
+
+Then pass the proper `-I` argument to the compiler to add the `src` directory to
+the include paths.
 
 ## Documentation
 
-### API Reference
-
-Unfortunately `EnTT` isn't documented yet and thus users cannot rely on in-code documentation.<br/>
-Source code and names are self-documenting and I'm pretty sure that a glimpse to the API is enough for most of the users.<br/>
-For all the others, below is a crash course that guides them through the project and tries to fill the gap.
-
-### Crash Course
-
-`EnTT` has two main actors: the **Registry** and the **View**.<br/>
-The former can be used to manage components, entities and collections of components and entities. The latter allows users to iterate the underlying collections.
-
-#### The Registry
-
-There are two options to instantiate a registry:
-
-* Use the `DefaultRegistry` alias:
-
-    ```cpp
-    auto registry = entt::DefaultRegistry<Components...>{args...};
-    ```
-
-  Users must provide the whole list of components to be registered with the default registry and that's all.
-
-* Use directly the `Registry` class template:
-
-    ```cpp
-    auto registry = entt::Registry<std::uint16_t, Components...>{args...};
-    ```
-
-  Users must provide the whole list of components to be registered with the registry **and** the desired type for the entities.
-  Note that the default type (the one used by the default registry) is `std::uint32_t`, that is larger enough for almost all the games but also too big for the most of the games.
-
-In both cases there are no requirements for the components but to be moveable, therefore POD types are just fine.
-
-The `Registry` class offers a bunch of basic functionalities to query the internal data structures.
-In almost all the cases those member functions can be used to query either the entity list or the components lists.<br/>
-As an example, the member functions `empty` can be used to know if at least an entity exists and/or if at least one component of the given type has been assigned to an entity.<br/>
-
-```cpp
-bool b = registry.empty();
-// ...
-bool b = registry.empty<MyComponent>();
-```
-
-Similarly, `size` can be used to know the number of entities alive and/or the number of components of a given type still assigned to entities. `capacity` follows the same pattern and returns the storage capacity for the given element.
-
-The `valid` member function returns true if `entity` is still in use, false otherwise:
-
-```cpp
-bool b = registry.valid(entity);
-```
-
-Boring, I agree. Let's go to something more tasty.
-The following functionalities are meant to give users the chance to play with entities and components within a registry.
-
-The `create` member function can be used to construct a new entity and it comes in two flavors:
-
-* The plain version just creates a _naked_ entity with no components assigned to it:
-
-    ```cpp
-    auto entity = registry.create();
-    ```
-
-* The member function template creates an entity and assigns to it the given _default-initialized_ components:
-
-    ```cpp
-    auto entity = registry.create<Position, Velocity>();
-    ```
-
-  It's a helper function, mostly syncactic sugar and it's equivalent to the following snippet:
-
-    ```cpp
-    auto entity = registry.create();
-    registry.assign<Position>();
-    registry.assign<Velocity>();
-    ```
-
-  See below to find more about the `assign` member function.
-
-On the other side, the `destroy` member function can be used to delete an entity and all its components (if any):
-
-```cpp
-registry.destroy(entity);
-```
-
-It requires that `entity` is valid. In case it is not, an assertion will fail in debug mode and the behaviour is undefined in release mode.
-
-If the purpose is to remove a single component instead, the `remove` member function template is the way to go:
-
-```cpp
-registry.remove<Position>(entity);
-```
-
-Again, it requires that `entity` is valid. Moreover, an instance of the component must have been previously assigned to the entity.
-If one of the requirements isn't satisfied, an assertion will fail in debug mode and the behaviour is undefined in release mode.
-
-The `reset` member function behaves similarly but with a strictly defined behaviour (and a performance penalty is the price to pay for that). In particular it removes the component if and only if it exists, otherwise it returns safely to the caller:
-
-```cpp
-registry.reset<Position>(entity);
-```
-
-It requires only that `entity` is valid. In case it is not, an assertion will fail in debug mode and the behaviour is undefined in release mode.
-
-There exist also two more _versions_ of the `reset` member function:
-
-* If no entity is passed to it, `reset` will remove the given component from each entity that has it:
-
-    ```cpp
-    registry.reset<Position>();
-    ```
-
-* If neither the entity nor the component are specified, all the entities and their components are destroyed:
-
-    ```cpp
-    registry.reset();
-    ```
-
-  **Note**: the registry has an assert in debug mode that verifies that entities are no longer valid when it's destructed. This function can be used to reset the registry to its initial state and thus to satisfy the requirement.
-
-To assign a component to an entity, users can rely on the `assign` member function template. It accepts a variable number of arguments that are used to construct the component itself if present:
-
-```cpp
-registry.assign<Position>(entity, 0., 0.);
-// ...
-auto &velocity = registr.assign<Velocity>(entity);
-velocity.dx = 0.;
-velocity.dy = 0.;
-```
-
-It requires that `entity` is valid. Moreover, the entity shouldn't have another instance of the component assigned to it.
-If one of the requirements isn't satisfied, an assertion will fail in debug mode and the behaviour is undefined in release mode.
-
-If the entity already has the given component and the user wants to replace it, the `replace` member function template is the way to go:
-
-```cpp
-registry.replace<Position>(entity, 0., 0.);
-// ...
-auto &velocity = registr.replace<Velocity>(entity);
-velocity.dx = 0.;
-velocity.dy = 0.;
-```
-
-It requires that `entity` is valid. Moreover, an instance of the component must have been previously assigned to the entity.
-If one of the requirements isn't satisfied, an assertion will fail in debug mode and the behaviour is undefined in release mode.
-
-In case users want to assign a component to an entity, but it's unknown whether the entity already has it or not, `accomodate` does the work in a single call
-(of course, there is a performance penalty to pay for that mainly due to the fact that it must check if `entity` already has the given component or not):
-
-```cpp
-registry.accomodate<Position>(entity, 0., 0.);
-// ...
-auto &velocity = registr.accomodate<Velocity>(entity);
-velocity.dx = 0.;
-velocity.dy = 0.;
-```
-
-It requires only that `entity` is valid. In case it is not, an assertion will fail in debug mode and the behaviour is undefined in release mode.<br/>
-Note that `accomodate` is a sliglhty faster alternative for the following if/else statement and nothing more:
-
-```cpp
-if(registry.has<Comp>(entity)) {
-    registry.replace<Comp>(entity, arg1, argN);
-} else {
-    registry.assign<Comp>(entity, arg1, argN);
-}
-```
-
-As already shown, if in doubt about whether or not an entity has one or more components, the `has` member function template may be useful:
-
-```cpp
-bool b = registry.has<Position, Velocity>(entity);
-```
-
-It requires only that `entity` is valid. In case it is not, an assertion will fail in debug mode and the behaviour is undefined in release mode.
-
-Entities can also be cloned and either partially or fully copied:
-
-```cpp
-auto entity = registry.clone(other);
-// ...
-auto &velocity = registry.copy<Velocity>(to, from);
-// ...
-registry.copy(dst, src);
-```
-
-In particular:
-
-* The `clone` member function creates a new entity and copy all the components from the given one.
-* The `copy` member function template copies one component from an entity to another one.
-* The `copy` member function copies all the components from an entity to another one.
-
-All the functions above mentioned require that entities provided as arguments are valid and components exist wherever they have to be accessed.
-In case they are not, an assertion will fail in debug mode and the behaviour is undefined in release mode.
-
-There exists also an utility member function that can be used to `swap` components between entities:
-
-```cpp
-registry.swap<Position>(e1, e2);
-```
-
-As usual, it requires that the two entities are valid and that two instances of the component have been previously assigned to them.
-In case they are not, an assertion will fail in debug mode and the behaviour is undefined in release mode.
-
-The `get` member function template (either the non-const or the const version) gives direct access to the component of an entity instead:
-
-```cpp
-auto &position = registry.get<Position>(entity);
-```
-
-It requires that `entity` is valid. Moreover, an instance of the component must have been previously assigned to the entity.
-If one of the requirements isn't satisfied, an assertion will fail in debug mode and the behaviour is undefined in release mode.
-
-Components can also be sorted in memory by means of the `sort` member function templates. In particular:
-
-* Components can be sorted according to a component:
-
-    ```cpp
-    registry.sort<Renderable>([](const auto &lhs, const auto &rhs) { return lhs.z < rhs.z; });
-    ```
-
-* Components can be sorted according to the order imposed by another component:
-
-    ```cpp
-    registry.sort<Movement, Physics>();
-    ```
-
-  In this case, instances of `Movement` are arranged in memory so that cache misses are minimized when the two components are iterated together.
-
-Finally, the `view` member function template returns an iterable portion of entities and components:
-
-```cpp
-auto view = registry.view<Position, Velocity>();
-```
-
-Views are the other core component of `EnTT` and are usually extensively used by softwares that include it. See below for more details about the types of views.
-
-#### The View
-
-There are two types of views:
-
-* **Single component view**.
-
-  A single component view gives direct access to both the components and the entities to which the components are assigned.<br/>
-  This kind of views are created from the `Registry` class by means of the `view` member function template as it follows:
-
-    ```cpp
-    // Actual type is Registry<Components...>::view_type<Comp>, where Comp is the component for which the view should be created ...
-    // ... well, auto is far easier to use in this case, isn't it?
-    auto view = registry.view<Sprite>();
-    ```
-
-  Components and entities are stored in tightly packed arrays and single component views are the fastest solution to iterate them.<br/>
-  They have the _C++11-ish_ `begin` and `end` member function that allow users to use them in a typical range-for loop:
-
-    ```cpp
-    auto view = registry.view<Sprite>();
-
-    for(auto entity: view) {
-        auto &sprite = registry.get<Sprite>(entity);
-        // ...
-    }
-    ```
-
-  Iterating a view this way returns entities that can be further used to get components or perform other activities.<br/>
-  There is also another method one can use to iterate the array of entities, that is by using the `size` and `data` member functions:
-
-    ```cpp
-    auto view = registry.view<Sprite>();
-    const auto *data = view.data();
-
-    for(auto i = 0, end = view.size(); i < end; ++i) {
-        auto entity = *(data + i);
-        // ...
-    }
-    ```
-
-  Entites are good when the sole component isn't enough to perform a task.
-  Anyway they come with a cost: accessing components by entities has an extra level of indirection. It's pretty fast, but not that fast in some cases.<br/>
-  Direct access to the packed array of components is the other option around of a single component view. Member functions `size` and `raw` are there for that:
-
-    ```cpp
-    auto view = registry.view<Sprite>();
-    const auto *raw = view.raw();
-
-    for(auto i = 0, end = view.size(); i < end; ++i) {
-        auto &sprite = *(raw + i);
-        // ...
-    }
-    ```
-
-  This is the fastest solution to iterate over the components: they are packed together by construction and visit them in order will reduce to a minimum the number of cache misses.
-
-* **Multi component view**.
-
-  A multi component view gives access only to the entities to which the components are assigned.<br/>
-  This kind of views are created from the `Registry` class by means of the `view` member function template as it follows:
-
-    ```cpp
-    // Actual type is Registry<Components...>::view_type<Comp...>, where Comp... are the components for which the view should be created ...
-    // ... well, auto is far easier to use in this case, isn't it?
-    auto view = registry.view<Position, Velocity>();
-    ```
-
-  Multi component views can be iterated by means of the `begin` and `end` member functions in a typical range-for loop:
-
-    ```cpp
-    auto view = registry.view<Position, Velocity>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        auto &velocity = registry.get<Velocity>(entity);
-        // ...
-    }
-    ```
-
-  Note that there exists a packed array of entities to which the component is assigned for each component.
-  Iterators of a multi component view pick the shortest array up and use it to visit the smallest set of potential entities.<br/>
-  The choice is performed when the view is constructed. It's good enough as long as views are discarded once they have been used.
-  For all the other cases, the `reset` member function can be used whenever the data within the registry are known to be changed and forcing the choice again could speed up the execution.
-
-  **Note**: one could argue that an iterator should return the set of references to components for each entity instead of the entity itself.
-  Well, who wants to spend CPU cycles to get a reference to an useless tag component? This drove the design choice indeed.
-
-All the views can be used more than once. They return newly created and correctly initialized iterators whenever `begin` or `end` is invoked.
-The same is valid for `data` and `raw` too. Anyway views and iterators are tiny objects and the time spent to construct them can be safely ignored.<br/>
-I'd suggest not to store them anywhere and to invoke the `Registry::view` member function template at each iteration to get a properly initialized view through which to iterate.
-
-#### Side notes
-
-* Entities are numbers and nothing more. They are not classes and they have no member functions at all.
-
-* Most of the _ECS_ available out there have an annoying limitation (at least from my point of view): entities and components cannot be created, assigned or deleted while users are iterating on them.<br/>
-  `EnTT` partially solves the problem with a few limitations:
-
-    * Entities can be created at any time while iterating one or more components.
-    * Components can be assigned to any entity at any time while iterating one or more components.
-    * During an iteration, the current entity (that is the one returned by the iterator) can be deleted and all its components can be removed safely.
-
-  Entities that are not the current one (that is the one returned by the iterator) cannot be deleted from within a loop.<br/>
-  Components assigned to entities that are not the current one (that is the one returned by the iterator) cannot be removed from within a loop.<br/>
-  In this case, iterators are invalidated and the behaviour is undefined if one continues to use those iterators. Possible approaches are:
-
-    * Store aside the entities and components to be removed and perform the operations at the end of the iteration.
-    * Mark entities and components with a proper tag component that indicates that they must be purged, then perform a second iteration to clean them up one by one.
-
-* Iterators aren't thread safe. Do no try to iterate over a set of components and modify them concurrently.<br/>
-  That being said, as long as a thread iterates over the entities that have the component `X` or assign and removes that component from a set of entities and another thread does something similar with components `Y` and `Z`, it shouldn't be a problem at all.<br/>
-  As an example, that means that users can freely run the rendering system over the renderable entities and update the physics concurrently on a separate thread if needed.
+The documentation is based on [doxygen](http://www.stack.nl/~dimitri/doxygen/).
+To build it:
+
+    $ cd build
+    $ cmake .. -DBUILD_DOCS=ON
+    $ make
+
+The API reference will be created in HTML format within the directory
+`build/docs/html`. To navigate it with your favorite browser:
+
+    $ cd build
+    $ your_favorite_browser docs/html/index.html
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+The API reference is also available [online](https://skypjack.github.io/entt/)
+for the latest version.<br/>
+There exists also a [wiki](https://github.com/skypjack/entt/wiki) dedicated to
+the project where users can find all related documentation pages.
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
 
 ## Tests
 
 To compile and run the tests, `EnTT` requires *googletest*.<br/>
-`cmake` will download and compile the library before to compile anything else.
+`cmake` will download and compile the library before compiling anything else.
+In order to build without tests set CMake option `BUILD_TESTING=OFF`.
 
-Then, to build the tests:
+To build the most basic set of tests:
 
 * `$ cd build`
 * `$ cmake ..`
 * `$ make`
 * `$ make test`
 
-To build the benchmarks, use the following line instead:
+Note that benchmarks are not part of this set.
 
-* `$ cmake -DCMAKE_BUILD_TYPE=Release ..`
+# Packaging Tools
 
-Benchmarks are compiled only in release mode currently.
+`EnTT` is available for some of the most known packaging tools. In particular:
 
+* [`vcpkg`](https://github.com/Microsoft/vcpkg/tree/master/ports/entt),
+  Microsoft VC++ Packaging Tool.
+* [`Homebrew`](https://github.com/skypjack/homebrew-entt), the missing package
+  manager for macOS.<br/>
+  Available as a homebrew formula. Just type the following to install it:
+  ```
+  brew install skypjack/entt/entt
+  ```
+
+Consider this list a work in progress and help me to make it longer.
+
+# EnTT in Action
+
+`EnTT` is widely used in private and commercial applications. I cannot even
+mention most of them because of some signatures I put on some documents time
+ago.<br/>
+Fortunately, there are also people who took the time to implement open source
+projects based on EnTT and did not hold back when it came to documenting them.
+
+Below an incomplete list of projects and articles:
+
+* [Minecraft](https://minecraft.net/en-us/attribution/): of course, **that**
+  Minecraft, by Mojang (see the open source attributions page).
+* [Face Smash](https://play.google.com/store/apps/details?id=com.gamee.facesmash):
+  the emojis dominate the world, destroy them all with your facial expressions.
+* [shiva](https://github.com/Milerius/shiva): modern C++ Engine with modularity.
+* [Classic Tower Defence](https://github.com/kerndog73/Classic-Tower-Defence):
+  a tiny little tower defence game featuring a homemade font.
+  [Check it out](https://indi-kernick.itch.io/classic-tower-defence).
+* [The Machine](https://github.com/Kerndog73/The-Machine): a box pushing puzzler
+  with logic gates and other cool stuff.
+  [Check it out](https://indi-kernick.itch.io/the-machine-web-version).
+* [EnttPong](https://github.com/reworks/EnttPong): example game with `EnTT`.
+* [Space Battle: Huge edition](http://victor.madtriangles.com/code%20experiment/2018/06/11/post-ecs-battle-huge.html):
+  huge space battle built entirely from scratch.
+* [Space Battle](https://github.com/vblanco20-1/ECS_SpaceBattle): huge space
+  battle built on `UE4`.
+* [Experimenting with ECS in UE4](http://victor.madtriangles.com/code%20experiment/2018/03/25/post-ue4-ecs-battle.html):
+  interesting article about `UE4` and `EnTT`.
+* [Implementing ECS architecture in UE4](https://forums.unrealengine.com/development-discussion/c-gameplay-programming/1449913-implementing-ecs-architecture-in-ue4-giant-space-battle):
+  giant space battle.
+* [MatchOneEntt](https://github.com/mhaemmerle/MatchOneEntt): port of
+  [Match One](https://github.com/sschmid/Match-One) for `Entitas-CSharp`.
+* [Randballs](https://github.com/gale93/randballs): simple `SFML` and `EnTT`
+  playground.
+* ...
+
+If you know of other resources out there that are about `EnTT`, feel free to
+open an issue or a PR and I'll be glad to add them to the list.
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
 # Contributors
 
-If you want to contribute, please send patches as pull requests against the branch master.<br/>
-Check the [contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to see who has partecipated so far.
+`EnTT` was written initially as a faster alternative to other well known and
+open source entity-component systems. Nowadays this library is moving its first
+steps. Much more will come in the future and hopefully I'm going to work on it
+for a long time.<br/>
+Requests for features, PR, suggestions ad feedback are highly appreciated.
+
+If you find you can help me and want to contribute to the project with your
+experience or you do want to get part of the project for some other reasons,
+feel free to contact me directly (you can find the mail in the
+[profile](https://github.com/skypjack)).<br/>
+I can't promise that each and every contribution will be accepted, but I can
+assure that I'll do my best to take them all seriously.
+
+If you decide to participate, please see the guidelines for
+[contributing](docs/CONTRIBUTING.md) before to create issues or pull requests.<br/>
+Take also a look at the
+[contributors list](https://github.com/skypjack/entt/blob/master/AUTHORS) to
+know who has participated so far.
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
 
 # License
 
-Code and documentation Copyright (c) 2017 Michele Caini.<br/>
-Code released under [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
+Code and documentation Copyright (c) 2017-2018 Michele Caini.<br/>
+Logo Copyright (c) 2018 Richard Caseres.
 
-# Donation
+Code released under
+[the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
+Documentation released under
+[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).<br/>
+Logo released under
+[CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/).
 
-Developing and maintaining `EnTT` takes some time and lots of coffee. If you want to support this project, you can offer me an espresso. I'm from Italy, we're used to turning the best coffee ever in code.<br/>
-Take a look at the donation button at the top of the page for more details or just click [here](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=W2HF9FESD5LJY&lc=IT&item_name=Michele%20Caini&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted).
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Support
+
+## Donation
+
+Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
+to add more and more functionalities in future and turn it in a full-featured
+solution.<br/>
+If you want to support this project, you can offer me an espresso. I'm from
+Italy, we're used to turning the best coffee ever in code. If you find that
+it's not enough, feel free to support me the way you prefer.<br/>
+Take a look at the donation button at the top of the page for more details or
+just click [here](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=W2HF9FESD5LJY&lc=IT&item_name=Michele%20Caini&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donateCC_LG%2egif%3aNonHosted).
+
+## Hire me
+
+If you start using `EnTT` and need help, if you want a new feature and want me
+to give it the highest priority, if you have any other reason to contact me:
+do not hesitate. I'm available for hiring.<br/>
+Feel free to take a look at my [profile](https://github.com/skypjack) and
+contact me by mail.
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->

TODO

@@ -0,0 +1,17 @@
+* custom allocators and EnTT allocator-aware in general (long term feature, I don't actually need it at the moment) - see #22
+* scene management (I prefer the concept of spaces, that is a kind of scene anyway)
+* debugging tools (#60): the issue online already contains interesting tips on this, look at it
+* define basic reactive systems (track entities to which component is attached, track entities from which component is removed, and so on)
+* define systems as composable mixins (initializazion, reactive, update, whatever) with flexible auto-detected arguments (registry, views, etc)
+* registry::create with a "hint" on the entity identifier to use, it should ease combining multiple registries
+* deep copy of a registry (or use the snapshot stuff to copy components and keep intact ids at least)
+* is it possible to iterate all the components assigned to an entity through a common base class?
+* optimize for empty components, it would be a mid improvement in terms of memory usage
+* can we do more for shared libraries? who knows... see #144
+* work stealing job system (see #100)
+* make view copyable/moveable
+* reflection system (maybe)
+* C++17. That's all.
+* AOB
+* lower case names (?)
+* tag_t and the others, create constexpr var

appveyor.yml

@@ -14,7 +14,7 @@ configuration:
 
 before_build:
   - cd %BUILD_DIR%
-  - cmake .. -G"Visual Studio 15 2017"
+  - cmake .. -DCMAKE_CXX_FLAGS=/W1 -G"Visual Studio 15 2017"
 
 build:
   parallel: true

cmake/in/EnTTBuildConfig.cmake.in

@@ -0,0 +1,6 @@
+set(ENTT_VERSION "@PROJECT_VERSION@")
+set(ENTT_INCLUDE_DIRS "@CMAKE_CURRENT_SOURCE_DIR@/src")
+
+if(NOT CMAKE_VERSION VERSION_LESS "3.0")
+    include("${CMAKE_CURRENT_LIST_DIR}/EnTTTargets.cmake")
+endif()

cmake/in/EnTTConfig.cmake.in

@@ -0,0 +1,11 @@
+set(ENTT_VERSION "@PROJECT_VERSION@")
+
+@PACKAGE_INIT@
+
+set_and_check(ENTT_INCLUDE_DIRS "@PACKAGE_CMAKE_INSTALL_INCLUDEDIR@")
+
+if(NOT CMAKE_VERSION VERSION_LESS "3.0")
+    include("${CMAKE_CURRENT_LIST_DIR}/EnTTTargets.cmake")
+endif()
+
+check_required_components("@PROJECT_NAME@")

cmake/in/cereal.in

@@ -0,0 +1,19 @@
+project(cereal-download NONE)
+cmake_minimum_required(VERSION 3.2)
+
+include(ExternalProject)
+
+ExternalProject_Add(
+    cereal
+    GIT_REPOSITORY https://github.com/USCiLab/cereal.git
+    GIT_TAG v1.2.2
+    DOWNLOAD_DIR ${CEREAL_DEPS_DIR}
+    TMP_DIR ${CEREAL_DEPS_DIR}/tmp
+    STAMP_DIR ${CEREAL_DEPS_DIR}/stamp
+    SOURCE_DIR ${CEREAL_DEPS_DIR}/src
+    BINARY_DIR ${CEREAL_DEPS_DIR}/build
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    TEST_COMMAND ""
+)

cmake/in/duktape.in

@@ -0,0 +1,19 @@
+project(duktape-download NONE)
+cmake_minimum_required(VERSION 3.2)
+
+include(ExternalProject)
+
+ExternalProject_Add(
+    duktape
+    GIT_REPOSITORY https://github.com/svaarala/duktape-releases.git
+    GIT_TAG v2.2.0
+    DOWNLOAD_DIR ${DUKTAPE_DEPS_DIR}
+    TMP_DIR ${DUKTAPE_DEPS_DIR}/tmp
+    STAMP_DIR ${DUKTAPE_DEPS_DIR}/stamp
+    SOURCE_DIR ${DUKTAPE_DEPS_DIR}/src
+    BINARY_DIR ${DUKTAPE_DEPS_DIR}/build
+    CONFIGURE_COMMAND ""
+    BUILD_COMMAND ""
+    INSTALL_COMMAND ""
+    TEST_COMMAND ""
+)

cmake/in/googletest.in

@@ -6,7 +6,7 @@ include(ExternalProject)
 ExternalProject_Add(
     googletest
     GIT_REPOSITORY https://github.com/google/googletest.git
-    GIT_TAG release-1.8.0
+    GIT_TAG master
     DOWNLOAD_DIR ${GOOGLETEST_DEPS_DIR}
     TMP_DIR ${GOOGLETEST_DEPS_DIR}/tmp
     STAMP_DIR ${GOOGLETEST_DEPS_DIR}/stamp

docs/CMakeLists.txt

@@ -0,0 +1,36 @@
+#
+# Doxygen configuration (documentation)
+#
+
+set(DOXY_SOURCE_DIRECTORY ${EnTT_SOURCE_DIR}/src)
+set(DOXY_DOCS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+set(DOXY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+
+configure_file(doxy.in doxy.cfg @ONLY)
+
+add_custom_target(
+    docs ALL
+    COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doxy.cfg
+    WORKING_DIRECTORY ${EnTT_SOURCE_DIR}
+    VERBATIM
+    SOURCES doxy.in
+)
+
+install(
+    DIRECTORY ${DOXY_OUTPUT_DIRECTORY}/html
+    DESTINATION share/${PROJECT_NAME}-${PROJECT_VERSION}/
+)
+
+add_custom_target(
+    docs_aob
+    SOURCES
+        CONTRIBUTING.md
+        core.md
+        entity.md
+        locator.md
+        process.md
+        resource.md
+        shared.md
+        signal.md
+        extra.dox
+)

docs/CONTRIBUTING.md

@@ -0,0 +1,43 @@
+# Contributing
+
+First of all, thank you very much for taking the time to contribute to the
+`EnTT` framework.<br/>
+How to do it mostly depends on the type of contribution:
+
+* If you have a question, **please** ensure there isn't already an answer for
+  you by searching on GitHub under
+  [issues](https://github.com/skypjack/entt/issues). Do not forget to search
+  also through the closed ones. If you are unable to find a proper answer, feel
+  free to [open a new issue](https://github.com/skypjack/entt/issues/new).
+  Usually, questions are marked as such and closed in a few days.
+
+* If you want to fix a typo in the inline documentation or in the README file,
+  if you want to add some new sections or if you want to help me with the
+  language by reviewing what I wrote so far (I'm not a native speaker after
+  all), **please** open a new
+  [pull request](https://github.com/skypjack/entt/pulls) with your changes.
+
+* If you found a bug, **please** ensure there isn't already an answer for you by
+  searching on GitHub under [issues](https://github.com/skypjack/entt/issues).
+  If you are unable to find an open issue addressing the problem, feel free to
+  [open a new one](https://github.com/skypjack/entt/issues/new). **Please**, do
+  not forget to carefully describe how to reproduce the problem, then add all
+  the informaion about the system on which you are experiencing it and point out
+  the version of `EnTT` you are using (tag or commit).
+
+* If you found a bug and you wrote a patch to fix it, open a new
+  [pull request](https://github.com/skypjack/entt/pulls) with your code.
+  **Please**, add some tests to avoid regressions in future if possible, it
+  would be really appreciated. Note that the `EnTT` framework has a
+  [coverage at 100%](https://coveralls.io/github/skypjack/entt?branch=master)
+  (at least it was at 100% at the time I wrote this file) and this is the reason
+  for which you can be confident with using it in a production environment.
+
+* If you want to propose a new feature and you know how to code it, **please**
+  do not issue directly a pull request. Before to do it,
+  [create a new issue](https://github.com/skypjack/entt/issues/new) to discuss
+  your proposal. Other users could be interested in your idea and the discussion
+  that will follow can refine it and therefore give us a better solution.
+
+* If you want to request a new feature, I'm available for hiring. Take a look at
+  [my profile](https://github.com/skypjack) and feel free to write me.

docs/core.md

@@ -0,0 +1,167 @@
+# Crash Course: core functionalities
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [Compile-time identifiers](#compile-time-identifiers)
+* [Runtime identifiers](#runtime-identifiers)
+* [Hashed strings](#hashed-strings)
+  * [Conflicts](#conflicts)
+* [Monostate](#monostate)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+`EnTT` comes with a bunch of core functionalities mostly used by the other parts
+of the library itself.<br/>
+Hardly users will include these features in their code, but it's worth
+describing what `EnTT` offers so as not to reinvent the wheel in case of need.
+
+# Compile-time identifiers
+
+Sometimes it's useful to be able to give unique identifiers to types at
+compile-time.<br/>
+There are plenty of different solutions out there and I could have used one of
+them. However, I decided to spend my time to define a compact and versatile tool
+that fully embraces what the modern C++ has to offer.
+
+The _result of my efforts_ is the `Identifier` class template:
+
+```cpp
+#include <ident.hpp>
+
+// defines the identifiers for the given types
+using ID = entt::Identifier<AType, AnotherType>;
+
+// ...
+
+switch(aTypeIdentifier) {
+case ID::get<AType>():
+    // ...
+    break;
+case ID::get<AnotherType>():
+    // ...
+    break;
+default:
+    // ...
+}
+```
+
+This is all what the class template has to offer: a static `get` member function
+that returns a numerical identifier for the given type. It can be used in any
+context where constant expressions are required.
+
+As long as the list remains unchanged, identifiers are also guaranteed to be the
+same for every run. In case they have been used in a production environment and
+a type has to be removed, one can just use a placeholder to left the other
+identifiers unchanged:
+
+```cpp
+template<typename> struct IgnoreType {};
+
+using ID = entt::Identifier<
+    ATypeStillValid,
+    IgnoreType<ATypeNoLongerValid>,
+    AnotherTypeStillValid
+>;
+```
+
+A bit ugly to see, but it works at least.
+
+# Runtime identifiers
+
+Sometimes it's useful to be able to give unique identifiers to types at
+runtime.<br/>
+There are plenty of different solutions out there and I could have used one of
+them. In fact, I adapted the most common one to my requirements and used it
+extensively within the entire library.
+
+It's the `Family` class. Here is an example of use directly from the
+entity-component system:
+
+```cpp
+using component_family = entt::Family<struct InternalRegistryComponentFamily>;
+
+// ...
+
+template<typename Component>
+component_type component() const noexcept {
+    return component_family::type<Component>();
+}
+```
+
+This is all what a _family_ has to offer: a `type` member function that returns
+a numerical identifier for the given type.
+
+Please, note that identifiers aren't guaranteed to be the same for every run.
+Indeed it mostly depends on the flow of execution.
+
+# Hashed strings
+
+A hashed string is a zero overhead resource identifier. Users can use
+human-readable identifiers in the codebase while using their numeric
+counterparts at runtime, thus without affecting performance.<br/>
+The class has an implicit `constexpr` constructor that chews a bunch of
+characters. Once created, all what one can do with it is getting back the
+original string or converting it into a number.<br/>
+The good part is that a hashed string can be used wherever a constant expression
+is required and no _string-to-number_ conversion will take place at runtime if
+used carefully.
+
+Example of use:
+
+```cpp
+auto load(entt::HashedString::hash_type resource) {
+    // uses the numeric representation of the resource to load and return it
+}
+
+auto resource = load(entt::HashedString{"gui/background"});
+```
+
+There is also a _user defined literal_ dedicated to hashed strings to make them
+more user-friendly:
+
+```cpp
+constexpr auto str = "text"_hs;
+```
+
+## Conflicts
+
+The hashed string class uses internally FNV-1a to compute the numeric
+counterpart of a string. Because of the _pigeonhole principle_, conflicts are
+possible. This is a fact.<br/>
+There is no silver bullet to solve the problem of conflicts when dealing with
+hashing functions. In this case, the best solution seemed to be to give up.
+That's all.<br/>
+After all, human-readable resource identifiers aren't something strictly defined
+and over which users have not the control. Choosing a slightly different
+identifier is probably the best solution to make the conflict disappear in this
+case.
+
+# Monostate
+
+The monostate pattern is often presented as an alternative to a singleton based
+configuration system. This is exactly its purpose in `EnTT`. Moreover, this
+implementation is thread safe by design (hopefully).<br/>
+Keys are represented by hashed strings, values are basic types like `int`s or
+`bool`s. Values of different types can be associated to each key, even more than
+one at a time. Because of this, users must pay attention to use the same type
+both during an assignment and when they try to read back their data. Otherwise,
+they will probably incur in unexpected results.
+
+Example of use:
+
+```cpp
+entt::Monostate<entt::HashedString{"mykey"}>{} = true;
+entt::Monostate<"mykey"_hs>{} = 42;
+
+// ...
+
+const bool b = entt::Monostate<"mykey"_hs>{};
+const int i = entt::Monostate<entt::HashedString{"mykey"}>{};
+```

docs/extra.dox

@@ -0,0 +1,5 @@
+/**
+ * @namespace entt
+ *
+ * @brief `EnTT` default namespace.
+ */

docs/locator.md

@@ -0,0 +1,75 @@
+# Crash Course: service locator
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [Service locator](#service-locator)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+Usually service locators are tightly bound to the services they expose and it's
+hard to define a general purpose solution. This template based implementation
+tries to fill the gap and to get rid of the burden of defining a different
+specific locator for each application.<br/>
+This class is tiny, partially unsafe and thus risky to use. Moreover it doesn't
+fit probably most of the scenarios in which a service locator is required. Look
+at it as a small tool that can sometimes be useful if users know how to handle
+it.
+
+# Service locator
+
+The API is straightforward. The basic idea is that services are implemented by
+means of interfaces and rely on polymorphism.<br/>
+The locator is instantiated with the base type of the service if any and a
+concrete implementation is provided along with all the parameters required to
+initialize it. As an example:
+
+```cpp
+// the service has no base type, a locator is used to treat it as a kind of singleton
+entt::ServiceLocator<MyService>::set(params...);
+
+// sets up an opaque service
+entt::ServiceLocator<AudioInterface>::set<AudioImplementation>(params...);
+
+// resets (destroys) the service
+entt::ServiceLocator<AudioInterface>::reset();
+```
+
+The locator can also be queried to know if an active service is currently set
+and to retrieve it if necessary (either as a pointer or as a reference):
+
+```cpp
+// no service currently set
+auto empty = entt::ServiceLocator<AudioInterface>::empty();
+
+// gets a (possibly empty) shared pointer to the service ...
+std::shared_ptr<AudioInterface> ptr = entt::ServiceLocator<AudioInterface>::get();
+
+// ... or a reference, but it's undefined behaviour if the service isn't set yet
+AudioInterface &ref = entt::ServiceLocator<AudioInterface>::ref();
+```
+
+A common use is to wrap the different locators in a container class, creating
+aliases for the various services:
+
+```cpp
+struct Locator {
+    using Camera = entt::ServiceLocator<CameraInterface>;
+    using Audio = entt::ServiceLocator<AudioInterface>;
+    // ...
+};
+
+// ...
+
+void init() {
+    Locator::Camera::set<CameraNull>();
+    Locator::Audio::set<AudioImplementation>(params...);
+    // ...
+}
+```

docs/process.md

@@ -0,0 +1,211 @@
+# Crash Course: cooperative scheduler
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [The process](#the-process)
+  * [Adaptor](#adaptor)
+* [The scheduler](#the-scheduler)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+Sometimes processes are a useful tool to work around the strict definition of a
+system and introduce logic in a different way, usually without resorting to the
+introduction of other components.
+
+`EnTT` offers a minimal support to this paradigm by introducing a few classes
+that users can use to define and execute cooperative processes.
+
+# The process
+
+A typical process must inherit from the `Process` class template that stays true
+to the CRTP idiom. Moreover, derived classes must specify what's the intended
+type for elapsed times.
+
+A process should expose publicly the following member functions whether
+required (note that it isn't required to define a function unless the derived
+class wants to _override_ the default behavior):
+
+* `void update(Delta, void *);`
+
+  It's invoked once per tick until a process is explicitly aborted or it
+  terminates either with or without errors. Even though it's not mandatory to
+  declare this member function, as a rule of thumb each process should at
+  least define it to work properly. The `void *` parameter is an opaque pointer
+  to user data (if any) forwarded directly to the process during an update.
+
+* `void init(void *);`
+
+  It's invoked at the first tick, immediately before an update. The `void *`
+  parameter is an opaque pointer to user data (if any) forwarded directly to the
+  process during an update.
+
+* `void succeeded();`
+
+  It's invoked in case of success, immediately after an update and during the
+  same tick.
+
+* `void failed();`
+
+  It's invoked in case of errors, immediately after an update and during the
+  same tick.
+
+* `void aborted();`
+
+  It's invoked only if a process is explicitly aborted. There is no guarantee
+  that it executes in the same tick, this depends solely on whether the
+  process is aborted immediately or not.
+
+Derived classes can also change the internal state of a process by invoking
+`succeed` and `fail`, as well as `pause` and `unpause` the process itself. All
+these are protected member functions made available to be able to manage the
+life cycle of a process from a derived class.
+
+Here is a minimal example for the sake of curiosity:
+
+```cpp
+struct MyProcess: entt::Process<MyProcess, std::uint32_t> {
+    using delta_type = std::uint32_t;
+
+    void update(delta_type delta, void *) {
+        remaining = delta > remaining ? delta_type{] : (remaining - delta);
+
+        // ...
+
+        if(!remaining) {
+            succeed();
+        }
+    }
+
+    void init(void *data) {
+        remaining = *static_cast<delta_type *>(data);
+    }
+
+private:
+    delta_type remaining;
+};
+```
+
+## Adaptor
+
+Lambdas and functors can't be used directly with a scheduler for they are not
+properly defined processes with managed life cycles.<br/>
+This class helps in filling the gap and turning lambdas and functors into
+full featured processes usable by a scheduler.
+
+The function call operator has a signature similar to the one of the `update`
+function of a process but for the fact that it receives two extra arguments to
+call whenever a process is terminated with success or with an error:
+
+```cpp
+void(Delta delta, void *data, auto succeed, auto fail);
+```
+
+Parameters have the following meaning:
+
+* `delta` is the elapsed time.
+* `data` is an opaque pointer to user data if any, `nullptr` otherwise.
+* `succeed` is a function to call when a process terminates with success.
+* `fail` is a function to call when a process terminates with errors.
+
+Both `succeed` and `fail` accept no parameters at all.
+
+Note that usually users shouldn't worry about creating adaptors at all. A
+scheduler creates them internally each and every time a lambda or a functor is
+used as a process.
+
+# The scheduler
+
+A cooperative scheduler runs different processes and helps managing their life
+cycles.
+
+Each process is invoked once per tick. If it terminates, it's removed
+automatically from the scheduler and it's never invoked again. Otherwise it's
+a good candidate to run once more the next tick.<br/>
+A process can also have a child. In this case, the process is replaced with
+its child when it terminates if it returns with success. In case of errors,
+both the process and its child are discarded. This way, it's easy to create
+chain of processes to run sequentially.
+
+Using a scheduler is straightforward. To create it, users must provide only the
+type for the elapsed times and no arguments at all:
+
+```cpp
+Scheduler<std::uint32_t> scheduler;
+```
+
+It has member functions to query its internal data structures, like `empty` or
+`size`, as well as a `clear` utility to reset it to a clean state:
+
+```cpp
+// checks if there are processes still running
+const auto empty = scheduler.empty();
+
+// gets the number of processes still running
+Scheduler<std::uint32_t>::size_type size = scheduler.size();
+
+// resets the scheduler to its initial state and discards all the processes
+scheduler.clear();
+```
+
+To attach a process to a scheduler there are mainly two ways:
+
+* If the process inherits from the `Process` class template, it's enough to
+  indicate its type and submit all the parameters required to construct it to
+  the `attach` member function:
+
+  ```cpp
+  scheduler.attach<MyProcess>("foobar");
+  ```
+
+* Otherwise, in case of a lambda or a functor, it's enough to provide an
+  instance of the class to the `attach` member function:
+
+  ```cpp
+  scheduler.attach([](auto...){ /* ... */ });
+  ```
+
+In both cases, the return value is an opaque object that offers a `then` member
+function to use to create chains of processes to run sequentially.<br/>
+As a minimal example of use:
+
+```cpp
+// schedules a task in the form of a lambda function
+scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
+    // ...
+})
+// appends a child in the form of another lambda function
+.then([](auto delta, void *, auto succeed, auto fail) {
+    // ...
+})
+// appends a child in the form of a process class
+.then<MyProcess>();
+```
+
+To update a scheduler and thus all its processes, the `update` member function
+is the way to go:
+
+```cpp
+// updates all the processes, no user data are provided
+scheduler.update(delta);
+
+// updates all the processes and provides them with custom data
+scheduler.update(delta, &data);
+```
+
+In addition to these functions, the scheduler offers an `abort` member function
+that can be used to discard all the running processes at once:
+
+```cpp
+// aborts all the processes abruptly ...
+scheduler.abort(true);
+
+// ... or gracefully during the next tick
+scheduler.abort();
+```

docs/resource.md

@@ -0,0 +1,240 @@
+# Crash Course: resource management
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [The resource, the loader and the cache](#the-resource-the-loader-and-the-cache)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+Resource management is usually one of the most critical part of a software like
+a game. Solutions are often tuned to the particular application. There exist
+several approaches and all of them are perfectly fine as long as they fit the
+requirements of the piece of software in which they are used.<br/>
+Examples are loading everything on start, loading on request, predictive
+loading, and so on.
+
+`EnTT` doesn't pretend to offer a _one-fits-all_ solution for the different
+cases. Instead, it offers a minimal and perhaps trivial cache that can be useful
+most of the time during prototyping and sometimes even in a production
+environment.<br/>
+For those interested in the subject, the plan is to improve it considerably over
+time in terms of performance, memory usage and functionalities. Hoping to make
+it, of course, one step at a time.
+
+# The resource, the loader and the cache
+
+There are three main actors in the model: the resource, the loader and the
+cache.
+
+The _resource_ is whatever users want it to be. An image, a video, an audio,
+whatever. There are no limits.<br/>
+As a minimal example:
+
+```cpp
+struct MyResource { const int value; };
+```
+
+A _loader_ is a class the aim of which is to load a specific resource. It has to
+inherit directly from the dedicated base class as in the following example:
+
+```cpp
+struct MyLoader final: entt::ResourceLoader<MyLoader, MyResource> {
+    // ...
+};
+```
+
+Where `MyResource` is the type of resources it creates.<br/>
+A resource loader must also expose a public const member function named `load`
+that accepts a variable number of arguments and returns a shared pointer to a
+resource.<br/>
+As an example:
+
+```cpp
+struct MyLoader: entt::ResourceLoader<MyLoader, MyResource> {
+    std::shared_ptr<MyResource> load(int value) const {
+        // ...
+        return std::shared_ptr<MyResource>(new MyResource{ value });
+    }
+};
+```
+
+In general, resource loaders should not have a state or retain data of any type.
+They should let the cache manage their resources instead.<br/>
+As a side note, base class and CRTP idiom aren't strictly required with the
+current implementation. One could argue that a cache can easily work with
+loaders of any type. However, future changes won't be breaking ones by forcing
+the use of a base class today and that's why the model is already in its place.
+
+Finally, a cache is a specialization of a class template tailored to a specific
+resource:
+
+```cpp
+using MyResourceCache = entt::ResourceCache<MyResource>;
+
+// ...
+
+MyResourceCache cache{};
+```
+
+The idea is to create different caches for different types of resources and to
+manage each one independently and in the most appropriate way.<br/>
+As a (very) trivial example, audio tracks can survive in most of the scenes of
+an application while meshes can be associated with a single scene and then
+discarded when users leave it.
+
+A cache offers a set of basic functionalities to query its internal state and to
+_organize_ it:
+
+```cpp
+// gets the number of resources managed by a cache
+const auto size = cache.size();
+
+// checks if a cache contains at least a valid resource
+const auto empty = cache.empty();
+
+// clears a cache and discards its content
+cache.clear();
+```
+
+Besides these member functions, it contains what is needed to load, use and
+discard resources of the given type.<br/>
+Before to explore this part of the interface, it makes sense to mention how
+resources are identified. The type of the identifiers to use is defined as:
+
+```cpp
+entt::ResourceCache<Resource>::resource_type
+```
+
+Where `resource_type` is an alias for `entt::HashedString`. Therefore, resource
+identifiers are created explicitly as in the following example:
+
+```cpp
+constexpr auto identifier = entt::ResourceCache<Resource>::resource_type{"my/resource/identifier"};
+// this is equivalent to the following
+constexpr auto hs = entt::HashedString{"my/resource/identifier"};
+```
+
+The class `HashedString` is described in a dedicated section, so I won't do in
+details here.
+
+Resources are loaded and thus stored in a cache through the `load` member
+function. It accepts the loader to use as a template parameter, the resource
+identifier and the parameters used to construct the resource as arguments:
+
+```cpp
+// uses the identifier declared above
+cache.load<MyLoader>(identifier, 0);
+
+// uses a const char * directly as an identifier
+cache.load<MyLoader>("another/identifier", 42);
+```
+
+The return value can be used to know if the resource has been loaded correctly.
+In case the loader returns an invalid pointer or the resource already exists in
+the cache, a false value is returned:
+
+```cpp
+if(!cache.load<MyLoader>("another/identifier", 42)) {
+    // ...
+}
+```
+
+Unfortunately, in this case there is no way to know what was the problem
+exactly. However, before trying to load a resource or after an error, one can
+use the `contains` member function to know if a cache already contains a
+specific resource:
+
+```cpp
+auto exists = cache.contains("my/identifier");
+```
+
+There exists also a member function to use to force a reload of an already
+existing resource if needed:
+
+```cpp
+auto result = cache.reload<MyLoader>("another/identifier", 42);
+```
+
+As above, the function returns true in case of success, false otherwise. The
+sole difference in this case is that an error necessarily means that the loader
+has failed for some reasons to load the resource.<br/>
+Note that the `reload` member function is a kind of alias of the following
+snippet:
+
+```cpp
+cache.discard(identifier);
+cache.load<MyLoader>(identifier, 42);
+```
+
+Where the `discard` member function is used to get rid of a resource if loaded.
+In case the cache doesn't contain a resource for the given identifier, the
+function does nothing and returns immediately.
+
+So far, so good. Resources are finally loaded and stored within the cache.<br/>
+They are returned to users in the form of handles. To get one of them:
+
+```cpp
+auto handle = cache.handle("my/identifier");
+```
+
+The idea behind a handle is the same of the flyweight pattern. In other terms,
+resources aren't copied around. Instead, instances are shared between handles.
+Users of a resource owns a handle and it guarantees that a resource isn't
+destroyed until all the handles are destroyed, even if the resource itself is
+removed from the cache.<br/>
+Handles are tiny objects both movable and copyable. They returns the contained
+resource as a const reference on request:
+
+* By means of the `get` member function:
+
+  ```cpp
+  const auto &resource = handle.get();
+  ```
+
+* Using the proper cast operator:
+
+  ```cpp
+  const auto &resource = handle;
+  ```
+
+* Through the dereference operator:
+
+  ```cpp
+  const auto &resource = *handle;
+  ```
+
+The resource can also be accessed directly using the arrow operator if required:
+
+```cpp
+auto value = handle->value;
+```
+
+To test if a handle is still valid, the cast operator to `bool` allows users to
+use it in a guard:
+
+```cpp
+if(handle) {
+    // ...
+}
+```
+
+Finally, in case there is the need to load a resource and thus to get a handle
+without storing the resource itself in the cache, users can rely on the `temp`
+member function template.<br/>
+The declaration is similar to the one of `load` but for the fact that it doesn't
+return a boolean value. Instead, it returns a (possibly invalid) handle for the
+resource:
+
+```cpp
+auto handle = cache.temp<MyLoader>("another/identifier", 42);
+```
+
+Do not forget to test the handle for validity. Otherwise, getting the reference
+to the resource it points may result in undefined behavior.

docs/shared.md

@@ -0,0 +1,39 @@
+### EnTT and shared libraries
+
+To make sure that an application and a shared library that use both `EnTT` can
+interact correctly when symbols are hidden by default, there are some tricks to
+follow.<br/>
+In particular and in order to avoid undefined behaviors, all the instantiation
+of the `Family` class template shall be made explicit along with the system-wide
+specifier to use to export them.
+
+At the time I'm writing this document, the classes that use internally the above
+mentioned class template are `Dispatcher`, `Emitter` and `Registry`. Therefore
+and as an example, if you use the `Registry` class template in your shared
+library and want to set symbols visibility to _hidden_ by default, the following
+lines are required to allow it to function properly with a client that also uses
+the `Registry` somehow:
+
+* On GNU/Linux:
+
+  ```cpp
+  namespace entt {
+      template class __attribute__((visibility("default"))) Family<struct InternalRegistryTagFamily>;
+      template class __attribute__((visibility("default"))) Family<struct InternalRegistryComponentFamily>;
+      template class __attribute__((visibility("default"))) Family<struct InternalRegistryHandlerFamily>;
+  }
+  ```
+
+* On Windows:
+
+  ```cpp
+  namespace entt {
+      template class __declspec(dllexport) Family<struct InternalRegistryTagFamily>;
+      template class __declspec(dllexport) Family<struct InternalRegistryComponentFamily>;
+      template class __declspec(dllexport) Family<struct InternalRegistryHandlerFamily>;
+  }
+  ```
+
+Otherwise, the risk is that type identifiers are different between the shared
+library and the application and this will prevent the whole thing from
+functioning correctly for obvious reasons.

docs/signal.md

@@ -0,0 +1,412 @@
+# Crash Course: events, signals and everything in between
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [Signals](#signals)
+* [Delegate](#delegate)
+* [Event dispatcher](#event-dispatcher)
+* [Event emitter](#event-emitter)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+Signals are usually a core part of games and software architectures in
+general.<br/>
+Roughly speaking, they help to decouple the various parts of a system while
+allowing them to communicate with each other somehow.
+
+The so called _modern C++_ comes with a tool that can be useful in these terms,
+the `std::function`. As an example, it can be used to create delegates.<br/>
+However, there is no guarantee that an `std::function` does not perform
+allocations under the hood and this could be problematic sometimes. Furthermore,
+it solves a problem but may not adapt well to other requirements that may arise
+from time to time.
+
+In case that the flexibility and potential of an `std::function` are not
+required or where you are looking for something different, `EnTT` offers a full
+set of classes to solve completely different problems.
+
+# Signals
+
+Signal handlers work with naked pointers, function pointers and pointers to
+member functions. Listeners can be any kind of objects and users are in charge
+of connecting and disconnecting them from a signal to avoid crashes due to
+different lifetimes. On the other side, performance shouldn't be affected that
+much by the presence of such a signal handler.<br/>
+A signal handler can be used as a private data member without exposing any
+_publish_ functionality to the clients of a class. The basic idea is to impose a
+clear separation between the signal itself and its _sink_ class, that is a tool
+to be used to connect and disconnect listeners on the fly.
+
+The API of a signal handler is straightforward. The most important thing is that
+it comes in two forms: with and without a collector. In case a signal is
+associated with a collector, all the values returned by the listeners can be
+literally _collected_ and used later by the caller. Otherwise it works just like
+a plain signal that emits events from time to time.<br/>
+
+**Note**: collectors are allowed only in case of function types whose the return
+type isn't `void` for obvious reasons.
+
+To create instances of signal handlers there exist mainly two ways:
+
+```cpp
+// no collector type
+entt::SigH<void(int, char)> signal;
+
+// explicit collector type
+entt::SigH<void(int, char), MyCollector<bool>> collector;
+```
+
+As expected, they offer all the basic functionalities required to know how many
+listeners they contain (`size`) or if they contain at least a listener (`empty`)
+and even to swap two signal handlers (`swap`).
+
+Besides them, there are member functions to use both to connect and disconnect
+listeners in all their forms by means of a sink:
+
+```cpp
+void foo(int, char) { /* ... */ }
+
+struct S {
+    void bar(int, char) { /* ... */ }
+};
+
+// ...
+
+S instance;
+
+signal.sink().connect<&foo>();
+signal.sink().connect<S, &S::bar>(&instance);
+
+// ...
+
+// disconnects a free function
+signal.sink().disconnect<&foo>();
+
+// disconnect a specific member function of an instance ...
+signal.sink().disconnect<S, &S::bar>(&instance);
+
+// ... or an instance as a whole
+signal.sink().disconnect(&instance);
+
+// discards all the listeners at once
+signal.sink().disconnect();
+```
+
+Once listeners are attached (or even if there are no listeners at all), events
+and data in general can be published through a signal by means of the `publish`
+member function:
+
+```cpp
+signal.publish(42, 'c');
+```
+
+To collect data, the `collect` member function should be used instead. Below is
+a minimal example to show how to use it:
+
+```cpp
+struct MyCollector {
+    std::vector<int> vec{};
+
+    bool operator()(int v) noexcept {
+        vec.push_back(v);
+        return true;
+    }
+};
+
+int f() { return 0; }
+int g() { return 1; }
+
+// ...
+
+entt::SigH<int(), MyCollector<int>> signal;
+
+signal.sink().connect<&f>();
+signal.sink().connect<&g>();
+
+MyCollector collector = signal.collect();
+
+assert(collector.vec[0] == 0);
+assert(collector.vec[1] == 1);
+```
+
+As shown above, a collector must expose a function operator that accepts as an
+argument a type to which the return type of the listeners can be converted.
+Moreover, it has to return a boolean value that is false to stop collecting
+data, true otherwise. This way one can avoid calling all the listeners in case
+it isn't necessary.
+
+# Delegate
+
+A delegate can be used as general purpose invoker with no memory overhead for
+free functions and member functions provided along with an instance on which
+to invoke them.<br/>
+It does not claim to be a drop-in replacement for an `std::function`, so do not
+expect to use it whenever an `std::function` fits well. However, it can be used
+to send opaque delegates around to be used to invoke functions as needed.
+
+The interface is trivial. It offers a default constructor to create empty
+delegates:
+
+```cpp
+entt::Delegate<int(int)> delegate{};
+```
+
+All what is needed to create an instance is to specify the type of the function
+the delegate will _contain_, that is the signature of the free function or the
+member function one wants to assign to it.
+
+Attempting to use an empty delegate by invoking its function call operator
+results in undefined behavior, most likely a crash actually. Before to use a
+delegate, it must be initialized.<br/>
+There exist two functions to do that, both named `connect`:
+
+```cpp
+int f(int i) { return i; }
+
+struct MyStruct {
+    int f(int i) { return i }
+};
+
+// bind a free function to the delegate
+delegate.connect<&f>();
+
+// bind a member function to the delegate
+MyStruct instance;
+delegate.connect<MyStruct, &MyStruct::f>(&instance);
+```
+
+It hasn't a `disconnect` counterpart. Instead, there exists a `reset` member
+function to clear it.<br/>
+The `empty` member function can be used to know if a delegate is empty:
+
+```cpp
+const auto empty = delegate.empty();
+```
+
+Finally, to invoke a delegate, the function call operator is the way to go as
+usual:
+
+```cpp
+auto ret = delegate(42);
+```
+
+Probably too much small and pretty poor of functionalities, but the delegate
+class can help in a lot of cases and it has shown that it is worth keeping it
+within the library.
+
+# Event dispatcher
+
+The event dispatcher class is designed so as to be used in a loop. It allows
+users both to trigger immediate events or to queue events to be published all
+together once per tick.<br/>
+This class shares part of its API with the one of the signal handler, but it
+doesn't require that all the types of events are specified when declared:
+
+```cpp
+// define a general purpose dispatcher that works with naked pointers
+entt::Dispatcher dispatcher{};
+```
+
+In order to register an instance of a class to a dispatcher, its type must
+expose one or more member functions of which the return types are `void` and the
+argument lists are `const E &`, for each type of event `E`.<br/>
+To ease the development, member functions that are named `receive` are
+automatically detected and have not to be explicitly specified when registered.
+In all the other cases, the name of the member function aimed to receive the
+event must be provided to the `connect` member function of the sink bound to the
+specific event:
+
+```cpp
+struct AnEvent { int value; };
+struct AnotherEvent {};
+
+struct Listener
+{
+    void receive(const AnEvent &) { /* ... */ }
+    void method(const AnotherEvent &) { /* ... */ }
+};
+
+// ...
+
+Listener listener;
+dispatcher.sink<AnEvent>().connect(&listener);
+dispatcher.sink<AnotherEvent>().connect<Listener, &Listener::method>(&listener);
+```
+
+The `disconnect` member function follows the same pattern and can be used to
+selectively remove listeners:
+
+```cpp
+dispatcher.sink<AnEvent>().disconnect(&listener);
+dispatcher.sink<AnotherEvent>().disconnect<Listener, &Listener::method>(&listener);
+```
+
+The `trigger` member function serves the purpose of sending an immediate event
+to all the listeners registered so far. It offers a convenient approach that
+relieves users from having to create the event itself. Instead, it's enough to
+specify the type of event and provide all the parameters required to construct
+it.<br/>
+As an example:
+
+```cpp
+dispatcher.trigger<AnEvent>(42);
+dispatcher.trigger<AnotherEvent>();
+```
+
+Listeners are invoked immediately, order of execution isn't guaranteed. This
+method can be used to push around urgent messages like an _is terminating_
+notification on a mobile app.
+
+On the other hand, the `enqueue` member function queues messages together and
+allows to maintain control over the moment they are sent to listeners. The
+signature of this method is more or less the same of `trigger`:
+
+```cpp
+dispatcher.enqueue<AnEvent>(42);
+dispatcher.enqueue<AnotherEvent>();
+```
+
+Events are stored aside until the `update` member function is invoked, then all
+the messages that are still pending are sent to the listeners at once:
+
+```cpp
+// emits all the events of the given type at once
+dispatcher.update<MyEvent>();
+
+// emits all the events queued so far at once
+dispatcher.update();
+```
+
+This way users can embed the dispatcher in a loop and literally dispatch events
+once per tick to their systems.
+
+# Event emitter
+
+A general purpose event emitter thought mainly for those cases where it comes to
+working with asynchronous stuff.<br/>
+Originally designed to fit the requirements of
+[`uvw`](https://github.com/skypjack/uvw) (a wrapper for `libuv` written in
+modern C++), it was adapted later to be included in this library.
+
+To create a custom emitter type, derived classes must inherit directly from the
+base class as:
+
+```cpp
+struct MyEmitter: Emitter<MyEmitter> {
+    // ...
+}
+```
+
+The full list of accepted types of events isn't required. Handlers are created
+internally on the fly and thus each type of event is accepted by default.
+
+Whenever an event is published, an emitter provides the listeners with a
+reference to itself along with a const reference to the event. Therefore
+listeners have an handy way to work with it without incurring in the need of
+capturing a reference to the emitter itself.<br/>
+In addition, an opaque object is returned each time a connection is established
+between an emitter and a listener, allowing the caller to disconnect them at a
+later time.<br/>
+The opaque object used to handle connections is both movable and copyable. On
+the other side, an event emitter is movable but not copyable by default.
+
+To create new instances of an emitter, no arguments are required:
+
+```cpp
+MyEmitter emitter{};
+```
+
+Listeners must be movable and callable objects (free functions, lambdas,
+functors, `std::function`s, whatever) whose function type is:
+
+```cpp
+void(const Event &, MyEmitter &)
+```
+
+Where `Event` is the type of event they want to listen.<br/>
+There are two ways to attach a listener to an event emitter that differ
+slightly from each other:
+
+* To register a long-lived listener, use the `on` member function. It is meant
+  to register a listener designed to be invoked more than once for the given
+  event type.<br/>
+  As an example:
+
+  ```cpp
+  auto conn = emitter.on<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
+      // ...
+  });
+  ```
+
+  The connection object can be freely discarded. Otherwise, it can be used later
+  to disconnect the listener if required.
+
+* To register a short-lived listener, use the `once` member function. It is
+  meant to register a listener designed to be invoked only once for the given
+  event type. The listener is automatically disconnected after the first
+  invocation.<br/>
+  As an example:
+
+  ```cpp
+  auto conn = emitter.once<MyEvent>([](const MyEvent &event, MyEmitter &emitter) {
+      // ...
+  });
+  ```
+
+  The connection object can be freely discarded. Otherwise, it can be used later
+  to disconnect the listener if required.
+
+In both cases, the connection object can be used with the `erase` member
+function:
+
+```cpp
+emitter.erase(conn);
+```
+
+There are also two member functions to use either to disconnect all the
+listeners for a given type of event or to clear the emitter:
+
+```cpp
+// removes all the listener for the specific event
+emitter.clear<MyEvent>();
+
+// removes all the listeners registered so far
+emitter.clear();
+```
+
+To send an event to all the listeners that are interested in it, the `publish`
+member function offers a convenient approach that relieves users from having to
+create the event:
+
+```cpp
+struct MyEvent { int i; };
+
+// ...
+
+emitter.publish<MyEvent>(42);
+```
+
+Finally, the `empty` member function tests if there exists at least either a
+listener registered with the event emitter or to a given type of event:
+
+```cpp
+bool empty;
+
+// checks if there is any listener registered for the specific event
+empty = emitter.empty<MyEvent>();
+
+// checks it there are listeners registered with the event emitter
+empty = emitter.empty();
+```
+
+In general, the event emitter is a handy tool when the derived classes _wrap_
+asynchronous operations, because it introduces a _nice-to-have_ model based on
+events and listeners that kindly hides the complexity behind the scenes. However
+it is not limited to such uses.

scripts/update_homebrew.sh

@@ -0,0 +1,60 @@
+#!/bin/sh
+
+# only argument should be the version to upgrade to
+if [ $# != 1 ]
+then
+  echo "Expected a version tag like v2.7.1"
+  exit 1
+fi
+
+VERSION="$1"
+URL="https://github.com/skypjack/entt/archive/$VERSION.tar.gz"
+FORMULA="entt.rb"
+
+echo "Updating homebrew package to $VERSION"
+
+echo "Cloning..."
+git clone https://github.com/skypjack/homebrew-entt.git
+if [ $? != 0 ]
+then
+  exit 1
+fi
+cd homebrew-entt
+
+# download the repo at the version
+# exit with error messages if curl fails
+echo "Curling..."
+curl "$URL" --location --fail --silent --show-error --output archive.tar.gz
+if [ $? != 0 ]
+then
+  exit 1
+fi
+
+# compute sha256 hash
+echo "Hashing..."
+HASH="$(openssl sha256 archive.tar.gz | cut -d " " -f 2)"
+
+# delete the archive
+rm archive.tar.gz
+
+echo "Sedding..."
+
+# change the url in the formula file
+# the slashes in the URL must be escaped
+ESCAPED_URL="$(sed -e 's/[\/&]/\\&/g' <<< "$URL")"
+sed -i -e '/url/s/".*"/"'$ESCAPED_URL'"/' $FORMULA
+
+# change the hash in the formula file
+sed -i -e '/sha256/s/".*"/"'$HASH'"/' $FORMULA
+
+# delete temporary file created by sed
+rm "$FORMULA-e"
+
+# update remote repo
+echo "Gitting..."
+git add entt.rb
+git commit -m "Update to $VERSION"
+git push origin master
+
+# out of homebrew-entt dir
+cd ..

scripts/update_packages.sh

@@ -0,0 +1,3 @@
+#!/bin/sh
+
+scripts/update_homebrew.sh $1

src/entt/config/config.h

@@ -0,0 +1,16 @@
+#ifndef ENTT_CONFIG_CONFIG_H
+#define ENTT_CONFIG_CONFIG_H
+
+
+#ifndef ENTT_NOEXCEPT
+#define ENTT_NOEXCEPT noexcept
+#endif // ENTT_NOEXCEPT
+
+
+#ifndef ENTT_HS_SUFFIX
+#define ENTT_HS_SUFFIX _hs
+#endif // ENTT_HS_SUFFIX
+
+
+
+#endif // ENTT_CONFIG_CONFIG_H

src/entt/core/algorithm.hpp

@@ -0,0 +1,111 @@
+#ifndef ENTT_CORE_ALGORITHM_HPP
+#define ENTT_CORE_ALGORITHM_HPP
+
+
+#include <functional>
+#include <algorithm>
+#include <utility>
+
+
+namespace entt {
+
+
+/**
+ * @brief Function object to wrap `std::sort` in a class type.
+ *
+ * Unfortunately, `std::sort` cannot be passed as template argument to a class
+ * template or a function template.<br/>
+ * This class fills the gap by wrapping some flavors of `std::sort` in a
+ * function object.
+ */
+struct StdSort final {
+    /**
+     * @brief Sorts the elements in a range.
+     *
+     * Sorts the elements in a range using the given binary comparison function.
+     *
+     * @tparam It Type of random access iterator.
+     * @tparam Compare Type of comparison function object.
+     * @tparam Args Types of arguments to forward to the sort function.
+     * @param first An iterator to the first element of the range to sort.
+     * @param last An iterator past the last element of the range to sort.
+     * @param compare A valid comparison function object.
+     * @param args Arguments to forward to the sort function, if any.
+     */
+    template<typename It, typename Compare = std::less<>, typename... Args>
+    void operator()(It first, It last, Compare compare = Compare{}, Args &&... args) const {
+        std::sort(std::forward<Args>(args)..., std::move(first), std::move(last), std::move(compare));
+    }
+};
+
+
+/*! @brief Function object for performing insertion sort. */
+struct InsertionSort final {
+    /**
+     * @brief Sorts the elements in a range.
+     *
+     * Sorts the elements in a range using the given binary comparison function.
+     *
+     * @tparam It Type of random access iterator.
+     * @tparam Compare Type of comparison function object.
+     * @param first An iterator to the first element of the range to sort.
+     * @param last An iterator past the last element of the range to sort.
+     * @param compare A valid comparison function object.
+     */
+    template<typename It, typename Compare = std::less<>>
+    void operator()(It first, It last, Compare compare = Compare{}) const {
+        auto it = first + 1;
+
+        while(it != last) {
+            auto value = *it;
+            auto pre = it;
+
+            while(pre != first && compare(value, *(pre-1))) {
+                *pre = *(pre-1);
+                --pre;
+            }
+
+            *pre = value;
+            ++it;
+        }
+    }
+};
+
+
+/*! @brief Function object for performing bubble sort (single iteration). */
+struct OneShotBubbleSort final {
+    /**
+     * @brief Tries to sort the elements in a range.
+     *
+     * Performs a single iteration to sort the elements in a range using the
+     * given binary comparison function. The range may not be completely sorted
+     * after running this function.
+     *
+     * @tparam It Type of random access iterator.
+     * @tparam Compare Type of comparison function object.
+     * @param first An iterator to the first element of the range to sort.
+     * @param last An iterator past the last element of the range to sort.
+     * @param compare A valid comparison function object.
+     */
+    template<typename It, typename Compare = std::less<>>
+    void operator()(It first, It last, Compare compare = Compare{}) const {
+        if(first != last) {
+            auto it = first++;
+
+            while(first != last) {
+                if(compare(*first, *it)) {
+                    using std::swap;
+                    std::swap(*first, *it);
+                }
+
+                it = first++;
+            }
+        }
+    }
+};
+
+
+}
+
+
+#endif // ENTT_CORE_ALGORITHM_HPP

src/entt/core/family.hpp

@@ -0,0 +1,53 @@
+#ifndef ENTT_CORE_FAMILY_HPP
+#define ENTT_CORE_FAMILY_HPP
+
+
+#include <type_traits>
+#include <cstddef>
+#include <atomic>
+#include "../config/config.h"
+
+
+namespace entt {
+
+
+/**
+ * @brief Dynamic identifier generator.
+ *
+ * Utility class template that can be used to assign unique identifiers to types
+ * at runtime. Use different specializations to create separate sets of
+ * identifiers.
+ */
+template<typename...>
+class Family {
+    static std::atomic<std::size_t> identifier;
+
+    template<typename...>
+    static std::size_t family() ENTT_NOEXCEPT {
+        static const std::size_t value = identifier.fetch_add(1);
+        return value;
+    }
+
+public:
+    /*! @brief Unsigned integer type. */
+    using family_type = std::size_t;
+
+    /**
+     * @brief Returns an unique identifier for the given type.
+     * @return Statically generated unique identifier for the given type.
+     */
+    template<typename... Type>
+    inline static family_type type() ENTT_NOEXCEPT {
+        return family<std::decay_t<Type>...>();
+    }
+};
+
+
+template<typename... Types>
+std::atomic<std::size_t> Family<Types...>::identifier{};
+
+
+}
+
+
+#endif // ENTT_CORE_FAMILY_HPP

src/entt/core/hashed_string.hpp

@@ -0,0 +1,121 @@
+#ifndef ENTT_CORE_HASHED_STRING_HPP
+#define ENTT_CORE_HASHED_STRING_HPP
+
+
+#include <cstddef>
+#include <cstdint>
+#include "../config/config.h"
+
+
+namespace entt {
+
+
+/**
+ * @brief Zero overhead resource identifier.
+ *
+ * A hashed string is a compile-time tool that allows users to use
+ * human-readable identifers in the codebase while using their numeric
+ * counterparts at runtime.<br/>
+ * Because of that, a hashed string can also be used in constant expressions if
+ * required.
+ */
+class HashedString final {
+    struct ConstCharWrapper final {
+        // non-explicit constructor on purpose
+        constexpr ConstCharWrapper(const char *str) ENTT_NOEXCEPT: str{str} {}
+        const char *str;
+    };
+
+    static constexpr std::uint64_t offset = 14695981039346656037ull;
+    static constexpr std::uint64_t prime = 1099511628211ull;
+
+    // Fowler–Noll–Vo hash function v. 1a - the good
+    static constexpr std::uint64_t helper(std::uint64_t partial, const char *str) ENTT_NOEXCEPT {
+        return str[0] == 0 ? partial : helper((partial^str[0])*prime, str+1);
+    }
+
+public:
+    /*! @brief Unsigned integer type. */
+    using hash_type = std::uint64_t;
+
+    /**
+     * @brief Constructs a hashed string from an array of const chars.
+     *
+     * Forcing template resolution avoids implicit conversions. An
+     * human-readable identifier can be anything but a plain, old bunch of
+     * characters.<br/>
+     * Example of use:
+     * @code{.cpp}
+     * HashedString sh{"my.png"};
+     * @endcode
+     *
+     * @tparam N Number of characters of the identifier.
+     * @param str Human-readable identifer.
+     */
+    template<std::size_t N>
+    constexpr HashedString(const char (&str)[N]) ENTT_NOEXCEPT
+        : hash{helper(offset, str)}, str{str}
+    {}
+
+    /**
+     * @brief Explicit constructor on purpose to avoid constructing a hashed
+     * string directly from a `const char *`.
+     *
+     * @param wrapper Helps achieving the purpose by relying on overloading.
+     */
+    explicit constexpr HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPT
+        : hash{helper(offset, wrapper.str)}, str{wrapper.str}
+    {}
+
+    /**
+     * @brief Returns the human-readable representation of a hashed string.
+     * @return The string used to initialize the instance.
+     */
+    constexpr operator const char *() const ENTT_NOEXCEPT { return str; }
+
+    /**
+     * @brief Returns the numeric representation of a hashed string.
+     * @return The numeric representation of the instance.
+     */
+    constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
+
+    /**
+     * @brief Compares two hashed strings.
+     * @param other Hashed string with which to compare.
+     * @return True if the two hashed strings are identical, false otherwise.
+     */
+    constexpr bool operator==(const HashedString &other) const ENTT_NOEXCEPT {
+        return hash == other.hash;
+    }
+
+private:
+    const hash_type hash;
+    const char *str;
+};
+
+
+/**
+ * @brief Compares two hashed strings.
+ * @param lhs A valid hashed string.
+ * @param rhs A valid hashed string.
+ * @return True if the two hashed strings are identical, false otherwise.
+ */
+constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+
+}
+
+
+/**
+ * @brief User defined literal for hashed strings.
+ * @param str The literal without its suffix.
+ * @return A properly initialized hashed string.
+ */
+constexpr entt::HashedString operator"" ENTT_HS_SUFFIX(const char *str, std::size_t) ENTT_NOEXCEPT {
+    return entt::HashedString{str};
+}
+
+
+#endif // ENTT_CORE_HASHED_STRING_HPP

src/entt/core/ident.hpp

@@ -0,0 +1,104 @@
+#ifndef ENTT_CORE_IDENT_HPP
+#define ENTT_CORE_IDENT_HPP
+
+
+#include <type_traits>
+#include <cstddef>
+#include <utility>
+#include <tuple>
+#include "../config/config.h"
+
+
+namespace entt {
+
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+
+namespace internal {
+
+
+template<typename...>
+struct IsPartOf;
+
+template<typename Type, typename Current, typename... Other>
+struct IsPartOf<Type, Current, Other...>: std::conditional_t<std::is_same<Type, Current>::value, std::true_type, IsPartOf<Type, Other...>> {};
+
+template<typename Type>
+struct IsPartOf<Type>: std::false_type {};
+
+
+}
+
+
+/**
+ * Internal details not to be documented.
+ * @endcond TURN_OFF_DOXYGEN
+ */
+
+
+/**
+ * @brief Types identifiers.
+ *
+ * Variable template used to generate identifiers at compile-time for the given
+ * types. Use the `get` member function to know what's the identifier associated
+ * to the specific type.
+ *
+ * @note
+ * Identifiers are constant expression and can be used in any context where such
+ * an expression is required. As an example:
+ * @code{.cpp}
+ * using ID = entt::Identifier<AType, AnotherType>;
+ *
+ * switch(aTypeIdentifier) {
+ * case ID::get<AType>():
+ *     // ...
+ *     break;
+ * case ID::get<AnotherType>():
+ *     // ...
+ *     break;
+ * default:
+ *     // ...
+ * }
+ * @endcode
+ *
+ * @tparam Types List of types for which to generate identifiers.
+ */
+template<typename... Types>
+class Identifier final {
+    using tuple_type = std::tuple<std::decay_t<Types>...>;
+
+    template<typename Type, std::size_t... Indexes>
+    static constexpr std::size_t get(std::index_sequence<Indexes...>) ENTT_NOEXCEPT {
+        static_assert(internal::IsPartOf<Type, Types...>::value, "!");
+
+        std::size_t max{};
+        using accumulator_type = std::size_t[];
+        accumulator_type accumulator = { (max = std::is_same<Type, std::tuple_element_t<Indexes, tuple_type>>::value ? Indexes : max)... };
+        (void)accumulator;
+        return max;
+    }
+
+public:
+    /*! @brief Unsigned integer type. */
+    using identifier_type = std::size_t;
+
+    /**
+     * @brief Returns the identifier associated with a given type.
+     * @tparam Type of which to return the identifier.
+     * @return The identifier associated with the given type.
+     */
+    template<typename Type>
+    static constexpr identifier_type get() ENTT_NOEXCEPT {
+        return get<std::decay_t<Type>>(std::make_index_sequence<sizeof...(Types)>{});
+    }
+};
+
+
+}
+
+
+#endif // ENTT_CORE_IDENT_HPP

src/entt/core/monostate.hpp

@@ -0,0 +1,61 @@
+#ifndef ENTT_CORE_MONOSTATE_HPP
+#define ENTT_CORE_MONOSTATE_HPP
+
+
+#include <atomic>
+#include <cassert>
+#include "family.hpp"
+#include "hashed_string.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Minimal implementation of the monostate pattern.
+ *
+ * A minimal, yet complete configuration system built on top of the monostate
+ * pattern. Thread safe by design, it works only with basic types like `int`s or
+ * `bool`s.<br/>
+ * Multiple types and therefore more than one value can be associated with a
+ * single key. Because of this, users must pay attention to use the same type
+ * both during an assignment and when they try to read back their data.
+ * Otherwise, they can incur in unexpected results.
+ */
+template<HashedString::hash_type>
+struct Monostate {
+    /**
+     * @brief Assigns a value of a specific type to a given key.
+     * @tparam Type Type of the value to assign.
+     * @param val User data to assign to the given key.
+     */
+    template<typename Type>
+    void operator=(Type val) const ENTT_NOEXCEPT {
+        Monostate::value<Type> = val;
+    }
+
+    /**
+     * @brief Gets a value of a specific type for a given key.
+     * @tparam Type Type of the value to get.
+     * @return Stored value, if any.
+     */
+    template<typename Type>
+    operator Type() const ENTT_NOEXCEPT {
+        return Monostate::value<Type>;
+    }
+
+private:
+    template<typename Type>
+    static std::atomic<Type> value;
+};
+
+
+template<HashedString::hash_type ID>
+template<typename Type>
+std::atomic<Type> Monostate<ID>::value{};
+
+
+}
+
+
+#endif // ENTT_CORE_MONOSTATE_HPP

src/entt/entity/actor.hpp

@@ -0,0 +1,243 @@
+#ifndef ENTT_ENTITY_ACTOR_HPP
+#define ENTT_ENTITY_ACTOR_HPP
+
+
+#include <cassert>
+#include <utility>
+#include "../config/config.h"
+#include "registry.hpp"
+#include "entity.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Dedicated to those who aren't confident with entity-component systems.
+ *
+ * Tiny wrapper around a registry, for all those users that aren't confident
+ * with entity-component systems and prefer to iterate objects directly.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+struct Actor {
+    /*! @brief Type of registry used internally. */
+    using registry_type = Registry<Entity>;
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+
+    /**
+     * @brief Constructs an actor by using the given registry.
+     * @param reg An entity-component system properly initialized.
+     */
+    Actor(Registry<Entity> &reg)
+        : reg{&reg}, entt{reg.create()}
+    {}
+
+    /*! @brief Default destructor. */
+    virtual ~Actor() {
+        reg->destroy(entt);
+    }
+
+    /*! @brief Copying an actor isn't allowed. */
+    Actor(const Actor &) = delete;
+
+    /**
+     * @brief Move constructor.
+     *
+     * After actor move construction, instances that have been moved from are
+     * placed in a valid but unspecified state. It's highly discouraged to
+     * continue using them.
+     *
+     * @param other The instance to move from.
+     */
+    Actor(Actor &&other)
+        : reg{other.reg}, entt{other.entt}
+    {
+        other.entt = entt::null;
+    }
+
+    /*! @brief Default copy assignment operator. @return This actor. */
+    Actor & operator=(const Actor &) = delete;
+
+    /**
+     * @brief Move assignment operator.
+     *
+     * After actor move assignment, instances that have been moved from are
+     * placed in a valid but unspecified state. It's highly discouraged to
+     * continue using them.
+     *
+     * @param other The instance to move from.
+     * @return This actor.
+     */
+    Actor & operator=(Actor &&other) {
+        if(this != &other) {
+            auto tmp{std::move(other)};
+            std::swap(reg, tmp.reg);
+            std::swap(entt, tmp.entt);
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Assigns the given tag to an actor.
+     *
+     * A new instance of the given tag is created and initialized with the
+     * arguments provided (the tag must have a proper constructor or be of
+     * aggregate type). Then the tag is removed from its previous owner (if any)
+     * and assigned to the actor.
+     *
+     * @tparam Tag Type of the tag to create.
+     * @tparam Args Types of arguments to use to construct the tag.
+     * @param args Parameters to use to initialize the tag.
+     * @return A reference to the newly created tag.
+     */
+    template<typename Tag, typename... Args>
+    Tag & assign(tag_t, Args &&... args) {
+        return (reg->template remove<Tag>(), reg->template assign<Tag>(tag_t{}, entt, std::forward<Args>(args)...));
+    }
+
+    /**
+     * @brief Assigns the given component to an actor.
+     *
+     * A new instance of the given component is created and initialized with the
+     * arguments provided (the component must have a proper constructor or be of
+     * aggregate type). Then the component is assigned to the actor.<br/>
+     * In case the actor already has a component of the given type, it's
+     * replaced with the new one.
+     *
+     * @tparam Component Type of the component to create.
+     * @tparam Args Types of arguments to use to construct the component.
+     * @param args Parameters to use to initialize the component.
+     * @return A reference to the newly created component.
+     */
+    template<typename Component, typename... Args>
+    Component & assign(Args &&... args) {
+        return reg->template accommodate<Component>(entt, std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Removes the given tag from an actor.
+     * @tparam Tag Type of the tag to remove.
+     */
+    template<typename Tag>
+    void remove(tag_t) {
+        assert(has<Tag>(tag_t{}));
+        reg->template remove<Tag>();
+    }
+
+    /**
+     * @brief Removes the given component from an actor.
+     * @tparam Component Type of the component to remove.
+     */
+    template<typename Component>
+    void remove() {
+        reg->template remove<Component>(entt);
+    }
+
+    /**
+     * @brief Checks if an actor owns the given tag.
+     * @tparam Tag Type of the tag for which to perform the check.
+     * @return True if the actor owns the tag, false otherwise.
+     */
+    template<typename Tag>
+    bool has(tag_t) const ENTT_NOEXCEPT {
+        return (reg->template has<Tag>() && (reg->template attachee<Tag>() == entt));
+    }
+
+    /**
+     * @brief Checks if an actor has the given component.
+     * @tparam Component Type of the component for which to perform the check.
+     * @return True if the actor has the component, false otherwise.
+     */
+    template<typename Component>
+    bool has() const ENTT_NOEXCEPT {
+        return reg->template has<Component>(entt);
+    }
+
+    /**
+     * @brief Returns a reference to the given tag for an actor.
+     * @tparam Tag Type of the tag to get.
+     * @return A reference to the instance of the tag owned by the actor.
+     */
+    template<typename Tag>
+    const Tag & get(tag_t) const ENTT_NOEXCEPT {
+        assert(has<Tag>(tag_t{}));
+        return reg->template get<Tag>();
+    }
+
+    /**
+     * @brief Returns a reference to the given tag for an actor.
+     * @tparam Tag Type of the tag to get.
+     * @return A reference to the instance of the tag owned by the actor.
+     */
+    template<typename Tag>
+    inline Tag & get(tag_t) ENTT_NOEXCEPT {
+        return const_cast<Tag &>(const_cast<const Actor *>(this)->get<Tag>(tag_t{}));
+    }
+
+    /**
+     * @brief Returns a reference to the given component for an actor.
+     * @tparam Component Type of the component to get.
+     * @return A reference to the instance of the component owned by the actor.
+     */
+    template<typename Component>
+    const Component & get() const ENTT_NOEXCEPT {
+        return reg->template get<Component>(entt);
+    }
+
+    /**
+     * @brief Returns a reference to the given component for an actor.
+     * @tparam Component Type of the component to get.
+     * @return A reference to the instance of the component owned by the actor.
+     */
+    template<typename Component>
+    inline Component & get() ENTT_NOEXCEPT {
+        return const_cast<Component &>(const_cast<const Actor *>(this)->get<Component>());
+    }
+
+    /**
+     * @brief Returns a reference to the underlying registry.
+     * @return A reference to the underlying registry.
+     */
+    inline const registry_type & registry() const ENTT_NOEXCEPT {
+        return *reg;
+    }
+
+    /**
+     * @brief Returns a reference to the underlying registry.
+     * @return A reference to the underlying registry.
+     */
+    inline registry_type & registry() ENTT_NOEXCEPT {
+        return const_cast<registry_type &>(const_cast<const Actor *>(this)->registry());
+    }
+
+    /**
+     * @brief Returns the entity associated with an actor.
+     * @return The entity associated with the actor.
+     */
+    inline entity_type entity() const ENTT_NOEXCEPT {
+        return entt;
+    }
+
+private:
+    registry_type * reg;
+    Entity entt;
+};
+
+
+/**
+ * @brief Default actor class.
+ *
+ * The default actor is the best choice for almost all the applications.<br/>
+ * Users should have a really good reason to choose something different.
+ */
+using DefaultActor = Actor<DefaultRegistry::entity_type>;
+
+
+}
+
+
+#endif // ENTT_ENTITY_ACTOR_HPP

src/entt/entity/attachee.hpp

@@ -0,0 +1,230 @@
+#ifndef ENTT_ENTITY_ATTACHEE_HPP
+#define ENTT_ENTITY_ATTACHEE_HPP
+
+
+#include <cassert>
+#include <utility>
+#include <type_traits>
+#include "../config/config.h"
+#include "entity.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Attachee.
+ *
+ * Primary template isn't defined on purpose. All the specializations give a
+ * compile-time error, but for a few reasonable cases.
+ */
+template<typename...>
+class Attachee;
+
+
+/**
+ * @brief Basic attachee implementation.
+ *
+ * Convenience data structure used to store single instance components.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class Attachee<Entity> {
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+
+    /*! @brief Default constructor. */
+    Attachee() ENTT_NOEXCEPT
+        : owner{null}
+    {}
+
+    /*! @brief Default copy constructor. */
+    Attachee(const Attachee &) = default;
+    /*! @brief Default move constructor. */
+    Attachee(Attachee &&) = default;
+
+    /*! @brief Default copy assignment operator. @return This attachee. */
+    Attachee & operator=(const Attachee &) = default;
+    /*! @brief Default move assignment operator. @return This attachee. */
+    Attachee & operator=(Attachee &&) = default;
+
+    /*! @brief Default destructor. */
+    virtual ~Attachee() ENTT_NOEXCEPT = default;
+
+    /**
+     * @brief Returns the owner of an attachee.
+     * @return A valid entity identifier if an owner exists, the null entity
+     * identifier otherwise.
+     */
+    inline entity_type get() const ENTT_NOEXCEPT {
+        return owner;
+    }
+
+    /**
+     * @brief Assigns an entity to an attachee.
+     *
+     * @warning
+     * Attempting to assigns an entity to an attachee that already has an owner
+     * results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode in case
+     * the attachee already has an owner.
+     *
+     * @param entity A valid entity identifier.
+     */
+    inline void construct(const entity_type entity) ENTT_NOEXCEPT {
+        assert(owner == null);
+        owner = entity;
+    }
+
+    /**
+     * @brief Removes an entity from an attachee.
+     *
+     * @warning
+     * Attempting to free an empty attachee results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * attachee is already empty.
+     */
+    virtual void destroy() ENTT_NOEXCEPT {
+        assert(owner != null);
+        owner = null;
+    }
+
+private:
+    entity_type owner;
+};
+
+
+/**
+ * @brief Extended attachee implementation.
+ *
+ * This specialization of an attachee associates an object to an entity. The
+ * main purpose of this class is to use attachees to store tags in a Registry.
+ * It guarantees fast access both to the element and to the entity.
+ *
+ * @sa Attachee<Entity>
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Type Type of object assigned to the entity.
+ */
+template<typename Entity, typename Type>
+class Attachee<Entity, Type>: public Attachee<Entity> {
+    using underlying_type = Attachee<Entity>;
+
+public:
+    /*! @brief Type of the object associated to the attachee. */
+    using object_type = Type;
+    /*! @brief Underlying entity identifier. */
+    using entity_type = typename underlying_type::entity_type;
+
+    /*! @brief Default constructor. */
+    Attachee() ENTT_NOEXCEPT = default;
+
+    /*! @brief Copying an attachee isn't allowed. */
+    Attachee(const Attachee &) = delete;
+    /*! @brief Moving an attachee isn't allowed. */
+    Attachee(Attachee &&) = delete;
+
+    /*! @brief Copying an attachee isn't allowed. @return This attachee. */
+    Attachee & operator=(const Attachee &) = delete;
+    /*! @brief Moving an attachee isn't allowed. @return This attachee. */
+    Attachee & operator=(Attachee &&) = delete;
+
+    /*! @brief Default destructor. */
+    ~Attachee() {
+        if(underlying_type::get() != null) {
+            reinterpret_cast<Type *>(&storage)->~Type();
+        }
+    }
+
+    /**
+     * @brief Returns the object associated to an attachee.
+     *
+     * @warning
+     * Attempting to query an empty attachee results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * attachee is empty.
+     *
+     * @return The object associated to the attachee.
+     */
+    const Type & get() const ENTT_NOEXCEPT {
+        assert(underlying_type::get() != null);
+        return *reinterpret_cast<const Type *>(&storage);
+    }
+
+    /**
+     * @brief Returns the object associated to an attachee.
+     *
+     * @warning
+     * Attempting to query an empty attachee results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * attachee is empty.
+     *
+     * @return The object associated to the attachee.
+     */
+    Type & get() ENTT_NOEXCEPT {
+        return const_cast<Type &>(const_cast<const Attachee *>(this)->get());
+    }
+
+    /**
+     * @brief Assigns an entity to an attachee and constructs its object.
+     *
+     * @warning
+     * Attempting to assigns an entity to an attachee that already has an owner
+     * results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode in case
+     * the attachee already has an owner.
+     *
+     * @tparam Args Types of arguments to use to construct the object.
+     * @param entity A valid entity identifier.
+     * @param args Parameters to use to construct an object for the entity.
+     * @return The object associated to the attachee.
+     */
+    template<typename... Args>
+    Type & construct(entity_type entity, Args &&... args) ENTT_NOEXCEPT {
+        underlying_type::construct(entity);
+        new (&storage) Type{std::forward<Args>(args)...};
+        return *reinterpret_cast<Type *>(&storage);
+    }
+
+    /**
+     * @brief Removes an entity from an attachee and destroies its object.
+     *
+     * @warning
+     * Attempting to free an empty attachee results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * attachee is already empty.
+     */
+    void destroy() ENTT_NOEXCEPT override {
+        reinterpret_cast<Type *>(&storage)->~Type();
+        underlying_type::destroy();
+    }
+
+    /**
+     * @brief Changes the owner of an attachee.
+     *
+     * The ownership of the attachee is transferred from one entity to another.
+     *
+     * @warning
+     * Attempting to transfer the ownership of an attachee that hasn't an owner
+     * results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode in case
+     * the attachee hasn't an owner yet.
+     *
+     * @param entity A valid entity identifier.
+     */
+    void move(const entity_type entity) ENTT_NOEXCEPT {
+        underlying_type::destroy();
+        underlying_type::construct(entity);
+    }
+
+private:
+    std::aligned_storage_t<sizeof(Type), alignof(Type)> storage;
+};
+
+
+}
+
+
+#endif // ENTT_ENTITY_ATTACHEE_HPP

src/entt/entity/entity.hpp

@@ -0,0 +1,84 @@
+#ifndef ENTT_ENTITY_ENTITY_HPP
+#define ENTT_ENTITY_ENTITY_HPP
+
+
+#include "../config/config.h"
+#include "entt_traits.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+
+namespace internal {
+
+
+struct Null {
+    explicit constexpr Null() = default;
+
+    template<typename Entity>
+    constexpr operator Entity() const ENTT_NOEXCEPT {
+        using traits_type = entt::entt_traits<Entity>;
+        return traits_type::entity_mask | (traits_type::version_mask << traits_type::entity_shift);
+    }
+
+    constexpr bool operator==(Null) const ENTT_NOEXCEPT {
+        return true;
+    }
+
+    constexpr bool operator!=(Null) const ENTT_NOEXCEPT {
+        return false;
+    }
+
+    template<typename Entity>
+    constexpr bool operator==(const Entity entity) const ENTT_NOEXCEPT {
+        return entity == static_cast<Entity>(*this);
+    }
+
+    template<typename Entity>
+    constexpr bool operator!=(const Entity entity) const ENTT_NOEXCEPT {
+        return entity != static_cast<Entity>(*this);
+    }
+};
+
+
+template<typename Entity>
+constexpr bool operator==(const Entity entity, Null null) ENTT_NOEXCEPT {
+    return null == entity;
+}
+
+
+template<typename Entity>
+constexpr bool operator!=(const Entity entity, Null null) ENTT_NOEXCEPT {
+    return null != entity;
+}
+
+
+}
+
+
+/**
+ * Internal details not to be documented.
+ * @endcond TURN_OFF_DOXYGEN
+ */
+
+
+/**
+ * @brief Null entity.
+ *
+ * There exist implicit conversions from this variable to entity identifiers of
+ * any allowed type. Similarly, there exist comparision operators between the
+ * null entity and any other entity identifier.
+ */
+constexpr auto null = internal::Null{};
+
+
+}
+
+
+#endif // ENTT_ENTITY_ENTITY_HPP

src/entt/entity/entt_traits.hpp

@@ -0,0 +1,102 @@
+#ifndef ENTT_ENTITY_ENTT_TRAITS_HPP
+#define ENTT_ENTITY_ENTT_TRAITS_HPP
+
+
+#include <cstdint>
+
+
+namespace entt {
+
+
+/**
+ * @brief Entity traits.
+ *
+ * Primary template isn't defined on purpose. All the specializations give a
+ * compile-time error unless the template parameter is an accepted entity type.
+ */
+template<typename>
+struct entt_traits;
+
+
+/**
+ * @brief Entity traits for a 16 bits entity identifier.
+ *
+ * A 16 bits entity identifier guarantees:
+ *
+ * * 12 bits for the entity number (up to 4k entities).
+ * * 4 bit for the version (resets in [0-15]).
+ */
+template<>
+struct entt_traits<std::uint16_t> {
+    /*! @brief Underlying entity type. */
+    using entity_type = std::uint16_t;
+    /*! @brief Underlying version type. */
+    using version_type = std::uint8_t;
+    /*! @brief Difference type. */
+    using difference_type = std::int32_t;
+
+    /*! @brief Mask to use to get the entity number out of an identifier. */
+    static constexpr std::uint16_t entity_mask = 0xFFF;
+    /*! @brief Mask to use to get the version out of an identifier. */
+    static constexpr std::uint16_t version_mask = 0xF;
+    /*! @brief Extent of the entity number within an identifier. */
+    static constexpr auto entity_shift = 12;
+};
+
+
+/**
+ * @brief Entity traits for a 32 bits entity identifier.
+ *
+ * A 32 bits entity identifier guarantees:
+ *
+ * * 20 bits for the entity number (suitable for almost all the games).
+ * * 12 bit for the version (resets in [0-4095]).
+ */
+template<>
+struct entt_traits<std::uint32_t> {
+    /*! @brief Underlying entity type. */
+    using entity_type = std::uint32_t;
+    /*! @brief Underlying version type. */
+    using version_type = std::uint16_t;
+    /*! @brief Difference type. */
+    using difference_type = std::int64_t;
+
+    /*! @brief Mask to use to get the entity number out of an identifier. */
+    static constexpr std::uint32_t entity_mask = 0xFFFFF;
+    /*! @brief Mask to use to get the version out of an identifier. */
+    static constexpr std::uint32_t version_mask = 0xFFF;
+    /*! @brief Extent of the entity number within an identifier. */
+    static constexpr auto entity_shift = 20;
+};
+
+
+/**
+ * @brief Entity traits for a 64 bits entity identifier.
+ *
+ * A 64 bits entity identifier guarantees:
+ *
+ * * 32 bits for the entity number (an indecently large number).
+ * * 32 bit for the version (an indecently large number).
+ */
+template<>
+struct entt_traits<std::uint64_t> {
+    /*! @brief Underlying entity type. */
+    using entity_type = std::uint64_t;
+    /*! @brief Underlying version type. */
+    using version_type = std::uint32_t;
+    /*! @brief Difference type. */
+    using difference_type = std::int64_t;
+
+    /*! @brief Mask to use to get the entity number out of an identifier. */
+    static constexpr std::uint64_t entity_mask = 0xFFFFFFFF;
+    /*! @brief Mask to use to get the version out of an identifier. */
+    static constexpr std::uint64_t version_mask = 0xFFFFFFFF;
+    /*! @brief Extent of the entity number within an identifier. */
+    static constexpr auto entity_shift = 32;
+};
+
+
+}
+
+
+#endif // ENTT_ENTITY_ENTT_TRAITS_HPP

src/entt/entity/helper.hpp

@@ -0,0 +1,105 @@
+#ifndef ENTT_ENTITY_HELPER_HPP
+#define ENTT_ENTITY_HELPER_HPP
+
+
+#include <type_traits>
+#include "../core/hashed_string.hpp"
+#include "../signal/sigh.hpp"
+#include "registry.hpp"
+#include "utility.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Dependency function prototype.
+ *
+ * A _dependency function_ is a built-in listener to use to automatically assign
+ * components to an entity when a type has a dependency on some other types.
+ *
+ * This is a prototype function to use to create dependencies.<br/>
+ * It isn't intended for direct use, although nothing forbids using it freely.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Component Types of components to assign to an entity if triggered.
+ * @param registry A valid reference to a registry.
+ * @param entity A valid entity identifier.
+ */
+template<typename Entity, typename... Component>
+void dependency(Registry<Entity> &registry, const Entity entity) {
+    using accumulator_type = int[];
+    accumulator_type accumulator = { ((registry.template has<Component>(entity) ? void() : (registry.template assign<Component>(entity), void())), 0)... };
+    (void)accumulator;
+}
+
+
+/**
+ * @brief Connects a dependency function to the given sink.
+ *
+ * A _dependency function_ is a built-in listener to use to automatically assign
+ * components to an entity when a type has a dependency on some other types.
+ *
+ * The following adds components `AType` and `AnotherType` whenever `MyType` is
+ * assigned to an entity:
+ * @code{.cpp}
+ * entt::DefaultRegistry registry;
+ * entt::connect<AType, AnotherType>(registry.construction<MyType>());
+ * @endcode
+ *
+ * @tparam Dependency Types of components to assign to an entity if triggered.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @param sink A sink object properly initialized.
+ */
+template<typename... Dependency, typename Entity>
+inline void connect(Sink<void(Registry<Entity> &, const Entity)> sink) {
+    sink.template connect<dependency<Entity, Dependency...>>();
+}
+
+
+/**
+ * @brief Disconnects a dependency function from the given sink.
+ *
+ * A _dependency function_ is a built-in listener to use to automatically assign
+ * components to an entity when a type has a dependency on some other types.
+ *
+ * The following breaks the dependency between the component `MyType` and the
+ * components `AType` and `AnotherType`:
+ * @code{.cpp}
+ * entt::DefaultRegistry registry;
+ * entt::disconnect<AType, AnotherType>(registry.construction<MyType>());
+ * @endcode
+ *
+ * @tparam Dependency Types of components used to create the dependency.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @param sink A sink object properly initialized.
+ */
+template<typename... Dependency, typename Entity>
+inline void disconnect(Sink<void(Registry<Entity> &, const Entity)> sink) {
+    sink.template disconnect<dependency<Entity, Dependency...>>();
+}
+
+
+/**
+ * @brief Alias template to ease the assignment of labels to entities.
+ *
+ * If used in combination with hashed strings, it simplifies the assignment of
+ * labels to entities and the use of labels in general where a type would be
+ * required otherwise.<br/>
+ * As an example and where the user defined literal for hashed strings hasn't
+ * been changed:
+ * @code{.cpp}
+ * entt::DefaultRegistry registry;
+ * registry.assign<entt::label<"enemy"_hs>>(entity);
+ * @endcode
+ *
+ * @tparam Value The numeric representation of an instance of hashed string.
+ */
+template<typename HashedString::hash_type Value>
+using label = std::integral_constant<typename HashedString::hash_type, Value>;
+
+
+}
+
+
+#endif // ENTT_ENTITY_HELPER_HPP

src/entt/entity/prototype.hpp

@@ -0,0 +1,497 @@
+#ifndef ENTT_ENTITY_PROTOTYPE_HPP
+#define ENTT_ENTITY_PROTOTYPE_HPP
+
+
+#include <tuple>
+#include <utility>
+#include <cstddef>
+#include <type_traits>
+#include <unordered_map>
+#include "../config/config.h"
+#include "registry.hpp"
+#include "entity.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Prototype container for _concepts_.
+ *
+ * A prototype is used to define a _concept_ in terms of components.<br/>
+ * Prototypes act as templates for those specific types of an application which
+ * users would otherwise define through a series of component assignments to
+ * entities. In other words, prototypes can be used to assign components to
+ * entities of a registry at once.
+ *
+ * @note
+ * Components used along with prototypes must be copy constructible. Prototypes
+ * wrap component types with custom types, so they do not interfere with other
+ * users of the registry they were built with.
+ *
+ * @warning
+ * Prototypes directly use their underlying registries to store entities and
+ * components for their purposes. Users must ensure that the lifetime of a
+ * registry and its contents exceed that of the prototypes that use it.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class Prototype final {
+    using basic_fn_type = void(const Prototype &, Registry<Entity> &, const Entity);
+    using component_type = typename Registry<Entity>::component_type;
+
+    template<typename Component>
+    struct Wrapper { Component component; };
+
+    struct Handler {
+        basic_fn_type *accommodate;
+        basic_fn_type *assign;
+    };
+
+    void release() {
+        if(registry->valid(entity)) {
+            registry->destroy(entity);
+        }
+    }
+
+public:
+    /*! @brief Registry type. */
+    using registry_type = Registry<Entity>;
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+
+    /**
+     * @brief Constructs a prototype that is bound to a given registry.
+     * @param registry A valid reference to a registry.
+     */
+    Prototype(Registry<Entity> &registry)
+        : registry{&registry},
+          entity{registry.create()}
+    {}
+
+    /**
+     * @brief Releases all its resources.
+     */
+    ~Prototype() {
+        release();
+    }
+
+    /*! @brief Copying a prototype isn't allowed. */
+    Prototype(const Prototype &) = delete;
+
+    /**
+     * @brief Move constructor.
+     *
+     * After prototype move construction, instances that have been moved from
+     * are placed in a valid but unspecified state. It's highly discouraged to
+     * continue using them.
+     *
+     * @param other The instance to move from.
+     */
+    Prototype(Prototype &&other)
+        : handlers{std::move(other.handlers)},
+          registry{other.registry},
+          entity{other.entity}
+    {
+        other.entity = entt::null;
+    }
+
+    /*! @brief Copying a prototype isn't allowed. @return This Prototype. */
+    Prototype & operator=(const Prototype &) = delete;
+
+    /**
+     * @brief Move assignment operator.
+     *
+     * After prototype move assignment, instances that have been moved from are
+     * placed in a valid but unspecified state. It's highly discouraged to
+     * continue using them.
+     *
+     * @param other The instance to move from.
+     * @return This Prototype.
+     */
+    Prototype & operator=(Prototype &&other) {
+        if(this != &other) {
+            auto tmp{std::move(other)};
+            handlers.swap(tmp.handlers);
+            std::swap(registry, tmp.registry);
+            std::swap(entity, tmp.entity);
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Assigns to or replaces the given component of a prototype.
+     * @tparam Component Type of component to assign or replace.
+     * @tparam Args Types of arguments to use to construct the component.
+     * @param args Parameters to use to initialize the component.
+     * @return A reference to the newly created component.
+     */
+    template<typename Component, typename... Args>
+    Component & set(Args &&... args) {
+        basic_fn_type *accommodate = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
+            const auto &wrapper = prototype.registry->template get<Wrapper<Component>>(prototype.entity);
+            other.template accommodate<Component>(dst, wrapper.component);
+        };
+
+        basic_fn_type *assign = [](const Prototype &prototype, Registry<Entity> &other, const Entity dst) {
+            if(!other.template has<Component>(dst)) {
+                const auto &wrapper = prototype.registry->template get<Wrapper<Component>>(prototype.entity);
+                other.template assign<Component>(dst, wrapper.component);
+            }
+        };
+
+        handlers[registry->template type<Component>()] = Handler{accommodate, assign};
+        auto &wrapper = registry->template accommodate<Wrapper<Component>>(entity, Component{std::forward<Args>(args)...});
+        return wrapper.component;
+    }
+
+    /**
+     * @brief Removes the given component from a prototype.
+     * @tparam Component Type of component to remove.
+     */
+    template<typename Component>
+    void unset() ENTT_NOEXCEPT {
+        registry->template reset<Wrapper<Component>>(entity);
+        handlers.erase(registry->template type<Component>());
+    }
+
+    /**
+     * @brief Checks if a prototype owns all the given components.
+     * @tparam Component Components for which to perform the check.
+     * @return True if the prototype owns all the components, false otherwise.
+     */
+    template<typename... Component>
+    bool has() const ENTT_NOEXCEPT {
+        return registry->template has<Wrapper<Component>...>(entity);
+    }
+
+    /**
+     * @brief Returns a reference to the given component.
+     *
+     * @warning
+     * Attempting to get a component from a prototype that doesn't own it
+     * results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * prototype doesn't own an instance of the given component.
+     *
+     * @tparam Component Type of component to get.
+     * @return A reference to the component owned by the prototype.
+     */
+    template<typename Component>
+    const Component & get() const ENTT_NOEXCEPT {
+        return registry->template get<Wrapper<Component>>(entity).component;
+    }
+
+    /**
+     * @brief Returns a reference to the given component.
+     *
+     * @warning
+     * Attempting to get a component from a prototype that doesn't own it
+     * results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * prototype doesn't own an instance of the given component.
+     *
+     * @tparam Component Type of component to get.
+     * @return A reference to the component owned by the prototype.
+     */
+    template<typename Component>
+    inline Component & get() ENTT_NOEXCEPT {
+        return const_cast<Component &>(const_cast<const Prototype *>(this)->get<Component>());
+    }
+
+    /**
+     * @brief Returns a reference to the given components.
+     *
+     * @warning
+     * Attempting to get components from a prototype that doesn't own them
+     * results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * prototype doesn't own instances of the given components.
+     *
+     * @tparam Component Type of components to get.
+     * @return References to the components owned by the prototype.
+     */
+    template<typename... Component>
+    inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<const Component &...>>
+    get() const ENTT_NOEXCEPT {
+        return std::tuple<const Component &...>{get<Component>()...};
+    }
+
+    /**
+     * @brief Returns a reference to the given components.
+     *
+     * @warning
+     * Attempting to get components from a prototype that doesn't own them
+     * results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * prototype doesn't own instances of the given components.
+     *
+     * @tparam Component Type of components to get.
+     * @return References to the components owned by the prototype.
+     */
+    template<typename... Component>
+    inline std::enable_if_t<(sizeof...(Component) > 1), std::tuple<Component &...>>
+    get() ENTT_NOEXCEPT {
+        return std::tuple<Component &...>{get<Component>()...};
+    }
+
+    /**
+     * @brief Creates a new entity using a given prototype.
+     *
+     * Utility shortcut, equivalent to the following snippet:
+     *
+     * @code{.cpp}
+     * const auto entity = registry.create();
+     * prototype(registry, entity);
+     * @endcode
+     *
+     * @note
+     * The registry may or may not be different from the one already used by
+     * the prototype. There is also an overload that directly uses the
+     * underlying registry.
+     *
+     * @param other A valid reference to a registry.
+     * @return A valid entity identifier.
+     */
+    entity_type create(registry_type &other) const {
+        const auto entity = other.create();
+        assign(other, entity);
+        return entity;
+    }
+
+    /**
+     * @brief Creates a new entity using a given prototype.
+     *
+     * Utility shortcut, equivalent to the following snippet:
+     *
+     * @code{.cpp}
+     * const auto entity = registry.create();
+     * prototype(entity);
+     * @endcode
+     *
+     * @note
+     * This overload directly uses the underlying registry as a working space.
+     * Therefore, the components of the prototype and of the entity will share
+     * the same registry.
+     *
+     * @return A valid entity identifier.
+     */
+    inline entity_type create() const {
+        return create(*registry);
+    }
+
+    /**
+     * @brief Assigns the components of a prototype to a given entity.
+     *
+     * Assigning a prototype to an entity won't overwrite existing components
+     * under any circumstances.<br/>
+     * In other words, only those components that the entity doesn't own yet are
+     * copied over. All the other components remain unchanged.
+     *
+     * @note
+     * The registry may or may not be different from the one already used by
+     * the prototype. There is also an overload that directly uses the
+     * underlying registry.
+     *
+     * @warning
+     * Attempting to use an invalid entity results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode in case of
+     * invalid entity.
+     *
+     * @param other A valid reference to a registry.
+     * @param dst A valid entity identifier.
+     */
+    void assign(registry_type &other, const entity_type dst) const {
+        for(auto &handler: handlers) {
+            handler.second.assign(*this, other, dst);
+        }
+    }
+
+    /**
+     * @brief Assigns the components of a prototype to a given entity.
+     *
+     * Assigning a prototype to an entity won't overwrite existing components
+     * under any circumstances.<br/>
+     * In other words, only those components that the entity doesn't own yet are
+     * copied over. All the other components remain unchanged.
+     *
+     * @note
+     * This overload directly uses the underlying registry as a working space.
+     * Therefore, the components of the prototype and of the entity will share
+     * the same registry.
+     *
+     * @warning
+     * Attempting to use an invalid entity results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode in case of
+     * invalid entity.
+     *
+     * @param dst A valid entity identifier.
+     */
+    inline void assign(const entity_type dst) const {
+        assign(*registry, dst);
+    }
+
+    /**
+     * @brief Assigns or replaces the components of a prototype for an entity.
+     *
+     * Existing components are overwritten, if any. All the other components
+     * will be copied over to the target entity.
+     *
+     * @note
+     * The registry may or may not be different from the one already used by
+     * the prototype. There is also an overload that directly uses the
+     * underlying registry.
+     *
+     * @warning
+     * Attempting to use an invalid entity results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode in case of
+     * invalid entity.
+     *
+     * @param other A valid reference to a registry.
+     * @param dst A valid entity identifier.
+     */
+    void accommodate(registry_type &other, const entity_type dst) const {
+        for(auto &handler: handlers) {
+            handler.second.accommodate(*this, other, dst);
+        }
+    }
+
+    /**
+     * @brief Assigns or replaces the components of a prototype for an entity.
+     *
+     * Existing components are overwritten, if any. All the other components
+     * will be copied over to the target entity.
+     *
+     * @note
+     * This overload directly uses the underlying registry as a working space.
+     * Therefore, the components of the prototype and of the entity will share
+     * the same registry.
+     *
+     * @warning
+     * Attempting to use an invalid entity results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode in case of
+     * invalid entity.
+     *
+     * @param dst A valid entity identifier.
+     */
+    inline void accommodate(const entity_type dst) const {
+        accommodate(*registry, dst);
+    }
+
+    /**
+     * @brief Assigns the components of a prototype to an entity.
+     *
+     * Assigning a prototype to an entity won't overwrite existing components
+     * under any circumstances.<br/>
+     * In other words, only the components that the entity doesn't own yet are
+     * copied over. All the other components remain unchanged.
+     *
+     * @note
+     * The registry may or may not be different from the one already used by
+     * the prototype. There is also an overload that directly uses the
+     * underlying registry.
+     *
+     * @warning
+     * Attempting to use an invalid entity results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode in case of
+     * invalid entity.
+     *
+     * @param other A valid reference to a registry.
+     * @param dst A valid entity identifier.
+     */
+    inline void operator()(registry_type &other, const entity_type dst) const ENTT_NOEXCEPT {
+        assign(other, dst);
+    }
+
+    /**
+     * @brief Assigns the components of a prototype to an entity.
+     *
+     * Assigning a prototype to an entity won't overwrite existing components
+     * under any circumstances.<br/>
+     * In other words, only the components that the entity doesn't own yet are
+     * copied over. All the other components remain unchanged.
+     *
+     * @note
+     * This overload directly uses the underlying registry as a working space.
+     * Therefore, the components of the prototype and of the entity will share
+     * the same registry.
+     *
+     * @warning
+     * Attempting to use an invalid entity results in undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode in case of
+     * invalid entity.
+     *
+     * @param dst A valid entity identifier.
+     */
+    inline void operator()(const entity_type dst) const ENTT_NOEXCEPT {
+        assign(*registry, dst);
+    }
+
+    /**
+     * @brief Creates a new entity using a given prototype.
+     *
+     * Utility shortcut, equivalent to the following snippet:
+     *
+     * @code{.cpp}
+     * const auto entity = registry.create();
+     * prototype(registry, entity);
+     * @endcode
+     *
+     * @note
+     * The registry may or may not be different from the one already used by
+     * the prototype. There is also an overload that directly uses the
+     * underlying registry.
+     *
+     * @param other A valid reference to a registry.
+     * @return A valid entity identifier.
+     */
+    inline entity_type operator()(registry_type &other) const ENTT_NOEXCEPT {
+        return create(other);
+    }
+
+    /**
+     * @brief Creates a new entity using a given prototype.
+     *
+     * Utility shortcut, equivalent to the following snippet:
+     *
+     * @code{.cpp}
+     * const auto entity = registry.create();
+     * prototype(entity);
+     * @endcode
+     *
+     * @note
+     * This overload directly uses the underlying registry as a working space.
+     * Therefore, the components of the prototype and of the entity will share
+     * the same registry.
+     *
+     * @return A valid entity identifier.
+     */
+    inline entity_type operator()() const ENTT_NOEXCEPT {
+        return create(*registry);
+    }
+
+private:
+    std::unordered_map<component_type, Handler> handlers;
+    Registry<Entity> *registry;
+    entity_type entity;
+};
+
+
+/**
+ * @brief Default prototype
+ *
+ * The default prototype is the best choice for almost all the
+ * applications.<br/>
+ * Users should have a really good reason to choose something different.
+ */
+using DefaultPrototype = Prototype<DefaultRegistry::entity_type>;
+
+
+}
+
+
+#endif // ENTT_ENTITY_PROTOTYPE_HPP

src/entt/entity/snapshot.hpp

@@ -0,0 +1,724 @@
+#ifndef ENTT_ENTITY_SNAPSHOT_HPP
+#define ENTT_ENTITY_SNAPSHOT_HPP
+
+
+#include <array>
+#include <cstddef>
+#include <utility>
+#include <cassert>
+#include <iterator>
+#include <type_traits>
+#include <unordered_map>
+#include "../config/config.h"
+#include "entt_traits.hpp"
+#include "utility.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Forward declaration of the registry class.
+ */
+template<typename>
+class Registry;
+
+
+/**
+ * @brief Utility class to create snapshots from a registry.
+ *
+ * A _snapshot_ can be either a dump of the entire registry or a narrower
+ * selection of components and tags of interest.<br/>
+ * This type can be used in both cases if provided with a correctly configured
+ * output archive.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class Snapshot final {
+    /*! @brief A registry is allowed to create snapshots. */
+    friend class Registry<Entity>;
+
+    using follow_fn_type = Entity(const Registry<Entity> &, const Entity);
+
+    Snapshot(const Registry<Entity> &registry, Entity seed, follow_fn_type *follow) ENTT_NOEXCEPT
+        : registry{registry},
+          seed{seed},
+          follow{follow}
+    {}
+
+    template<typename Component, typename Archive, typename It>
+    void get(Archive &archive, std::size_t sz, It first, It last) const {
+        archive(static_cast<Entity>(sz));
+
+        while(first != last) {
+            const auto entity = *(first++);
+
+            if(registry.template has<Component>(entity)) {
+                archive(entity, registry.template get<Component>(entity));
+            }
+        }
+    }
+
+    template<typename... Component, typename Archive, typename It, std::size_t... Indexes>
+    void component(Archive &archive, It first, It last, std::index_sequence<Indexes...>) const {
+        std::array<std::size_t, sizeof...(Indexes)> size{};
+        auto begin = first;
+
+        while(begin != last) {
+            const auto entity = *(begin++);
+            using accumulator_type = std::size_t[];
+            accumulator_type accumulator = { (registry.template has<Component>(entity) ? ++size[Indexes] : size[Indexes])... };
+            (void)accumulator;
+        }
+
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (get<Component>(archive, size[Indexes], first, last), 0)... };
+        (void)accumulator;
+    }
+
+public:
+    /*! @brief Copying a snapshot isn't allowed. */
+    Snapshot(const Snapshot &) = delete;
+    /*! @brief Default move constructor. */
+    Snapshot(Snapshot &&) = default;
+
+    /*! @brief Copying a snapshot isn't allowed. @return This snapshot. */
+    Snapshot & operator=(const Snapshot &) = delete;
+    /*! @brief Default move assignment operator. @return This snapshot. */
+    Snapshot & operator=(Snapshot &&) = default;
+
+    /**
+     * @brief Puts aside all the entities that are still in use.
+     *
+     * Entities are serialized along with their versions. Destroyed entities are
+     * not taken in consideration by this function.
+     *
+     * @tparam Archive Type of output archive.
+     * @param archive A valid reference to an output archive.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename Archive>
+    const Snapshot & entities(Archive &archive) const {
+        archive(static_cast<Entity>(registry.alive()));
+        registry.each([&archive](const auto entity) { archive(entity); });
+        return *this;
+    }
+
+    /**
+     * @brief Puts aside destroyed entities.
+     *
+     * Entities are serialized along with their versions. Entities that are
+     * still in use are not taken in consideration by this function.
+     *
+     * @tparam Archive Type of output archive.
+     * @param archive A valid reference to an output archive.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename Archive>
+    const Snapshot & destroyed(Archive &archive) const {
+        auto size = registry.size() - registry.alive();
+        archive(static_cast<Entity>(size));
+
+        if(size) {
+            auto curr = seed;
+            archive(curr);
+
+            for(--size; size; --size) {
+                curr = follow(registry, curr);
+                archive(curr);
+            }
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Puts aside the given component.
+     *
+     * Each instance is serialized together with the entity to which it belongs.
+     * Entities are serialized along with their versions.
+     *
+     * @tparam Component Type of component to serialize.
+     * @tparam Archive Type of output archive.
+     * @param archive A valid reference to an output archive.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename Component, typename Archive>
+    const Snapshot & component(Archive &archive) const {
+        const auto sz = registry.template size<Component>();
+        const auto *entities = registry.template data<Component>();
+
+        archive(static_cast<Entity>(sz));
+
+        for(std::remove_const_t<decltype(sz)> i{}; i < sz; ++i) {
+            const auto entity = entities[i];
+            archive(entity, registry.template get<Component>(entity));
+        };
+
+        return *this;
+    }
+
+    /**
+     * @brief Puts aside the given components.
+     *
+     * Each instance is serialized together with the entity to which it belongs.
+     * Entities are serialized along with their versions.
+     *
+     * @tparam Component Types of components to serialize.
+     * @tparam Archive Type of output archive.
+     * @param archive A valid reference to an output archive.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename... Component, typename Archive>
+    std::enable_if_t<(sizeof...(Component) > 1), const Snapshot &>
+    component(Archive &archive) const {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { 0, (component<Component>(archive), 0)... };
+        (void)accumulator;
+        return *this;
+    }
+
+    /**
+     * @brief Puts aside the given components for the entities in a range.
+     *
+     * Each instance is serialized together with the entity to which it belongs.
+     * Entities are serialized along with their versions.
+     *
+     * @tparam Component Types of components to serialize.
+     * @tparam Archive Type of output archive.
+     * @tparam It Type of input iterator.
+     * @param archive A valid reference to an output archive.
+     * @param first An iterator to the first element of the range to serialize.
+     * @param last An iterator past the last element of the range to serialize.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename... Component, typename Archive, typename It>
+    const Snapshot & component(Archive &archive, It first, It last) const {
+        component<Component...>(archive, first, last, std::make_index_sequence<sizeof...(Component)>{});
+        return *this;
+    }
+
+    /**
+     * @brief Puts aside the given tag.
+     *
+     * Each instance is serialized together with the entity to which it belongs.
+     * Entities are serialized along with their versions.
+     *
+     * @tparam Tag Type of tag to serialize.
+     * @tparam Archive Type of output archive.
+     * @param archive A valid reference to an output archive.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename Tag, typename Archive>
+    const Snapshot & tag(Archive &archive) const {
+        const bool has = registry.template has<Tag>();
+
+        // numerical length is forced for tags to facilitate loading
+        archive(has ? Entity(1): Entity{});
+
+        if(has) {
+            archive(registry.template attachee<Tag>(), registry.template get<Tag>());
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Puts aside the given tags.
+     *
+     * Each instance is serialized together with the entity to which it belongs.
+     * Entities are serialized along with their versions.
+     *
+     * @tparam Tag Types of tags to serialize.
+     * @tparam Archive Type of output archive.
+     * @param archive A valid reference to an output archive.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename... Tag, typename Archive>
+    std::enable_if_t<(sizeof...(Tag) > 1), const Snapshot &>
+    tag(Archive &archive) const {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { 0, (tag<Tag>(archive), 0)... };
+        (void)accumulator;
+        return *this;
+    }
+
+private:
+    const Registry<Entity> &registry;
+    const Entity seed;
+    follow_fn_type *follow;
+};
+
+
+/**
+ * @brief Utility class to restore a snapshot as a whole.
+ *
+ * A snapshot loader requires that the destination registry be empty and loads
+ * all the data at once while keeping intact the identifiers that the entities
+ * originally had.<br/>
+ * An example of use is the implementation of a save/restore utility.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class SnapshotLoader final {
+    /*! @brief A registry is allowed to create snapshot loaders. */
+    friend class Registry<Entity>;
+
+    using assure_fn_type = void(Registry<Entity> &, const Entity, const bool);
+
+    SnapshotLoader(Registry<Entity> &registry, assure_fn_type *assure_fn) ENTT_NOEXCEPT
+        : registry{registry},
+          assure_fn{assure_fn}
+    {
+        // restore a snapshot as a whole requires a clean registry
+        assert(!registry.capacity());
+    }
+
+    template<typename Archive>
+    void assure(Archive &archive, bool destroyed) const {
+        Entity length{};
+        archive(length);
+
+        while(length--) {
+            Entity entity{};
+            archive(entity);
+            assure_fn(registry, entity, destroyed);
+        }
+    }
+
+    template<typename Type, typename Archive, typename... Args>
+    void assign(Archive &archive, Args... args) const {
+        Entity length{};
+        archive(length);
+
+        while(length--) {
+            Entity entity{};
+            Type instance{};
+            archive(entity, instance);
+            static constexpr auto destroyed = false;
+            assure_fn(registry, entity, destroyed);
+            registry.template assign<Type>(args..., entity, static_cast<const Type &>(instance));
+        }
+    }
+
+public:
+    /*! @brief Copying a snapshot loader isn't allowed. */
+    SnapshotLoader(const SnapshotLoader &) = delete;
+    /*! @brief Default move constructor. */
+    SnapshotLoader(SnapshotLoader &&) = default;
+
+    /*! @brief Copying a snapshot loader isn't allowed. @return This loader. */
+    SnapshotLoader & operator=(const SnapshotLoader &) = delete;
+    /*! @brief Default move assignment operator. @return This loader. */
+    SnapshotLoader & operator=(SnapshotLoader &&) = default;
+
+    /**
+     * @brief Restores entities that were in use during serialization.
+     *
+     * This function restores the entities that were in use during serialization
+     * and gives them the versions they originally had.
+     *
+     * @tparam Archive Type of input archive.
+     * @param archive A valid reference to an input archive.
+     * @return A valid loader to continue restoring data.
+     */
+    template<typename Archive>
+    const SnapshotLoader & entities(Archive &archive) const {
+        static constexpr auto destroyed = false;
+        assure(archive, destroyed);
+        return *this;
+    }
+
+    /**
+     * @brief Restores entities that were destroyed during serialization.
+     *
+     * This function restores the entities that were destroyed during
+     * serialization and gives them the versions they originally had.
+     *
+     * @tparam Archive Type of input archive.
+     * @param archive A valid reference to an input archive.
+     * @return A valid loader to continue restoring data.
+     */
+    template<typename Archive>
+    const SnapshotLoader & destroyed(Archive &archive) const {
+        static constexpr auto destroyed = true;
+        assure(archive, destroyed);
+        return *this;
+    }
+
+    /**
+     * @brief Restores components and assigns them to the right entities.
+     *
+     * The template parameter list must be exactly the same used during
+     * serialization. In the event that the entity to which the component is
+     * assigned doesn't exist yet, the loader will take care to create it with
+     * the version it originally had.
+     *
+     * @tparam Component Types of components to restore.
+     * @tparam Archive Type of input archive.
+     * @param archive A valid reference to an input archive.
+     * @return A valid loader to continue restoring data.
+     */
+    template<typename... Component, typename Archive>
+    const SnapshotLoader & component(Archive &archive) const {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { 0, (assign<Component>(archive), 0)... };
+        (void)accumulator;
+        return *this;
+    }
+
+    /**
+     * @brief Restores tags and assigns them to the right entities.
+     *
+     * The template parameter list must be exactly the same used during
+     * serialization. In the event that the entity to which the tag is assigned
+     * doesn't exist yet, the loader will take care to create it with the
+     * version it originally had.
+     *
+     * @tparam Tag Types of tags to restore.
+     * @tparam Archive Type of input archive.
+     * @param archive A valid reference to an input archive.
+     * @return A valid loader to continue restoring data.
+     */
+    template<typename... Tag, typename Archive>
+    const SnapshotLoader & tag(Archive &archive) const {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { 0, (assign<Tag>(archive, tag_t{}), 0)... };
+        (void)accumulator;
+        return *this;
+    }
+
+    /**
+     * @brief Destroys those entities that have neither components nor tags.
+     *
+     * In case all the entities were serialized but only part of the components
+     * and tags was saved, it could happen that some of the entities have
+     * neither components nor tags once restored.<br/>
+     * This functions helps to identify and destroy those entities.
+     *
+     * @return A valid loader to continue restoring data.
+     */
+    const SnapshotLoader & orphans() const {
+        registry.orphans([this](const auto entity) {
+            registry.destroy(entity);
+        });
+
+        return *this;
+    }
+
+private:
+    Registry<Entity> &registry;
+    assure_fn_type *assure_fn;
+};
+
+
+/**
+ * @brief Utility class for _continuous loading_.
+ *
+ * A _continuous loader_ is designed to load data from a source registry to a
+ * (possibly) non-empty destination. The loader can accomodate in a registry
+ * more than one snapshot in a sort of _continuous loading_ that updates the
+ * destination one step at a time.<br/>
+ * Identifiers that entities originally had are not transferred to the target.
+ * Instead, the loader maps remote identifiers to local ones while restoring a
+ * snapshot.<br/>
+ * An example of use is the implementation of a client-server applications with
+ * the requirement of transferring somehow parts of the representation side to
+ * side.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class ContinuousLoader final {
+    using traits_type = entt_traits<Entity>;
+
+    void destroy(Entity entity) {
+        const auto it = remloc.find(entity);
+
+        if(it == remloc.cend()) {
+            const auto local = registry.create();
+            remloc.emplace(entity, std::make_pair(local, true));
+            registry.destroy(local);
+        }
+    }
+
+    void restore(Entity entity) {
+        const auto it = remloc.find(entity);
+
+        if(it == remloc.cend()) {
+            const auto local = registry.create();
+            remloc.emplace(entity, std::make_pair(local, true));
+        } else {
+            remloc[entity].first =
+                    registry.valid(remloc[entity].first)
+                    ? remloc[entity].first
+                    : registry.create();
+
+            // set the dirty flag
+            remloc[entity].second = true;
+        }
+    }
+
+    template<typename Type, typename Member>
+    std::enable_if_t<std::is_same<Member, Entity>::value>
+    update(Type &instance, Member Type:: *member) {
+        instance.*member = map(instance.*member);
+    }
+
+    template<typename Type, typename Member>
+    std::enable_if_t<std::is_same<typename std::iterator_traits<typename Member::iterator>::value_type, Entity>::value>
+    update(Type &instance, Member Type:: *member) {
+        for(auto &entity: instance.*member) {
+            entity = map(entity);
+        }
+    }
+
+    template<typename Other, typename Type, typename Member>
+    std::enable_if_t<!std::is_same<Other, Type>::value>
+    update(Other &, Member Type:: *) {}
+
+    template<typename Archive>
+    void assure(Archive &archive, void(ContinuousLoader:: *member)(Entity)) {
+        Entity length{};
+        archive(length);
+
+        while(length--) {
+            Entity entity{};
+            archive(entity);
+            (this->*member)(entity);
+        }
+    }
+
+    template<typename Component>
+    void reset() {
+        for(auto &&ref: remloc) {
+            const auto local = ref.second.first;
+
+            if(registry.valid(local)) {
+                registry.template reset<Component>(local);
+            }
+        }
+    }
+
+    template<typename Other, typename Archive, typename Func, typename... Type, typename... Member>
+    void assign(Archive &archive, Func func, Member Type:: *... member) {
+        Entity length{};
+        archive(length);
+
+        while(length--) {
+            Entity entity{};
+            Other instance{};
+
+            archive(entity, instance);
+            restore(entity);
+
+            using accumulator_type = int[];
+            accumulator_type accumulator = { 0, (update(instance, member), 0)... };
+            (void)accumulator;
+
+            func(map(entity), instance);
+        }
+    }
+
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+
+    /**
+     * @brief Constructs a loader that is bound to a given registry.
+     * @param registry A valid reference to a registry.
+     */
+    ContinuousLoader(Registry<entity_type> &registry) ENTT_NOEXCEPT
+        : registry{registry}
+    {}
+
+    /*! @brief Copying a snapshot loader isn't allowed. */
+    ContinuousLoader(const ContinuousLoader &) = delete;
+    /*! @brief Default move constructor. */
+    ContinuousLoader(ContinuousLoader &&) = default;
+
+    /*! @brief Copying a snapshot loader isn't allowed. @return This loader. */
+    ContinuousLoader & operator=(const ContinuousLoader &) = delete;
+    /*! @brief Default move assignment operator. @return This loader. */
+    ContinuousLoader & operator=(ContinuousLoader &&) = default;
+
+    /**
+     * @brief Restores entities that were in use during serialization.
+     *
+     * This function restores the entities that were in use during serialization
+     * and creates local counterparts for them if required.
+     *
+     * @tparam Archive Type of input archive.
+     * @param archive A valid reference to an input archive.
+     * @return A non-const reference to this loader.
+     */
+    template<typename Archive>
+    ContinuousLoader & entities(Archive &archive) {
+        assure(archive, &ContinuousLoader::restore);
+        return *this;
+    }
+
+    /**
+     * @brief Restores entities that were destroyed during serialization.
+     *
+     * This function restores the entities that were destroyed during
+     * serialization and creates local counterparts for them if required.
+     *
+     * @tparam Archive Type of input archive.
+     * @param archive A valid reference to an input archive.
+     * @return A non-const reference to this loader.
+     */
+    template<typename Archive>
+    ContinuousLoader & destroyed(Archive &archive) {
+        assure(archive, &ContinuousLoader::destroy);
+        return *this;
+    }
+
+    /**
+     * @brief Restores components and assigns them to the right entities.
+     *
+     * The template parameter list must be exactly the same used during
+     * serialization. In the event that the entity to which the component is
+     * assigned doesn't exist yet, the loader will take care to create a local
+     * counterpart for it.<br/>
+     * Members can be either data members of type entity_type or containers of
+     * entities. In both cases, the loader will visit them and update the
+     * entities by replacing each one with its local counterpart.
+     *
+     * @tparam Component Type of component to restore.
+     * @tparam Archive Type of input archive.
+     * @tparam Type Types of components to update with local counterparts.
+     * @tparam Member Types of members to update with their local counterparts.
+     * @param archive A valid reference to an input archive.
+     * @param member Members to update with their local counterparts.
+     * @return A non-const reference to this loader.
+     */
+    template<typename... Component, typename Archive, typename... Type, typename... Member>
+    ContinuousLoader & component(Archive &archive, Member Type:: *... member) {
+        auto apply = [this](const auto entity, const auto &component) {
+            registry.template accommodate<std::decay_t<decltype(component)>>(entity, component);
+        };
+
+        using accumulator_type = int[];
+        accumulator_type accumulator = { 0, (reset<Component>(), assign<Component>(archive, apply, member...), 0)... };
+        (void)accumulator;
+        return *this;
+    }
+
+    /**
+     * @brief Restores tags and assigns them to the right entities.
+     *
+     * The template parameter list must be exactly the same used during
+     * serialization. In the event that the entity to which the tag is assigned
+     * doesn't exist yet, the loader will take care to create a local
+     * counterpart for it.<br/>
+     * Members can be either data members of type entity_type or containers of
+     * entities. In both cases, the loader will visit them and update the
+     * entities by replacing each one with its local counterpart.
+     *
+     * @tparam Tag Type of tag to restore.
+     * @tparam Archive Type of input archive.
+     * @tparam Type Types of components to update with local counterparts.
+     * @tparam Member Types of members to update with their local counterparts.
+     * @param archive A valid reference to an input archive.
+     * @param member Members to update with their local counterparts.
+     * @return A non-const reference to this loader.
+     */
+    template<typename... Tag, typename Archive, typename... Type, typename... Member>
+    ContinuousLoader & tag(Archive &archive, Member Type:: *... member) {
+        auto apply = [this](const auto entity, const auto &tag) {
+            registry.template assign<std::decay_t<decltype(tag)>>(tag_t{}, entity, tag);
+        };
+
+        using accumulator_type = int[];
+        accumulator_type accumulator = { 0, (registry.template remove<Tag>(), assign<Tag>(archive, apply, member...), 0)... };
+        (void)accumulator;
+        return *this;
+    }
+
+    /**
+     * @brief Helps to purge entities that no longer have a conterpart.
+     *
+     * Users should invoke this member function after restoring each snapshot,
+     * unless they know exactly what they are doing.
+     *
+     * @return A non-const reference to this loader.
+     */
+    ContinuousLoader & shrink() {
+        auto it = remloc.begin();
+
+        while(it != remloc.cend()) {
+            const auto local = it->second.first;
+            bool &dirty = it->second.second;
+
+            if(dirty) {
+                dirty = false;
+                ++it;
+            } else {
+                if(registry.valid(local)) {
+                    registry.destroy(local);
+                }
+
+                it = remloc.erase(it);
+            }
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Destroys those entities that have neither components nor tags.
+     *
+     * In case all the entities were serialized but only part of the components
+     * and tags was saved, it could happen that some of the entities have
+     * neither components nor tags once restored.<br/>
+     * This functions helps to identify and destroy those entities.
+     *
+     * @return A non-const reference to this loader.
+     */
+    ContinuousLoader & orphans() {
+        registry.orphans([this](const auto entity) {
+            registry.destroy(entity);
+        });
+
+        return *this;
+    }
+
+    /**
+     * @brief Tests if a loader knows about a given entity.
+     * @param entity An entity identifier.
+     * @return True if `entity` is managed by the loader, false otherwise.
+     */
+    bool has(entity_type entity) const ENTT_NOEXCEPT {
+        return (remloc.find(entity) != remloc.cend());
+    }
+
+    /**
+     * @brief Returns the identifier to which an entity refers.
+     *
+     * @warning
+     * Attempting to use an entity that isn't managed by the loader results in
+     * undefined behavior.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * loader doesn't knows about the entity.
+     *
+     * @param entity An entity identifier.
+     * @return The identifier to which `entity` refers in the target registry.
+     */
+    entity_type map(entity_type entity) const ENTT_NOEXCEPT {
+        assert(has(entity));
+        return remloc.find(entity)->second.first;
+    }
+
+private:
+    std::unordered_map<Entity, std::pair<Entity, bool>> remloc;
+    Registry<Entity> &registry;
+};
+
+
+}
+
+
+#endif // ENTT_ENTITY_SNAPSHOT_HPP

src/entt/entity/utility.hpp

@@ -0,0 +1,23 @@
+#ifndef ENTT_ENTITY_UTILITY_HPP
+#define ENTT_ENTITY_UTILITY_HPP
+
+
+namespace entt {
+
+
+/*! @brief Tag class type used to disambiguate overloads. */
+struct tag_t final {};
+
+
+/*! @brief Persistent view type used to disambiguate overloads. */
+struct persistent_t final {};
+
+
+/*! @brief Raw view type used to disambiguate overloads. */
+struct raw_t final {};
+
+
+}
+
+
+#endif // ENTT_ENTITY_UTILITY_HPP

src/entt/entt.hpp

@@ -0,0 +1,26 @@
+#include "core/algorithm.hpp"
+#include "core/family.hpp"
+#include "core/hashed_string.hpp"
+#include "core/ident.hpp"
+#include "core/monostate.hpp"
+#include "entity/actor.hpp"
+#include "entity/attachee.hpp"
+#include "entity/entity.hpp"
+#include "entity/entt_traits.hpp"
+#include "entity/helper.hpp"
+#include "entity/prototype.hpp"
+#include "entity/registry.hpp"
+#include "entity/snapshot.hpp"
+#include "entity/sparse_set.hpp"
+#include "entity/utility.hpp"
+#include "entity/view.hpp"
+#include "locator/locator.hpp"
+#include "process/process.hpp"
+#include "process/scheduler.hpp"
+#include "resource/cache.hpp"
+#include "resource/handle.hpp"
+#include "resource/loader.hpp"
+#include "signal/delegate.hpp"
+#include "signal/dispatcher.hpp"
+#include "signal/emitter.hpp"
+#include "signal/sigh.hpp"

src/entt/locator/locator.hpp

@@ -0,0 +1,116 @@
+#ifndef ENTT_LOCATOR_LOCATOR_HPP
+#define ENTT_LOCATOR_LOCATOR_HPP
+
+
+#include <memory>
+#include <utility>
+#include <cassert>
+#include "../config/config.h"
+
+
+namespace entt {
+
+
+/**
+ * @brief Service locator, nothing more.
+ *
+ * A service locator can be used to do what it promises: locate services.<br/>
+ * Usually service locators are tightly bound to the services they expose and
+ * thus it's hard to define a general purpose class to do that. This template
+ * based implementation tries to fill the gap and to get rid of the burden of
+ * defining a different specific locator for each application.
+ *
+ * @tparam Service Type of service managed by the locator.
+ */
+template<typename Service>
+struct ServiceLocator final {
+    /*! @brief Type of service offered. */
+    using service_type = Service;
+
+    /*! @brief Default constructor, deleted on purpose. */
+    ServiceLocator() = delete;
+    /*! @brief Default destructor, deleted on purpose. */
+    ~ServiceLocator() = delete;
+
+    /**
+     * @brief Tests if a valid service implementation is set.
+     * @return True if the service is set, false otherwise.
+     */
+    inline static bool empty() ENTT_NOEXCEPT {
+        return !static_cast<bool>(service);
+    }
+
+    /**
+     * @brief Returns a weak pointer to a service implementation, if any.
+     *
+     * Clients of a service shouldn't retain references to it. The recommended
+     * way is to retrieve the service implementation currently set each and
+     * every time the need of using it arises. Otherwise users can incur in
+     * unexpected behaviors.
+     *
+     * @return A reference to the service implementation currently set, if any.
+     */
+    inline static std::weak_ptr<Service> get() ENTT_NOEXCEPT {
+        return service;
+    }
+
+    /**
+     * @brief Returns a weak reference to a service implementation, if any.
+     *
+     * Clients of a service shouldn't retain references to it. The recommended
+     * way is to retrieve the service implementation currently set each and
+     * every time the need of using it arises. Otherwise users can incur in
+     * unexpected behaviors.
+     *
+     * @warning
+     * In case no service implementation has been set, a call to this function
+     * results in undefined behavior.
+     *
+     * @return A reference to the service implementation currently set, if any.
+     */
+    inline static Service & ref() ENTT_NOEXCEPT {
+        return *service;
+    }
+
+    /**
+     * @brief Sets or replaces a service.
+     * @tparam Impl Type of the new service to use.
+     * @tparam Args Types of arguments to use to construct the service.
+     * @param args Parameters to use to construct the service.
+     */
+    template<typename Impl = Service, typename... Args>
+    inline static void set(Args &&... args) {
+        service = std::make_shared<Impl>(std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Sets or replaces a service.
+     * @param ptr Service to use to replace the current one.
+     */
+    inline static void set(std::shared_ptr<Service> ptr) {
+        assert(static_cast<bool>(ptr));
+        service = std::move(ptr);
+    }
+
+    /**
+     * @brief Resets a service.
+     *
+     * The service is no longer valid after a reset.
+     */
+    inline static void reset() {
+        service.reset();
+    }
+
+private:
+    static std::shared_ptr<Service> service;
+};
+
+
+template<typename Service>
+std::shared_ptr<Service> ServiceLocator<Service>::service{};
+
+
+}
+
+
+#endif // ENTT_LOCATOR_LOCATOR_HPP

src/entt/process/process.hpp

@@ -0,0 +1,339 @@
+#ifndef ENTT_PROCESS_PROCESS_HPP
+#define ENTT_PROCESS_PROCESS_HPP
+
+
+#include <type_traits>
+#include <functional>
+#include <utility>
+#include "../config/config.h"
+
+
+namespace entt {
+
+
+/**
+ * @brief Base class for processes.
+ *
+ * This class stays true to the CRTP idiom. Derived classes must specify what's
+ * the intended type for elapsed times.<br/>
+ * A process should expose publicly the following member functions whether
+ * required:
+ *
+ * * @code{.cpp}
+ *   void update(Delta, void *);
+ *   @endcode
+ *
+ *   It's invoked once per tick until a process is explicitly aborted or it
+ *   terminates either with or without errors. Even though it's not mandatory to
+ *   declare this member function, as a rule of thumb each process should at
+ *   least define it to work properly. The `void *` parameter is an opaque
+ *   pointer to user data (if any) forwarded directly to the process during an
+ *   update.
+ *
+ * * @code{.cpp}
+ *   void init(void *);
+ *   @endcode
+ *
+ *   It's invoked at the first tick, immediately before an update. The `void *`
+ *   parameter is an opaque pointer to user data (if any) forwarded directly to
+ *   the process during an update.
+ *
+ * * @code{.cpp}
+ *   void succeeded();
+ *   @endcode
+ *
+ *   It's invoked in case of success, immediately after an update and during the
+ *   same tick.
+ *
+ * * @code{.cpp}
+ *   void failed();
+ *   @endcode
+ *
+ *   It's invoked in case of errors, immediately after an update and during the
+ *   same tick.
+ *
+ * * @code{.cpp}
+ *   void aborted();
+ *   @endcode
+ *
+ *   It's invoked only if a process is explicitly aborted. There is no guarantee
+ *   that it executes in the same tick, this depends solely on whether the
+ *   process is aborted immediately or not.
+ *
+ * Derived classes can change the internal state of a process by invoking the
+ * `succeed` and `fail` protected member functions and even pause or unpause the
+ * process itself.
+ *
+ * @sa Scheduler
+ *
+ * @tparam Derived Actual type of process that extends the class template.
+ * @tparam Delta Type to use to provide elapsed time.
+ */
+template<typename Derived, typename Delta>
+class Process {
+    enum class State: unsigned int {
+        UNINITIALIZED = 0,
+        RUNNING,
+        PAUSED,
+        SUCCEEDED,
+        FAILED,
+        ABORTED,
+        FINISHED
+    };
+
+    template<State state>
+    using tag = std::integral_constant<State, state>;
+
+    template<typename Target = Derived>
+    auto tick(int, tag<State::UNINITIALIZED>, void *data)
+    -> decltype(std::declval<Target>().init(data)) {
+        static_cast<Target *>(this)->init(data);
+    }
+
+    template<typename Target = Derived>
+    auto tick(int, tag<State::RUNNING>, Delta delta, void *data)
+    -> decltype(std::declval<Target>().update(delta, data)) {
+        static_cast<Target *>(this)->update(delta, data);
+    }
+
+    template<typename Target = Derived>
+    auto tick(int, tag<State::SUCCEEDED>)
+    -> decltype(std::declval<Target>().succeeded()) {
+        static_cast<Target *>(this)->succeeded();
+    }
+
+    template<typename Target = Derived>
+    auto tick(int, tag<State::FAILED>)
+    -> decltype(std::declval<Target>().failed()) {
+        static_cast<Target *>(this)->failed();
+    }
+
+    template<typename Target = Derived>
+    auto tick(int, tag<State::ABORTED>)
+    -> decltype(std::declval<Target>().aborted()) {
+        static_cast<Target *>(this)->aborted();
+    }
+
+    template<State S, typename... Args>
+    void tick(char, tag<S>, Args &&...) const ENTT_NOEXCEPT {}
+
+protected:
+    /**
+     * @brief Terminates a process with success if it's still alive.
+     *
+     * The function is idempotent and it does nothing if the process isn't
+     * alive.
+     */
+    void succeed() ENTT_NOEXCEPT {
+        if(alive()) {
+            current = State::SUCCEEDED;
+        }
+    }
+
+    /**
+     * @brief Terminates a process with errors if it's still alive.
+     *
+     * The function is idempotent and it does nothing if the process isn't
+     * alive.
+     */
+    void fail() ENTT_NOEXCEPT {
+        if(alive()) {
+            current = State::FAILED;
+        }
+    }
+
+    /**
+     * @brief Stops a process if it's in a running state.
+     *
+     * The function is idempotent and it does nothing if the process isn't
+     * running.
+     */
+    void pause() ENTT_NOEXCEPT {
+        if(current == State::RUNNING) {
+            current = State::PAUSED;
+        }
+    }
+
+    /**
+     * @brief Restarts a process if it's paused.
+     *
+     * The function is idempotent and it does nothing if the process isn't
+     * paused.
+     */
+    void unpause() ENTT_NOEXCEPT {
+        if(current  == State::PAUSED) {
+            current  = State::RUNNING;
+        }
+    }
+
+public:
+    /*! @brief Type used to provide elapsed time. */
+    using delta_type = Delta;
+
+    /*! @brief Default destructor. */
+    virtual ~Process() ENTT_NOEXCEPT {
+        static_assert(std::is_base_of<Process, Derived>::value, "!");
+    }
+
+    /**
+     * @brief Aborts a process if it's still alive.
+     *
+     * The function is idempotent and it does nothing if the process isn't
+     * alive.
+     *
+     * @param immediately Requests an immediate operation.
+     */
+    void abort(const bool immediately = false) ENTT_NOEXCEPT {
+        if(alive()) {
+            current = State::ABORTED;
+
+            if(immediately) {
+                tick(0);
+            }
+        }
+    }
+
+    /**
+     * @brief Returns true if a process is either running or paused.
+     * @return True if the process is still alive, false otherwise.
+     */
+    bool alive() const ENTT_NOEXCEPT {
+        return current == State::RUNNING || current == State::PAUSED;
+    }
+
+    /**
+     * @brief Returns true if a process is already terminated.
+     * @return True if the process is terminated, false otherwise.
+     */
+    bool dead() const ENTT_NOEXCEPT {
+        return current == State::FINISHED;
+    }
+
+    /**
+     * @brief Returns true if a process is currently paused.
+     * @return True if the process is paused, false otherwise.
+     */
+    bool paused() const ENTT_NOEXCEPT {
+        return current == State::PAUSED;
+    }
+
+    /**
+     * @brief Returns true if a process terminated with errors.
+     * @return True if the process terminated with errors, false otherwise.
+     */
+    bool rejected() const ENTT_NOEXCEPT {
+        return stopped;
+    }
+
+    /**
+     * @brief Updates a process and its internal state if required.
+     * @param delta Elapsed time.
+     * @param data Optional data.
+     */
+    void tick(const Delta delta, void *data = nullptr) {
+        switch (current) {
+        case State::UNINITIALIZED:
+            tick(0, tag<State::UNINITIALIZED>{}, data);
+            current = State::RUNNING;
+            // no break on purpose, tasks are executed immediately
+        case State::RUNNING:
+            tick(0, tag<State::RUNNING>{}, delta, data);
+        default:
+            // suppress warnings
+            break;
+        }
+
+        // if it's dead, it must be notified and removed immediately
+        switch(current) {
+        case State::SUCCEEDED:
+            tick(0, tag<State::SUCCEEDED>{});
+            current = State::FINISHED;
+            break;
+        case State::FAILED:
+            tick(0, tag<State::FAILED>{});
+            current = State::FINISHED;
+            stopped = true;
+            break;
+        case State::ABORTED:
+            tick(0, tag<State::ABORTED>{});
+            current = State::FINISHED;
+            stopped = true;
+            break;
+        default:
+            // suppress warnings
+            break;
+        }
+    }
+
+private:
+    State current{State::UNINITIALIZED};
+    bool stopped{false};
+};
+
+
+/**
+ * @brief Adaptor for lambdas and functors to turn them into processes.
+ *
+ * Lambdas and functors can't be used directly with a scheduler for they are not
+ * properly defined processes with managed life cycles.<br/>
+ * This class helps in filling the gap and turning lambdas and functors into
+ * full featured processes usable by a scheduler.
+ *
+ * The signature of the function call operator should be equivalent to the
+ * following:
+ *
+ * @code{.cpp}
+ * void(Delta delta, void *data, auto succeed, auto fail);
+ * @endcode
+ *
+ * Where:
+ *
+ * * `delta` is the elapsed time.
+ * * `data` is an opaque pointer to user data if any, `nullptr` otherwise.
+ * * `succeed` is a function to call when a process terminates with success.
+ * * `fail` is a function to call when a process terminates with errors.
+ *
+ * The signature of the function call operator of both `succeed` and `fail`
+ * is equivalent to the following:
+ *
+ * @code{.cpp}
+ * void();
+ * @endcode
+ *
+ * Usually users shouldn't worry about creating adaptors. A scheduler will
+ * create them internally each and avery time a lambda or a functor is used as
+ * a process.
+ *
+ * @sa Process
+ * @sa Scheduler
+ *
+ * @tparam Func Actual type of process.
+ * @tparam Delta Type to use to provide elapsed time.
+ */
+template<typename Func, typename Delta>
+struct ProcessAdaptor: Process<ProcessAdaptor<Func, Delta>, Delta>, private Func {
+    /**
+     * @brief Constructs a process adaptor from a lambda or a functor.
+     * @tparam Args Types of arguments to use to initialize the actual process.
+     * @param args Parameters to use to initialize the actual process.
+     */
+    template<typename... Args>
+    ProcessAdaptor(Args &&... args)
+        : Func{std::forward<Args>(args)...}
+    {}
+
+    /**
+     * @brief Updates a process and its internal state if required.
+     * @param delta Elapsed time.
+     * @param data Optional data.
+     */
+    void update(const Delta delta, void *data) {
+        Func::operator()(delta, data, [this]() { this->succeed(); }, [this]() { this->fail(); });
+    }
+};
+
+
+}
+
+
+#endif // ENTT_PROCESS_PROCESS_HPP

src/entt/process/scheduler.hpp

@@ -0,0 +1,311 @@
+#ifndef ENTT_PROCESS_SCHEDULER_HPP
+#define ENTT_PROCESS_SCHEDULER_HPP
+
+
+#include <vector>
+#include <memory>
+#include <utility>
+#include <algorithm>
+#include <type_traits>
+#include "../config/config.h"
+#include "process.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Cooperative scheduler for processes.
+ *
+ * A cooperative scheduler runs processes and helps managing their life cycles.
+ *
+ * Each process is invoked once per tick. If a process terminates, it's
+ * removed automatically from the scheduler and it's never invoked again.<br/>
+ * A process can also have a child. In this case, the process is replaced with
+ * its child when it terminates if it returns with success. In case of errors,
+ * both the process and its child are discarded.
+ *
+ * Example of use (pseudocode):
+ *
+ * @code{.cpp}
+ * scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
+ *     // code
+ * }).then<MyProcess>(arguments...);
+ * @endcode
+ *
+ * In order to invoke all scheduled processes, call the `update` member function
+ * passing it the elapsed time to forward to the tasks.
+ *
+ * @sa Process
+ *
+ * @tparam Delta Type to use to provide elapsed time.
+ */
+template<typename Delta>
+class Scheduler final {
+    struct ProcessHandler final {
+        using instance_type = std::unique_ptr<void, void(*)(void *)>;
+        using update_fn_type = bool(ProcessHandler &, Delta, void *);
+        using abort_fn_type = void(ProcessHandler &, bool);
+        using next_type = std::unique_ptr<ProcessHandler>;
+
+        instance_type instance;
+        update_fn_type *update;
+        abort_fn_type *abort;
+        next_type next;
+    };
+
+    struct Then final {
+        Then(ProcessHandler *handler)
+            : handler{handler}
+        {}
+
+        template<typename Proc, typename... Args>
+        decltype(auto) then(Args &&... args) && {
+            static_assert(std::is_base_of<Process<Proc, Delta>, Proc>::value, "!");
+            handler = Scheduler::then<Proc>(handler, std::forward<Args>(args)...);
+            return std::move(*this);
+        }
+
+        template<typename Func>
+        decltype(auto) then(Func &&func) && {
+            using Proc = ProcessAdaptor<std::decay_t<Func>, Delta>;
+            return std::move(*this).template then<Proc>(std::forward<Func>(func));
+        }
+
+    private:
+        ProcessHandler *handler;
+    };
+
+    template<typename Proc>
+    static bool update(ProcessHandler &handler, const Delta delta, void *data) {
+        auto *process = static_cast<Proc *>(handler.instance.get());
+        process->tick(delta, data);
+
+        auto dead = process->dead();
+
+        if(dead) {
+            if(handler.next && !process->rejected()) {
+                handler = std::move(*handler.next);
+                dead = handler.update(handler, delta, data);
+            } else {
+                handler.instance.reset();
+            }
+        }
+
+        return dead;
+    }
+
+    template<typename Proc>
+    static void abort(ProcessHandler &handler, const bool immediately) {
+        static_cast<Proc *>(handler.instance.get())->abort(immediately);
+    }
+
+    template<typename Proc>
+    static void deleter(void *proc) {
+        delete static_cast<Proc *>(proc);
+    }
+
+    template<typename Proc, typename... Args>
+    static auto then(ProcessHandler *handler, Args &&... args) {
+        if(handler) {
+            auto proc = typename ProcessHandler::instance_type{new Proc{std::forward<Args>(args)...}, &Scheduler::deleter<Proc>};
+            handler->next.reset(new ProcessHandler{std::move(proc), &Scheduler::update<Proc>, &Scheduler::abort<Proc>, nullptr});
+            handler = handler->next.get();
+        }
+
+        return handler;
+    }
+
+public:
+    /*! @brief Unsigned integer type. */
+    using size_type = typename std::vector<ProcessHandler>::size_type;
+
+    /*! @brief Default constructor. */
+    Scheduler() ENTT_NOEXCEPT = default;
+
+    /*! @brief Copying a scheduler isn't allowed. */
+    Scheduler(const Scheduler &) = delete;
+    /*! @brief Default move constructor. */
+    Scheduler(Scheduler &&) = default;
+
+    /*! @brief Copying a scheduler isn't allowed. @return This scheduler. */
+    Scheduler & operator=(const Scheduler &) = delete;
+    /*! @brief Default move assignment operator. @return This scheduler. */
+    Scheduler & operator=(Scheduler &&) = default;
+
+    /**
+     * @brief Number of processes currently scheduled.
+     * @return Number of processes currently scheduled.
+     */
+    size_type size() const ENTT_NOEXCEPT {
+        return handlers.size();
+    }
+
+    /**
+     * @brief Returns true if at least a process is currently scheduled.
+     * @return True if there are scheduled processes, false otherwise.
+     */
+    bool empty() const ENTT_NOEXCEPT {
+        return handlers.empty();
+    }
+
+    /**
+     * @brief Discards all scheduled processes.
+     *
+     * Processes aren't aborted. They are discarded along with their children
+     * and never executed again.
+     */
+    void clear() {
+        handlers.clear();
+    }
+
+    /**
+     * @brief Schedules a process for the next tick.
+     *
+     * Returned value is an opaque object that can be used to attach a child to
+     * the given process. The child is automatically scheduled when the process
+     * terminates and only if the process returns with success.
+     *
+     * Example of use (pseudocode):
+     *
+     * @code{.cpp}
+     * // schedules a task in the form of a process class
+     * scheduler.attach<MyProcess>(arguments...)
+     * // appends a child in the form of a lambda function
+     * .then([](auto delta, void *, auto succeed, auto fail) {
+     *     // code
+     * })
+     * // appends a child in the form of another process class
+     * .then<MyOtherProcess>();
+     * @endcode
+     *
+     * @tparam Proc Type of process to schedule.
+     * @tparam Args Types of arguments to use to initialize the process.
+     * @param args Parameters to use to initialize the process.
+     * @return An opaque object to use to concatenate processes.
+     */
+    template<typename Proc, typename... Args>
+    auto attach(Args &&... args) {
+        static_assert(std::is_base_of<Process<Proc, Delta>, Proc>::value, "!");
+
+        auto proc = typename ProcessHandler::instance_type{new Proc{std::forward<Args>(args)...}, &Scheduler::deleter<Proc>};
+        ProcessHandler handler{std::move(proc), &Scheduler::update<Proc>, &Scheduler::abort<Proc>, nullptr};
+        handlers.push_back(std::move(handler));
+
+        return Then{&handlers.back()};
+    }
+
+    /**
+     * @brief Schedules a process for the next tick.
+     *
+     * A process can be either a lambda or a functor. The scheduler wraps both
+     * of them in a process adaptor internally.<br/>
+     * The signature of the function call operator should be equivalent to the
+     * following:
+     *
+     * @code{.cpp}
+     * void(Delta delta, auto succeed, auto fail);
+     * @endcode
+     *
+     * Where:
+     *
+     * * `delta` is the elapsed time.
+     * * `succeed` is a function to call when a process terminates with success.
+     * * `fail` is a function to call when a process terminates with errors.
+     *
+     * The signature of the function call operator of both `succeed` and `fail`
+     * is equivalent to the following:
+     *
+     * @code{.cpp}
+     * void();
+     * @endcode
+     *
+     * Returned value is an opaque object that can be used to attach a child to
+     * the given process. The child is automatically scheduled when the process
+     * terminates and only if the process returns with success.
+     *
+     * Example of use (pseudocode):
+     *
+     * @code{.cpp}
+     * // schedules a task in the form of a lambda function
+     * scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
+     *     // code
+     * })
+     * // appends a child in the form of another lambda function
+     * .then([](auto delta, void *, auto succeed, auto fail) {
+     *     // code
+     * })
+     * // appends a child in the form of a process class
+     * .then<MyProcess>(arguments...);
+     * @endcode
+     *
+     * @sa ProcessAdaptor
+     *
+     * @tparam Func Type of process to schedule.
+     * @param func Either a lambda or a functor to use as a process.
+     * @return An opaque object to use to concatenate processes.
+     */
+    template<typename Func>
+    auto attach(Func &&func) {
+        using Proc = ProcessAdaptor<std::decay_t<Func>, Delta>;
+        return attach<Proc>(std::forward<Func>(func));
+    }
+
+    /**
+     * @brief Updates all scheduled processes.
+     *
+     * All scheduled processes are executed in no specific order.<br/>
+     * If a process terminates with success, it's replaced with its child, if
+     * any. Otherwise, if a process terminates with an error, it's removed along
+     * with its child.
+     *
+     * @param delta Elapsed time.
+     * @param data Optional data.
+     */
+    void update(const Delta delta, void *data = nullptr) {
+        bool clean = false;
+
+        for(auto pos = handlers.size(); pos; --pos) {
+            auto &handler = handlers[pos-1];
+            const bool dead = handler.update(handler, delta, data);
+            clean = clean || dead;
+        }
+
+        if(clean) {
+            handlers.erase(std::remove_if(handlers.begin(), handlers.end(), [](auto &handler) {
+                return !handler.instance;
+            }), handlers.end());
+        }
+    }
+
+    /**
+     * @brief Aborts all scheduled processes.
+     *
+     * Unless an immediate operation is requested, the abort is scheduled for
+     * the next tick. Processes won't be executed anymore in any case.<br/>
+     * Once a process is fully aborted and thus finished, it's discarded along
+     * with its child, if any.
+     *
+     * @param immediately Requests an immediate operation.
+     */
+    void abort(const bool immediately = false) {
+        decltype(handlers) exec;
+        exec.swap(handlers);
+
+        std::for_each(exec.begin(), exec.end(), [immediately](auto &handler) {
+            handler.abort(handler, immediately);
+        });
+
+        std::move(handlers.begin(), handlers.end(), std::back_inserter(exec));
+        handlers.swap(exec);
+    }
+
+private:
+    std::vector<ProcessHandler> handlers{};
+};
+
+
+}
+
+
+#endif // ENTT_PROCESS_SCHEDULER_HPP

src/entt/resource/cache.hpp

@@ -0,0 +1,201 @@
+#ifndef ENTT_RESOURCE_CACHE_HPP
+#define ENTT_RESOURCE_CACHE_HPP
+
+
+#include <memory>
+#include <utility>
+#include <type_traits>
+#include <unordered_map>
+#include "../config/config.h"
+#include "../core/hashed_string.hpp"
+#include "handle.hpp"
+#include "loader.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Simple cache for resources of a given type.
+ *
+ * Minimal implementation of a cache for resources of a given type. It doesn't
+ * offer much functionalities but it's suitable for small or medium sized
+ * applications and can be freely inherited to add targeted functionalities for
+ * large sized applications.
+ *
+ * @tparam Resource Type of resources managed by a cache.
+ */
+template<typename Resource>
+class ResourceCache {
+    using container_type = std::unordered_map<HashedString::hash_type, std::shared_ptr<Resource>>;
+
+public:
+    /*! @brief Unsigned integer type. */
+    using size_type = typename container_type::size_type;
+    /*! @brief Type of resources managed by a cache. */
+    using resource_type = HashedString;
+
+    /*! @brief Default constructor. */
+    ResourceCache() = default;
+
+    /*! @brief Copying a cache isn't allowed. */
+    ResourceCache(const ResourceCache &) ENTT_NOEXCEPT = delete;
+    /*! @brief Default move constructor. */
+    ResourceCache(ResourceCache &&) ENTT_NOEXCEPT = default;
+
+    /*! @brief Copying a cache isn't allowed. @return This cache. */
+    ResourceCache & operator=(const ResourceCache &) ENTT_NOEXCEPT = delete;
+    /*! @brief Default move assignment operator. @return This cache. */
+    ResourceCache & operator=(ResourceCache &&) ENTT_NOEXCEPT = default;
+
+    /**
+     * @brief Number of resources managed by a cache.
+     * @return Number of resources currently stored.
+     */
+    size_type size() const ENTT_NOEXCEPT {
+        return resources.size();
+    }
+
+    /**
+     * @brief Returns true if a cache contains no resources, false otherwise.
+     * @return True if the cache contains no resources, false otherwise.
+     */
+    bool empty() const ENTT_NOEXCEPT {
+        return resources.empty();
+    }
+
+    /**
+     * @brief Clears a cache and discards all its resources.
+     *
+     * Handles are not invalidated and the memory used by a resource isn't
+     * freed as long as at least a handle keeps the resource itself alive.
+     */
+    void clear() ENTT_NOEXCEPT {
+        resources.clear();
+    }
+
+    /**
+     * @brief Loads the resource that corresponds to a given identifier.
+     *
+     * In case an identifier isn't already present in the cache, it loads its
+     * resource and stores it aside for future uses. Arguments are forwarded
+     * directly to the loader in order to construct properly the requested
+     * resource.
+     *
+     * @note
+     * If the identifier is already present in the cache, this function does
+     * nothing and the arguments are simply discarded.
+     *
+     * @tparam Loader Type of loader to use to load the resource if required.
+     * @tparam Args Types of arguments to use to load the resource if required.
+     * @param id Unique resource identifier.
+     * @param args Arguments to use to load the resource if required.
+     * @return True if the resource is ready to use, false otherwise.
+     */
+    template<typename Loader, typename... Args>
+    bool load(const resource_type id, Args &&... args) {
+        static_assert(std::is_base_of<ResourceLoader<Loader, Resource>, Loader>::value, "!");
+
+        bool loaded = true;
+
+        if(resources.find(id) == resources.cend()) {
+            std::shared_ptr<Resource> resource = Loader{}.get(std::forward<Args>(args)...);
+            loaded = (static_cast<bool>(resource) ? (resources[id] = std::move(resource), loaded) : false);
+        }
+
+        return loaded;
+    }
+
+    /**
+     * @brief Reloads a resource or loads it for the first time if not present.
+     *
+     * Equivalent to the following snippet (pseudocode):
+     *
+     * @code{.cpp}
+     * cache.discard(id);
+     * cache.load(id, args...);
+     * @endcode
+     *
+     * Arguments are forwarded directly to the loader in order to construct
+     * properly the requested resource.
+     *
+     * @tparam Loader Type of loader to use to load the resource.
+     * @tparam Args Types of arguments to use to load the resource.
+     * @param id Unique resource identifier.
+     * @param args Arguments to use to load the resource.
+     * @return True if the resource is ready to use, false otherwise.
+     */
+    template<typename Loader, typename... Args>
+    bool reload(const resource_type id, Args &&... args) {
+        return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
+    }
+
+    /**
+     * @brief Creates a temporary handle for a resource.
+     *
+     * Arguments are forwarded directly to the loader in order to construct
+     * properly the requested resource. The handle isn't stored aside and the
+     * cache isn't in charge of the lifetime of the resource itself.
+     *
+     * @tparam Loader Type of loader to use to load the resource.
+     * @tparam Args Types of arguments to use to load the resource.
+     * @param args Arguments to use to load the resource.
+     * @return A handle for the given resource.
+     */
+    template<typename Loader, typename... Args>
+    ResourceHandle<Resource> temp(Args &&... args) const {
+        return { Loader{}.get(std::forward<Args>(args)...) };
+    }
+
+    /**
+     * @brief Creates a handle for a given resource identifier.
+     *
+     * A resource handle can be in a either valid or invalid state. In other
+     * terms, a resource handle is properly initialized with a resource if the
+     * cache contains the resource itself. Otherwise the returned handle is
+     * uninitialized and accessing it results in undefined behavior.
+     *
+     * @sa ResourceHandle
+     *
+     * @param id Unique resource identifier.
+     * @return A handle for the given resource.
+     */
+    ResourceHandle<Resource> handle(const resource_type id) const {
+        auto it = resources.find(id);
+        return { it == resources.end() ? nullptr : it->second };
+    }
+
+    /**
+     * @brief Checks if a cache contains a given identifier.
+     * @param id Unique resource identifier.
+     * @return True if the cache contains the resource, false otherwise.
+     */
+    bool contains(const resource_type id) const ENTT_NOEXCEPT {
+        return (resources.find(id) != resources.cend());
+    }
+
+    /**
+     * @brief Discards the resource that corresponds to a given identifier.
+     *
+     * Handles are not invalidated and the memory used by the resource isn't
+     * freed as long as at least a handle keeps the resource itself alive.
+     *
+     * @param id Unique resource identifier.
+     */
+    void discard(const resource_type id) ENTT_NOEXCEPT {
+        auto it = resources.find(id);
+
+        if(it != resources.end()) {
+            resources.erase(it);
+        }
+    }
+
+private:
+    container_type resources;
+};
+
+
+}
+
+
+#endif // ENTT_RESOURCE_CACHE_HPP

src/entt/resource/handle.hpp

@@ -0,0 +1,116 @@
+#ifndef ENTT_RESOURCE_HANDLE_HPP
+#define ENTT_RESOURCE_HANDLE_HPP
+
+
+#include <memory>
+#include <utility>
+#include <cassert>
+#include "../config/config.h"
+
+
+namespace entt {
+
+
+template<typename Resource>
+class ResourceCache;
+
+
+/**
+ * @brief Shared resource handle.
+ *
+ * A shared resource handle is a small class that wraps a resource and keeps it
+ * alive even if it's deleted from the cache. It can be either copied or
+ * moved. A handle shares a reference to the same resource with all the other
+ * handles constructed for the same identifier.<br/>
+ * As a rule of thumb, resources should never be copied nor moved. Handles are
+ * the way to go to keep references to them.
+ *
+ * @tparam Resource Type of resource managed by a handle.
+ */
+template<typename Resource>
+class ResourceHandle final {
+    /*! @brief Resource handles are friends of their caches. */
+    friend class ResourceCache<Resource>;
+
+    ResourceHandle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
+        : resource{std::move(res)}
+    {}
+
+public:
+    /*! @brief Default copy constructor. */
+    ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT = default;
+    /*! @brief Default move constructor. */
+    ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT = default;
+
+    /*! @brief Default copy assignment operator. @return This handle. */
+    ResourceHandle & operator=(const ResourceHandle &) ENTT_NOEXCEPT = default;
+    /*! @brief Default move assignment operator. @return This handle. */
+    ResourceHandle & operator=(ResourceHandle &&) ENTT_NOEXCEPT = default;
+
+    /**
+     * @brief Gets a reference to the managed resource.
+     *
+     * @warning
+     * The behavior is undefined if the handle doesn't contain a resource.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * handle is empty.
+     *
+     * @return A reference to the managed resource.
+     */
+    const Resource & get() const ENTT_NOEXCEPT {
+        assert(static_cast<bool>(resource));
+        return *resource;
+    }
+
+    /**
+     * @brief Casts a handle and gets a reference to the managed resource.
+     *
+     * @warning
+     * The behavior is undefined if the handle doesn't contain a resource.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * handle is empty.
+     */
+    inline operator const Resource &() const ENTT_NOEXCEPT { return get(); }
+
+    /**
+     * @brief Dereferences a handle to obtain the managed resource.
+     *
+     * @warning
+     * The behavior is undefined if the handle doesn't contain a resource.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * handle is empty.
+     *
+     * @return A reference to the managed resource.
+     */
+    inline const Resource & operator *() const ENTT_NOEXCEPT { return get(); }
+
+    /**
+     * @brief Gets a pointer to the managed resource from a handle.
+     *
+     * @warning
+     * The behavior is undefined if the handle doesn't contain a resource.<br/>
+     * An assertion will abort the execution at runtime in debug mode if the
+     * handle is empty.
+     *
+     * @return A pointer to the managed resource or `nullptr` if the handle
+     * contains no resource at all.
+     */
+    inline const Resource * operator ->() const ENTT_NOEXCEPT {
+        assert(static_cast<bool>(resource));
+        return resource.get();
+    }
+
+    /**
+     * @brief Returns true if the handle contains a resource, false otherwise.
+     */
+    explicit operator bool() const { return static_cast<bool>(resource); }
+
+private:
+    std::shared_ptr<Resource> resource;
+};
+
+
+}
+
+
+#endif // ENTT_RESOURCE_HANDLE_HPP

src/entt/resource/loader.hpp

@@ -0,0 +1,62 @@
+#ifndef ENTT_RESOURCE_LOADER_HPP
+#define ENTT_RESOURCE_LOADER_HPP
+
+
+#include <memory>
+
+
+namespace entt {
+
+
+template<typename Resource>
+class ResourceCache;
+
+
+/**
+ * @brief Base class for resource loaders.
+ *
+ * Resource loaders must inherit from this class and stay true to the CRTP
+ * idiom. Moreover, a resource loader must expose a public, const member
+ * function named `load` that accepts a variable number of arguments and returns
+ * a shared pointer to the resource just created.<br/>
+ * As an example:
+ *
+ * @code{.cpp}
+ * struct MyResource {};
+ *
+ * struct MyLoader: entt::ResourceLoader<MyLoader, MyResource> {
+ *     std::shared_ptr<MyResource> load(int) const {
+ *         // use the integer value somehow
+ *         return std::make_shared<MyResource>();
+ *     }
+ * };
+ * @endcode
+ *
+ * In general, resource loaders should not have a state or retain data of any
+ * type. They should let the cache manage their resources instead.
+ *
+ * @note
+ * Base class and CRTP idiom aren't strictly required with the current
+ * implementation. One could argue that a cache can easily work with loaders of
+ * any type. However, future changes won't be breaking ones by forcing the use
+ * of a base class today and that's why the model is already in its place.
+ *
+ * @tparam Loader Type of the derived class.
+ * @tparam Resource Type of resource for which to use the loader.
+ */
+template<typename Loader, typename Resource>
+class ResourceLoader {
+    /*! @brief Resource loaders are friends of their caches. */
+    friend class ResourceCache<Resource>;
+
+    template<typename... Args>
+    std::shared_ptr<Resource> get(Args &&... args) const {
+        return static_cast<const Loader *>(this)->load(std::forward<Args>(args)...);
+    }
+};
+
+
+}
+
+
+#endif // ENTT_RESOURCE_LOADER_HPP

src/entt/signal/delegate.hpp

@@ -0,0 +1,166 @@
+#ifndef ENTT_SIGNAL_DELEGATE_HPP
+#define ENTT_SIGNAL_DELEGATE_HPP
+
+
+#include <utility>
+#include "../config/config.h"
+
+
+namespace entt {
+
+
+/**
+ * @brief Basic delegate implementation.
+ *
+ * Primary template isn't defined on purpose. All the specializations give a
+ * compile-time error unless the template parameter is a function type.
+ */
+template<typename>
+class Delegate;
+
+
+/**
+ * @brief Utility class to send around functions and member functions.
+ *
+ * Unmanaged delegate for function pointers and member functions. Users of this
+ * class are in charge of disconnecting instances before deleting them.
+ *
+ * A delegate can be used as general purpose invoker with no memory overhead for
+ * free functions and member functions provided along with an instance on which
+ * to invoke them.
+ *
+ * @tparam Ret Return type of a function type.
+ * @tparam Args Types of arguments of a function type.
+ */
+template<typename Ret, typename... Args>
+class Delegate<Ret(Args...)> final {
+    using proto_fn_type = Ret(void *, Args...);
+    using stub_type = std::pair<void *, proto_fn_type *>;
+
+    template<Ret(*Function)(Args...)>
+    static Ret proto(void *, Args... args) {
+        return (Function)(args...);
+    }
+
+    template<typename Class, Ret(Class:: *Member)(Args...) const>
+    static Ret proto(void *instance, Args... args) {
+        return (static_cast<const Class *>(instance)->*Member)(args...);
+    }
+
+    template<typename Class, Ret(Class:: *Member)(Args...)>
+    static Ret proto(void *instance, Args... args) {
+        return (static_cast<Class *>(instance)->*Member)(args...);
+    }
+
+public:
+    /*! @brief Default constructor. */
+    Delegate() ENTT_NOEXCEPT
+        : stub{}
+    {}
+
+    /**
+     * @brief Checks whether a delegate actually stores a listener.
+     * @return True if the delegate is empty, false otherwise.
+     */
+    bool empty() const ENTT_NOEXCEPT {
+        // no need to test also stub.first
+        return !stub.second;
+    }
+
+    /**
+     * @brief Binds a free function to a delegate.
+     * @tparam Function A valid free function pointer.
+     */
+    template<Ret(*Function)(Args...)>
+    void connect() ENTT_NOEXCEPT {
+        stub = std::make_pair(nullptr, &proto<Function>);
+    }
+
+    /**
+     * @brief Connects a member function for a given instance to a delegate.
+     *
+     * The delegate isn't responsible for the connected object. Users must
+     * guarantee that the lifetime of the instance overcomes the one of the
+     * delegate.
+     *
+     * @tparam Class Type of class to which the member function belongs.
+     * @tparam Member Member function to connect to the delegate.
+     * @param instance A valid instance of type pointer to `Class`.
+     */
+    template<typename Class, Ret(Class:: *Member)(Args...) const>
+    void connect(Class *instance) ENTT_NOEXCEPT {
+        stub = std::make_pair(instance, &proto<Class, Member>);
+    }
+
+    /**
+     * @brief Connects a member function for a given instance to a delegate.
+     *
+     * The delegate isn't responsible for the connected object. Users must
+     * guarantee that the lifetime of the instance overcomes the one of the
+     * delegate.
+     *
+     * @tparam Class Type of class to which the member function belongs.
+     * @tparam Member Member function to connect to the delegate.
+     * @param instance A valid instance of type pointer to `Class`.
+     */
+    template<typename Class, Ret(Class:: *Member)(Args...)>
+    void connect(Class *instance) ENTT_NOEXCEPT {
+        stub = std::make_pair(instance, &proto<Class, Member>);
+    }
+
+    /**
+     * @brief Resets a delegate.
+     *
+     * After a reset, a delegate can be safely invoked with no effect.
+     */
+    void reset() ENTT_NOEXCEPT {
+        stub.second = nullptr;
+    }
+
+    /**
+     * @brief Triggers a delegate.
+     * @param args Arguments to use to invoke the underlying function.
+     * @return The value returned by the underlying function.
+     */
+    Ret operator()(Args... args) const {
+        return stub.second(stub.first, args...);
+    }
+
+    /**
+     * @brief Checks if the contents of the two delegates are different.
+     *
+     * Two delegates are identical if they contain the same listener.
+     *
+     * @param other Delegate with which to compare.
+     * @return True if the two delegates are identical, false otherwise.
+     */
+    bool operator==(const Delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
+        return stub.first == other.stub.first && stub.second == other.stub.second;
+    }
+
+private:
+    stub_type stub;
+};
+
+
+/**
+ * @brief Checks if the contents of the two delegates are different.
+ *
+ * Two delegates are identical if they contain the same listener.
+ *
+ * @tparam Ret Return type of a function type.
+ * @tparam Args Types of arguments of a function type.
+ * @param lhs A valid delegate object.
+ * @param rhs A valid delegate object.
+ * @return True if the two delegates are different, false otherwise.
+ */
+template<typename Ret, typename... Args>
+bool operator!=(const Delegate<Ret(Args...)> &lhs, const Delegate<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+
+}
+
+
+#endif // ENTT_SIGNAL_DELEGATE_HPP

src/entt/signal/dispatcher.hpp

@@ -0,0 +1,188 @@
+#ifndef ENTT_SIGNAL_DISPATCHER_HPP
+#define ENTT_SIGNAL_DISPATCHER_HPP
+
+
+#include <vector>
+#include <memory>
+#include <utility>
+#include <cstdint>
+#include <algorithm>
+#include <type_traits>
+#include "../config/config.h"
+#include "../core/family.hpp"
+#include "sigh.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Basic dispatcher implementation.
+ *
+ * A dispatcher can be used either to trigger an immediate event or to enqueue
+ * events to be published all together once per tick.<br/>
+ * Listeners are provided in the form of member functions. For each event of
+ * type `Event`, listeners must have the following function type:
+ * @code{.cpp}
+ * void(const Event &)
+ * @endcode
+ *
+ * Member functions named `receive` are automatically detected and registered or
+ * unregistered by the dispatcher. The type of the instances is `Class *` (a
+ * naked pointer). It means that users must guarantee that the lifetimes of the
+ * instances overcome the one of the dispatcher itself to avoid crashes.
+ */
+class Dispatcher final {
+    using event_family = Family<struct InternalDispatcherEventFamily>;
+
+    template<typename Class, typename Event>
+    using instance_type = typename SigH<void(const Event &)>::template instance_type<Class>;
+
+    struct BaseSignalWrapper {
+        virtual ~BaseSignalWrapper() = default;
+        virtual void publish() = 0;
+    };
+
+    template<typename Event>
+    struct SignalWrapper final: BaseSignalWrapper {
+        using sink_type = typename SigH<void(const Event &)>::sink_type;
+
+        void publish() override {
+            const auto &curr = current++;
+            current %= std::extent<decltype(events)>::value;
+            std::for_each(events[curr].cbegin(), events[curr].cend(), [this](const auto &event) { signal.publish(event); });
+            events[curr].clear();
+        }
+
+        inline sink_type sink() ENTT_NOEXCEPT {
+            return signal.sink();
+        }
+
+        template<typename... Args>
+        inline void trigger(Args &&... args) {
+            signal.publish({ std::forward<Args>(args)... });
+        }
+
+        template<typename... Args>
+        inline void enqueue(Args &&... args) {
+            events[current].push_back({ std::forward<Args>(args)... });
+        }
+
+    private:
+        SigH<void(const Event &)> signal{};
+        std::vector<Event> events[2];
+        int current{};
+    };
+
+    template<typename Event>
+    SignalWrapper<Event> & wrapper() {
+        const auto type = event_family::type<Event>();
+
+        if(!(type < wrappers.size())) {
+            wrappers.resize(type + 1);
+        }
+
+        if(!wrappers[type]) {
+            wrappers[type] = std::make_unique<SignalWrapper<Event>>();
+        }
+
+        return static_cast<SignalWrapper<Event> &>(*wrappers[type]);
+    }
+
+public:
+    /*! @brief Type of sink for the given event. */
+    template<typename Event>
+    using sink_type = typename SignalWrapper<Event>::sink_type;
+
+    /**
+     * @brief Returns a sink object for the given event.
+     *
+     * A sink is an opaque object used to connect listeners to events.
+     *
+     * The function type for a listener is:
+     * @code{.cpp}
+     * void(const Event &)
+     * @endcode
+     *
+     * The order of invocation of the listeners isn't guaranteed.
+     *
+     * @sa SigH::Sink
+     *
+     * @tparam Event Type of event of which to get the sink.
+     * @return A temporary sink object.
+     */
+    template<typename Event>
+    inline sink_type<Event> sink() ENTT_NOEXCEPT {
+        return wrapper<Event>().sink();
+    }
+
+    /**
+     * @brief Triggers an immediate event of the given type.
+     *
+     * All the listeners registered for the given type are immediately notified.
+     * The event is discarded after the execution.
+     *
+     * @tparam Event Type of event to trigger.
+     * @tparam Args Types of arguments to use to construct the event.
+     * @param args Arguments to use to construct the event.
+     */
+    template<typename Event, typename... Args>
+    inline void trigger(Args &&... args) {
+        wrapper<Event>().trigger(std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Enqueues an event of the given type.
+     *
+     * An event of the given type is queued. No listener is invoked. Use the
+     * `update` member function to notify listeners when ready.
+     *
+     * @tparam Event Type of event to trigger.
+     * @tparam Args Types of arguments to use to construct the event.
+     * @param args Arguments to use to construct the event.
+     */
+    template<typename Event, typename... Args>
+    inline void enqueue(Args &&... args) {
+        wrapper<Event>().enqueue(std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Delivers all the pending events of the given type.
+     *
+     * This method is blocking and it doesn't return until all the events are
+     * delivered to the registered listeners. It's responsibility of the users
+     * to reduce at a minimum the time spent in the bodies of the listeners.
+     *
+     * @tparam Event Type of events to send.
+     */
+    template<typename Event>
+    inline void update() {
+        wrapper<Event>().publish();
+    }
+
+    /**
+     * @brief Delivers all the pending events.
+     *
+     * This method is blocking and it doesn't return until all the events are
+     * delivered to the registered listeners. It's responsibility of the users
+     * to reduce at a minimum the time spent in the bodies of the listeners.
+     */
+    inline void update() const {
+        for(auto pos = wrappers.size(); pos; --pos) {
+            auto &wrapper = wrappers[pos-1];
+
+            if(wrapper) {
+                wrapper->publish();
+            }
+        }
+    }
+
+private:
+    std::vector<std::unique_ptr<BaseSignalWrapper>> wrappers;
+};
+
+
+}
+
+
+#endif // ENTT_SIGNAL_DISPATCHER_HPP

src/entt/signal/emitter.hpp

@@ -0,0 +1,336 @@
+#ifndef ENTT_SIGNAL_EMITTER_HPP
+#define ENTT_SIGNAL_EMITTER_HPP
+
+
+#include <type_traits>
+#include <functional>
+#include <algorithm>
+#include <utility>
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include <list>
+#include "../config/config.h"
+#include "../core/family.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief General purpose event emitter.
+ *
+ * The emitter class template follows the CRTP idiom. To create a custom emitter
+ * type, derived classes must inherit directly from the base class as:
+ *
+ * ```cpp
+ * struct MyEmitter: Emitter<MyEmitter> {
+ *     // ...
+ * }
+ * ```
+ *
+ * Handlers for the type of events are created internally on the fly. It's not
+ * required to specify in advance the full list of accepted types.<br/>
+ * Moreover, whenever an event is published, an emitter provides the listeners
+ * with a reference to itself along with a const reference to the event.
+ * Therefore listeners have an handy way to work with it without incurring in
+ * the need of capturing a reference to the emitter.
+ *
+ * @tparam Derived Actual type of emitter that extends the class template.
+ */
+template<typename Derived>
+class Emitter {
+    using handler_family = Family<struct InternalEmitterHandlerFamily>;
+
+    struct BaseHandler {
+        virtual ~BaseHandler() = default;
+        virtual bool empty() const ENTT_NOEXCEPT = 0;
+        virtual void clear() ENTT_NOEXCEPT = 0;
+    };
+
+    template<typename Event>
+    struct Handler final: BaseHandler {
+        using listener_type = std::function<void(const Event &, Derived &)>;
+        using element_type = std::pair<bool, listener_type>;
+        using container_type = std::list<element_type>;
+        using connection_type = typename container_type::iterator;
+
+        bool empty() const ENTT_NOEXCEPT override {
+            auto pred = [](auto &&element) { return element.first; };
+
+            return std::all_of(onceL.cbegin(), onceL.cend(), pred) &&
+                    std::all_of(onL.cbegin(), onL.cend(), pred);
+        }
+
+        void clear() ENTT_NOEXCEPT override {
+            if(publishing) {
+                auto func = [](auto &&element) { element.first = true; };
+                std::for_each(onceL.begin(), onceL.end(), func);
+                std::for_each(onL.begin(), onL.end(), func);
+            } else {
+                onceL.clear();
+                onL.clear();
+            }
+        }
+
+        inline connection_type once(listener_type listener) {
+            return onceL.emplace(onceL.cend(), false, std::move(listener));
+        }
+
+        inline connection_type on(listener_type listener) {
+            return onL.emplace(onL.cend(), false, std::move(listener));
+        }
+
+        void erase(connection_type conn) ENTT_NOEXCEPT {
+            conn->first = true;
+
+            if(!publishing) {
+                auto pred = [](auto &&element) { return element.first; };
+                onceL.remove_if(pred);
+                onL.remove_if(pred);
+            }
+        }
+
+        void publish(const Event &event, Derived &ref) {
+            container_type currentL;
+            onceL.swap(currentL);
+
+            auto func = [&event, &ref](auto &&element) {
+                return element.first ? void() : element.second(event, ref);
+            };
+
+            publishing = true;
+
+            std::for_each(onL.rbegin(), onL.rend(), func);
+            std::for_each(currentL.rbegin(), currentL.rend(), func);
+
+            publishing = false;
+
+            onL.remove_if([](auto &&element) { return element.first; });
+        }
+
+    private:
+        bool publishing{false};
+        container_type onceL{};
+        container_type onL{};
+    };
+
+    template<typename Event>
+    Handler<Event> & handler() ENTT_NOEXCEPT {
+        const std::size_t family = handler_family::type<Event>();
+
+        if(!(family < handlers.size())) {
+            handlers.resize(family+1);
+        }
+
+        if(!handlers[family]) {
+            handlers[family] = std::make_unique<Handler<Event>>();
+        }
+
+        return static_cast<Handler<Event> &>(*handlers[family]);
+    }
+
+public:
+    /** @brief Type of listeners accepted for the given event. */
+    template<typename Event>
+    using Listener = typename Handler<Event>::listener_type;
+
+    /**
+     * @brief Generic connection type for events.
+     *
+     * Type of the connection object returned by the event emitter whenever a
+     * listener for the given type is registered.<br/>
+     * It can be used to break connections still in use.
+     *
+     * @tparam Event Type of event for which the connection is created.
+     */
+    template<typename Event>
+    struct Connection final: private Handler<Event>::connection_type {
+        /** @brief Event emitters are friend classes of connections. */
+        friend class Emitter;
+
+        /*! @brief Default constructor. */
+        Connection() ENTT_NOEXCEPT = default;
+
+        /**
+         * @brief Creates a connection that wraps its underlying instance.
+         * @param conn A connection object to wrap.
+         */
+        Connection(typename Handler<Event>::connection_type conn)
+            : Handler<Event>::connection_type{std::move(conn)}
+        {}
+
+        /*! @brief Default copy constructor. */
+        Connection(const Connection &) = default;
+        /*! @brief Default move constructor. */
+        Connection(Connection &&) = default;
+
+        /**
+         * @brief Default copy assignment operator.
+         * @return This connection.
+         */
+        Connection & operator=(const Connection &) = default;
+
+        /**
+         * @brief Default move assignment operator.
+         * @return This connection.
+         */
+        Connection & operator=(Connection &&) = default;
+    };
+
+    /*! @brief Default constructor. */
+    Emitter() ENTT_NOEXCEPT = default;
+
+    /*! @brief Default destructor. */
+    virtual ~Emitter() ENTT_NOEXCEPT {
+        static_assert(std::is_base_of<Emitter<Derived>, Derived>::value, "!");
+    }
+
+    /*! @brief Copying an emitter isn't allowed. */
+    Emitter(const Emitter &) = delete;
+    /*! @brief Default move constructor. */
+    Emitter(Emitter &&) = default;
+
+    /*! @brief Copying an emitter isn't allowed. @return This emitter. */
+    Emitter & operator=(const Emitter &) = delete;
+    /*! @brief Default move assignment operator. @return This emitter. */
+    Emitter & operator=(Emitter &&) = default;
+
+    /**
+     * @brief Emits the given event.
+     *
+     * All the listeners registered for the specific event type are invoked with
+     * the given event. The event type must either have a proper constructor for
+     * the arguments provided or be an aggregate type.
+     *
+     * @tparam Event Type of event to publish.
+     * @tparam Args Types of arguments to use to construct the event.
+     * @param args Parameters to use to initialize the event.
+     */
+    template<typename Event, typename... Args>
+    void publish(Args &&... args) {
+        handler<Event>().publish({ std::forward<Args>(args)... }, *static_cast<Derived *>(this));
+    }
+
+    /**
+     * @brief Registers a long-lived listener with the event emitter.
+     *
+     * This method can be used to register a listener designed to be invoked
+     * more than once for the given event type.<br/>
+     * The connection returned by the method can be freely discarded. It's meant
+     * to be used later to disconnect the listener if required.
+     *
+     * The listener is as a callable object that can be moved and the type of
+     * which is `void(const Event &, Derived &)`.
+     *
+     * @note
+     * Whenever an event is emitted, the emitter provides the listener with a
+     * reference to the derived class. Listeners don't have to capture those
+     * instances for later uses.
+     *
+     * @tparam Event Type of event to which to connect the listener.
+     * @param listener The listener to register.
+     * @return Connection object that can be used to disconnect the listener.
+     */
+    template<typename Event>
+    Connection<Event> on(Listener<Event> listener) {
+        return handler<Event>().on(std::move(listener));
+    }
+
+    /**
+     * @brief Registers a short-lived listener with the event emitter.
+     *
+     * This method can be used to register a listener designed to be invoked
+     * only once for the given event type.<br/>
+     * The connection returned by the method can be freely discarded. It's meant
+     * to be used later to disconnect the listener if required.
+     *
+     * The listener is as a callable object that can be moved and the type of
+     * which is `void(const Event &, Derived &)`.
+     *
+     * @note
+     * Whenever an event is emitted, the emitter provides the listener with a
+     * reference to the derived class. Listeners don't have to capture those
+     * instances for later uses.
+     *
+     * @tparam Event Type of event to which to connect the listener.
+     * @param listener The listener to register.
+     * @return Connection object that can be used to disconnect the listener.
+     */
+    template<typename Event>
+    Connection<Event> once(Listener<Event> listener) {
+        return handler<Event>().once(std::move(listener));
+    }
+
+    /**
+     * @brief Disconnects a listener from the event emitter.
+     *
+     * Do not use twice the same connection to disconnect a listener, it results
+     * in undefined behavior. Once used, discard the connection object.
+     *
+     * @tparam Event Type of event of the connection.
+     * @param conn A valid connection.
+     */
+    template<typename Event>
+    void erase(Connection<Event> conn) ENTT_NOEXCEPT {
+        handler<Event>().erase(std::move(conn));
+    }
+
+    /**
+     * @brief Disconnects all the listeners for the given event type.
+     *
+     * All the connections previously returned for the given event are
+     * invalidated. Using them results in undefined behavior.
+     *
+     * @tparam Event Type of event to reset.
+     */
+    template<typename Event>
+    void clear() ENTT_NOEXCEPT {
+        handler<Event>().clear();
+    }
+
+    /**
+     * @brief Disconnects all the listeners.
+     *
+     * All the connections previously returned are invalidated. Using them
+     * results in undefined behavior.
+     */
+    void clear() ENTT_NOEXCEPT {
+        std::for_each(handlers.begin(), handlers.end(), [](auto &&handler) {
+            return handler ? handler->clear() : void();
+        });
+    }
+
+    /**
+     * @brief Checks if there are listeners registered for the specific event.
+     * @tparam Event Type of event to test.
+     * @return True if there are no listeners registered, false otherwise.
+     */
+    template<typename Event>
+    bool empty() const ENTT_NOEXCEPT {
+        const std::size_t family = handler_family::type<Event>();
+
+        return (!(family < handlers.size()) ||
+                !handlers[family] ||
+                static_cast<Handler<Event> &>(*handlers[family]).empty());
+    }
+
+    /**
+     * @brief Checks if there are listeners registered with the event emitter.
+     * @return True if there are no listeners registered, false otherwise.
+     */
+    bool empty() const ENTT_NOEXCEPT {
+        return std::all_of(handlers.cbegin(), handlers.cend(), [](auto &&handler) {
+            return !handler || handler->empty();
+        });
+    }
+
+private:
+    std::vector<std::unique_ptr<BaseHandler>> handlers{};
+};
+
+
+}
+
+
+#endif // ENTT_SIGNAL_EMITTER_HPP

src/entt/signal/sigh.hpp

@@ -0,0 +1,426 @@
+#ifndef ENTT_SIGNAL_SIGH_HPP
+#define ENTT_SIGNAL_SIGH_HPP
+
+
+#include <algorithm>
+#include <utility>
+#include <vector>
+#include "../config/config.h"
+
+
+namespace entt {
+
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+
+namespace internal {
+
+
+template<typename>
+struct sigh_traits;
+
+
+template<typename Ret, typename... Args>
+struct sigh_traits<Ret(Args...)> {
+    using proto_fn_type = Ret(void *, Args...);
+    using call_type = std::pair<void *, proto_fn_type *>;
+};
+
+
+template<typename, typename>
+struct Invoker;
+
+
+template<typename Ret, typename... Args, typename Collector>
+struct Invoker<Ret(Args...), Collector> {
+    using proto_fn_type = typename sigh_traits<Ret(Args...)>::proto_fn_type;
+
+    virtual ~Invoker() = default;
+
+    bool invoke(Collector &collector, proto_fn_type *proto, void *instance, Args... args) const {
+        return collector(proto(instance, args...));
+    }
+};
+
+
+template<typename... Args, typename Collector>
+struct Invoker<void(Args...), Collector> {
+    using proto_fn_type = typename sigh_traits<void(Args...)>::proto_fn_type;
+
+    virtual ~Invoker() = default;
+
+    bool invoke(Collector &, proto_fn_type *proto, void *instance, Args... args) const {
+        return (proto(instance, args...), true);
+    }
+};
+
+
+template<typename Ret>
+struct NullCollector final {
+    using result_type = Ret;
+    bool operator()(result_type) const ENTT_NOEXCEPT { return true; }
+};
+
+
+template<>
+struct NullCollector<void> final {
+    using result_type = void;
+    bool operator()() const ENTT_NOEXCEPT { return true; }
+};
+
+
+template<typename>
+struct DefaultCollector;
+
+
+template<typename Ret, typename... Args>
+struct DefaultCollector<Ret(Args...)> final {
+    using collector_type = NullCollector<Ret>;
+};
+
+
+template<typename Function>
+using DefaultCollectorType = typename DefaultCollector<Function>::collector_type;
+
+
+}
+
+
+/**
+ * Internal details not to be documented.
+ * @endcond TURN_OFF_DOXYGEN
+ */
+
+
+/**
+ * @brief Sink implementation.
+ *
+ * Primary template isn't defined on purpose. All the specializations give a
+ * compile-time error unless the template parameter is a function type.
+ *
+ * @tparam Function A valid function type.
+ */
+template<typename Function>
+class Sink;
+
+
+/**
+ * @brief Unmanaged signal handler declaration.
+ *
+ * Primary template isn't defined on purpose. All the specializations give a
+ * compile-time error unless the template parameter is a function type.
+ *
+ * @tparam Function A valid function type.
+ * @tparam Collector Type of collector to use, if any.
+ */
+template<typename Function, typename Collector = internal::DefaultCollectorType<Function>>
+class SigH;
+
+
+/**
+ * @brief Sink implementation.
+ *
+ * A sink is an opaque object used to connect listeners to signals.<br/>
+ * The function type for a listener is the one of the signal to which it
+ * belongs.
+ *
+ * The clear separation between a signal and a sink permits to store the
+ * former as private data member without exposing the publish functionality
+ * to the users of a class.
+ *
+ * @tparam Ret Return type of a function type.
+ * @tparam Args Types of arguments of a function type.
+ */
+template<typename Ret, typename... Args>
+class Sink<Ret(Args...)> final {
+    /*! @brief A signal is allowed to create sinks. */
+    template<typename, typename>
+    friend class SigH;
+
+    using call_type = typename internal::sigh_traits<Ret(Args...)>::call_type;
+
+    template<Ret(*Function)(Args...)>
+    static Ret proto(void *, Args... args) {
+        return (Function)(args...);
+    }
+
+    template<typename Class, Ret(Class:: *Member)(Args... args) const>
+    static Ret proto(void *instance, Args... args) {
+        return (static_cast<const Class *>(instance)->*Member)(args...);
+    }
+
+    template<typename Class, Ret(Class:: *Member)(Args... args)>
+    static Ret proto(void *instance, Args... args) {
+        return (static_cast<Class *>(instance)->*Member)(args...);
+    }
+
+    Sink(std::vector<call_type> *calls) ENTT_NOEXCEPT
+        : calls{calls}
+    {}
+
+public:
+    /**
+     * @brief Connects a free function to a signal.
+     *
+     * The signal handler performs checks to avoid multiple connections for
+     * free functions.
+     *
+     * @tparam Function A valid free function pointer.
+     */
+    template<Ret(*Function)(Args...)>
+    void connect() {
+        disconnect<Function>();
+        calls->emplace_back(nullptr, &proto<Function>);
+    }
+
+    /**
+     * @brief Connects a member function for a given instance to a signal.
+     *
+     * The signal isn't responsible for the connected object. Users must
+     * guarantee that the lifetime of the instance overcomes the one of the
+     * signal. On the other side, the signal handler performs checks to
+     * avoid multiple connections for the same member function of a given
+     * instance.
+     *
+     * @tparam Class Type of class to which the member function belongs.
+     * @tparam Member Member function to connect to the signal.
+     * @param instance A valid instance of type pointer to `Class`.
+     */
+    template<typename Class, Ret(Class:: *Member)(Args...) const = &Class::receive>
+    void connect(Class *instance) {
+        disconnect<Class, Member>(instance);
+        calls->emplace_back(instance, &proto<Class, Member>);
+    }
+
+    /**
+     * @brief Connects a member function for a given instance to a signal.
+     *
+     * The signal isn't responsible for the connected object. Users must
+     * guarantee that the lifetime of the instance overcomes the one of the
+     * signal. On the other side, the signal handler performs checks to
+     * avoid multiple connections for the same member function of a given
+     * instance.
+     *
+     * @tparam Class Type of class to which the member function belongs.
+     * @tparam Member Member function to connect to the signal.
+     * @param instance A valid instance of type pointer to `Class`.
+     */
+    template<typename Class, Ret(Class:: *Member)(Args...) = &Class::receive>
+    void connect(Class *instance) {
+        disconnect<Class, Member>(instance);
+        calls->emplace_back(instance, &proto<Class, Member>);
+    }
+
+    /**
+     * @brief Disconnects a free function from a signal.
+     * @tparam Function A valid free function pointer.
+     */
+    template<Ret(*Function)(Args...)>
+    void disconnect() {
+        call_type target{nullptr, &proto<Function>};
+        calls->erase(std::remove(calls->begin(), calls->end(), std::move(target)), calls->end());
+    }
+
+    /**
+     * @brief Disconnects the given member function from a signal.
+     * @tparam Class Type of class to which the member function belongs.
+     * @tparam Member Member function to connect to the signal.
+     * @param instance A valid instance of type pointer to `Class`.
+     */
+    template<typename Class, Ret(Class:: *Member)(Args...) const>
+    void disconnect(Class *instance) {
+        call_type target{instance, &proto<Class, Member>};
+        calls->erase(std::remove(calls->begin(), calls->end(), std::move(target)), calls->end());
+    }
+
+    /**
+     * @brief Disconnects the given member function from a signal.
+     * @tparam Class Type of class to which the member function belongs.
+     * @tparam Member Member function to connect to the signal.
+     * @param instance A valid instance of type pointer to `Class`.
+     */
+    template<typename Class, Ret(Class:: *Member)(Args...)>
+    void disconnect(Class *instance) {
+        call_type target{instance, &proto<Class, Member>};
+        calls->erase(std::remove(calls->begin(), calls->end(), std::move(target)), calls->end());
+    }
+
+    /**
+     * @brief Removes all existing connections for the given instance.
+     * @tparam Class Type of class to which the member function belongs.
+     * @param instance A valid instance of type pointer to `Class`.
+     */
+    template<typename Class>
+    void disconnect(Class *instance) {
+        auto func = [instance](const call_type &call) { return call.first == instance; };
+        calls->erase(std::remove_if(calls->begin(), calls->end(), std::move(func)), calls->end());
+    }
+
+    /**
+     * @brief Disconnects all the listeners from a signal.
+     */
+    void disconnect() {
+        calls->clear();
+    }
+
+private:
+    std::vector<call_type> *calls;
+};
+
+
+/**
+ * @brief Unmanaged signal handler definition.
+ *
+ * Unmanaged signal handler. It works directly with naked pointers to classes
+ * and pointers to member functions as well as pointers to free functions. Users
+ * of this class are in charge of disconnecting instances before deleting them.
+ *
+ * This class serves mainly two purposes:
+ *
+ * * Creating signals used later to notify a bunch of listeners.
+ * * Collecting results from a set of functions like in a voting system.
+ *
+ * The default collector does nothing. To properly collect data, define and use
+ * a class that has a call operator the signature of which is `bool(Param)` and:
+ *
+ * * `Param` is a type to which `Ret` can be converted.
+ * * The return type is true if the handler must stop collecting data, false
+ * otherwise.
+ *
+ * @tparam Ret Return type of a function type.
+ * @tparam Args Types of arguments of a function type.
+ * @tparam Collector Type of collector to use, if any.
+ */
+template<typename Ret, typename... Args, typename Collector>
+class SigH<Ret(Args...), Collector> final: private internal::Invoker<Ret(Args...), Collector> {
+    using call_type = typename internal::sigh_traits<Ret(Args...)>::call_type;
+
+public:
+    /*! @brief Unsigned integer type. */
+    using size_type = typename std::vector<call_type>::size_type;
+    /*! @brief Collector type. */
+    using collector_type = Collector;
+    /*! @brief Sink type. */
+    using sink_type = Sink<Ret(Args...)>;
+
+    /**
+     * @brief Instance type when it comes to connecting member functions.
+     * @tparam Class Type of class to which the member function belongs.
+     */
+    template<typename Class>
+    using instance_type = Class *;
+
+    /**
+     * @brief Number of listeners connected to the signal.
+     * @return Number of listeners currently connected.
+     */
+    size_type size() const ENTT_NOEXCEPT {
+        return calls.size();
+    }
+
+    /**
+     * @brief Returns false if at least a listener is connected to the signal.
+     * @return True if the signal has no listeners connected, false otherwise.
+     */
+    bool empty() const ENTT_NOEXCEPT {
+        return calls.empty();
+    }
+
+    /**
+     * @brief Returns a sink object for the given signal.
+     *
+     * A sink is an opaque object used to connect listeners to signals.<br/>
+     * The function type for a listener is the one of the signal to which it
+     * belongs. The order of invocation of the listeners isn't guaranteed.
+     *
+     * @return A temporary sink object.
+     */
+    sink_type sink() ENTT_NOEXCEPT {
+        return { &calls };
+    }
+
+    /**
+     * @brief Triggers a signal.
+     *
+     * All the listeners are notified. Order isn't guaranteed.
+     *
+     * @param args Arguments to use to invoke listeners.
+     */
+    void publish(Args... args) const {
+        for(auto pos = calls.size(); pos; --pos) {
+            auto &call = calls[pos-1];
+            call.second(call.first, args...);
+        }
+    }
+
+    /**
+     * @brief Collects return values from the listeners.
+     * @param args Arguments to use to invoke listeners.
+     * @return An instance of the collector filled with collected data.
+     */
+    collector_type collect(Args... args) const {
+        collector_type collector;
+
+        for(auto &&call: calls) {
+            if(!this->invoke(collector, call.second, call.first, args...)) {
+                break;
+            }
+        }
+
+        return collector;
+    }
+
+    /**
+     * @brief Swaps listeners between the two signals.
+     * @param lhs A valid signal object.
+     * @param rhs A valid signal object.
+     */
+    friend void swap(SigH &lhs, SigH &rhs) {
+        using std::swap;
+        swap(lhs.calls, rhs.calls);
+    }
+
+    /**
+     * @brief Checks if the contents of the two signals are identical.
+     *
+     * Two signals are identical if they have the same size and the same
+     * listeners registered exactly in the same order.
+     *
+     * @param other Signal with which to compare.
+     * @return True if the two signals are identical, false otherwise.
+     */
+    bool operator==(const SigH &other) const ENTT_NOEXCEPT {
+        return std::equal(calls.cbegin(), calls.cend(), other.calls.cbegin(), other.calls.cend());
+    }
+
+private:
+    std::vector<call_type> calls;
+};
+
+
+/**
+ * @brief Checks if the contents of the two signals are different.
+ *
+ * Two signals are identical if they have the same size and the same
+ * listeners registered exactly in the same order.
+ *
+ * @tparam Ret Return type of a function type.
+ * @tparam Args Types of arguments of a function type.
+ * @param lhs A valid signal object.
+ * @param rhs A valid signal object.
+ * @return True if the two signals are different, false otherwise.
+ */
+template<typename Ret, typename... Args>
+bool operator!=(const SigH<Ret(Args...)> &lhs, const SigH<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+
+}
+
+
+#endif // ENTT_SIGNAL_SIGH_HPP

src/ident.hpp

@@ -1,43 +0,0 @@
-#ifndef ENTT_IDENT_HPP
-#define ENTT_IDENT_HPP
-
-
-#include<type_traits>
-#include<cstddef>
-#include<utility>
-
-
-namespace entt {
-
-
-namespace details {
-
-
-template<typename Type>
-struct Wrapper {
-    using type = Type;
-    constexpr Wrapper(std::size_t index): index{index} {}
-    const std::size_t index;
-};
-
-template<typename... Types>
-struct Identifier final: Wrapper<Types>... {
-    template<std::size_t... Indexes>
-    constexpr Identifier(std::index_sequence<Indexes...>): Wrapper<Types>{Indexes}... {}
-
-    template<typename Type>
-    constexpr std::size_t get() const { return Wrapper<std::decay_t<Type>>::index; }
-};
-
-
-}
-
-
-template<typename... Types>
-constexpr auto ident = details::Identifier<std::decay_t<Types>...>{std::make_index_sequence<sizeof...(Types)>{}};
-
-
-}
-
-
-#endif // ENTT_IDENT_HPP

src/registry.hpp

@@ -1,443 +0,0 @@
-#ifndef ENTT_REGISTRY_HPP
-#define ENTT_REGISTRY_HPP
-
-
-#include <tuple>
-#include <vector>
-#include <bitset>
-#include <utility>
-#include <cstddef>
-#include <cassert>
-#include <type_traits>
-#include "sparse_set.hpp"
-#include "ident.hpp"
-
-
-namespace entt {
-
-
-template<typename, std::size_t...>
-class View;
-
-
-template<typename Pool, std::size_t Ident, std::size_t... Other>
-class View<Pool, Ident, Other...> final {
-    using pool_type = Pool;
-    using mask_type = std::bitset<std::tuple_size<Pool>::value + 1>;
-    using underlying_iterator_type = typename std::tuple_element_t<Ident, Pool>::iterator_type;
-
-    class ViewIterator;
-
-public:
-    using iterator_type = ViewIterator;
-    using entity_type = typename std::tuple_element_t<Ident, Pool>::index_type;
-    using size_type = typename std::tuple_element_t<Ident, Pool>::size_type;
-
-private:
-    class ViewIterator {
-        inline bool valid() const noexcept {
-            return ((mask[*begin] & bitmask) == bitmask);
-        }
-
-    public:
-        using value_type = entity_type;
-
-        ViewIterator(underlying_iterator_type begin, underlying_iterator_type end, const mask_type &bitmask, const mask_type *mask) noexcept
-            : begin{begin}, end{end}, bitmask{bitmask}, mask{mask}
-        {
-            if(begin != end && !valid()) {
-                ++(*this);
-            }
-        }
-
-        ViewIterator & operator++() noexcept {
-            ++begin;
-            while(begin != end && !valid()) { ++begin; }
-            return *this;
-        }
-
-        ViewIterator operator++(int) noexcept {
-            ViewIterator orig = *this;
-            return ++(*this), orig;
-        }
-
-        bool operator==(const ViewIterator &other) const noexcept {
-            return other.begin == begin;
-        }
-
-        bool operator!=(const ViewIterator &other) const noexcept {
-            return !(*this == other);
-        }
-
-        value_type operator*() const noexcept {
-            return *begin;
-        }
-
-    private:
-        underlying_iterator_type begin;
-        underlying_iterator_type end;
-        const mask_type bitmask;
-        const mask_type *mask;
-    };
-
-    template<std::size_t Idx>
-    void prefer(size_type &size) noexcept {
-        auto &&cpool = std::get<Idx>(*pool);
-        auto sz = cpool.size();
-
-        if(sz < size) {
-            from = cpool.begin();
-            to = cpool.end();
-            size = sz;
-        }
-    }
-
-public:
-    explicit View(const pool_type *pool, const mask_type *mask) noexcept
-        : from{std::get<Ident>(*pool).begin()},
-          to{std::get<Ident>(*pool).end()},
-          pool{pool},
-          mask{mask}
-    {
-        using accumulator_type = int[];
-        size_type size = std::get<Ident>(*pool).size();
-        bitmask.set(Ident);
-        accumulator_type types = { 0, (bitmask.set(Other), 0)... };
-        accumulator_type pref = { 0, (prefer<Other>(size), 0)... };
-        (void)types, (void)pref;
-    }
-
-    iterator_type begin() const noexcept {
-        return ViewIterator{from, to, bitmask, mask};
-    }
-
-    iterator_type end() const noexcept {
-        return ViewIterator{to, to, bitmask, mask};
-    }
-
-    void reset() noexcept {
-        using accumulator_type = int[];
-        auto &&cpool = std::get<Ident>(*pool);
-        from = cpool.begin();
-        to = cpool.end();
-        size_type size = cpool.size();
-        accumulator_type accumulator = { 0, (prefer<Other>(size), 0)... };
-        (void)accumulator;
-    }
-
-private:
-    underlying_iterator_type from;
-    underlying_iterator_type to;
-    const pool_type *pool;
-    const mask_type *mask;
-    mask_type bitmask;
-};
-
-
-template<typename Pool, std::size_t Ident>
-class View<Pool, Ident> final {
-    using pool_type = std::tuple_element_t<Ident, Pool>;
-
-public:
-    using iterator_type = typename pool_type::iterator_type;
-    using entity_type = typename pool_type::index_type;
-    using size_type = typename pool_type::size_type;
-    using raw_type = typename pool_type::type;
-
-    explicit View(const Pool *pool) noexcept
-        : pool{&std::get<Ident>(*pool)}
-    {}
-
-    raw_type * raw() noexcept {
-        return pool->raw();
-    }
-
-    const raw_type * raw() const noexcept {
-        return pool->raw();
-    }
-
-    const entity_type * data() const noexcept {
-        return pool->data();
-    }
-
-    size_type size() const noexcept {
-        return pool->size();
-    }
-
-    iterator_type begin() const noexcept {
-        return pool->begin();
-    }
-
-    iterator_type end() const noexcept {
-        return pool->end();
-    }
-
-private:
-    const pool_type *pool;
-};
-
-
-template<typename Entity, typename... Component>
-class Registry {
-    using pool_type = std::tuple<SparseSet<Entity, Component>...>;
-    using mask_type = std::bitset<sizeof...(Component)+1>;
-
-    static constexpr auto validity_bit = sizeof...(Component);
-
-    // variable templates are fine as well, but for the fact that MSVC goes crazy
-    template<typename Comp>
-    struct identifier {
-        static constexpr auto value = ident<Component...>.template get<Comp>();
-    };
-
-public:
-    using entity_type = Entity;
-    using size_type = typename std::vector<mask_type>::size_type;
-
-    template<typename... Comp>
-    using view_type = View<pool_type, identifier<Comp>::value...>;
-
-private:
-    template<typename Comp>
-    void clone(entity_type to, entity_type from) {
-        if(entities[from].test(identifier<Comp>::value)) {
-            assign<Comp>(to, std::get<identifier<Comp>::value>(pool).get(from));
-        }
-    }
-
-    template<typename Comp>
-    void sync(entity_type to, entity_type from) {
-        bool src = entities[from].test(identifier<Comp>::value);
-        bool dst = entities[to].test(identifier<Comp>::value);
-
-        if(src && dst) {
-            copy<Comp>(to, from);
-        } else if(src) {
-            clone<Comp>(to, from);
-        } else if(dst) {
-            remove<Comp>(to);
-        }
-    }
-
-public:
-    explicit Registry() = default;
-    ~Registry() = default;
-
-    Registry(const Registry &) = delete;
-    Registry(Registry &&) = delete;
-
-    Registry & operator=(const Registry &) = delete;
-    Registry & operator=(Registry &&) = delete;
-
-    template<typename Comp>
-    size_type size() const noexcept {
-        return std::get<identifier<Comp>::value>(pool).size();
-    }
-
-    size_type size() const noexcept {
-        return entities.size() - available.size();
-    }
-
-    template<typename Comp>
-    size_type capacity() const noexcept {
-        return std::get<identifier<Comp>::value>(pool).capacity();
-    }
-
-    size_type capacity() const noexcept {
-        return entities.size();
-    }
-
-    template<typename Comp>
-    bool empty() const noexcept {
-        return std::get<identifier<Comp>::value>(pool).empty();
-    }
-
-    bool empty() const noexcept {
-        return entities.empty();
-    }
-
-    bool valid(entity_type entity) const noexcept {
-        return (entity < entities.size() && entities[entity].test(validity_bit));
-    }
-
-    template<typename... Comp>
-    entity_type create() noexcept {
-        using accumulator_type = int[];
-        auto entity = create();
-        accumulator_type accumulator = { 0, (assign<Comp>(entity), 0)... };
-        (void)accumulator;
-        return entity;
-    }
-
-    entity_type create() noexcept {
-        entity_type entity;
-
-        if(available.empty()) {
-            entity = entity_type(entities.size());
-            entities.emplace_back();
-        } else {
-            entity = available.back();
-            available.pop_back();
-        }
-
-        entities[entity].set(validity_bit);
-
-        return entity;
-    }
-
-    void destroy(entity_type entity) {
-        assert(valid(entity));
-        using accumulator_type = int[];
-        accumulator_type accumulator = { 0, (reset<Component>(entity), 0)... };
-        available.push_back(entity);
-        entities[entity].reset();
-        (void)accumulator;
-    }
-
-    template<typename Comp, typename... Args>
-    Comp & assign(entity_type entity, Args... args) {
-        assert(valid(entity));
-        entities[entity].set(identifier<Comp>::value);
-        return std::get<identifier<Comp>::value>(pool).construct(entity, args...);
-    }
-
-    template<typename Comp>
-    void remove(entity_type entity) {
-        assert(valid(entity));
-        entities[entity].reset(identifier<Comp>::value);
-        std::get<identifier<Comp>::value>(pool).destroy(entity);
-    }
-
-    template<typename... Comp>
-    bool has(entity_type entity) const noexcept {
-        assert(valid(entity));
-        using accumulator_type = bool[];
-        bool all = true;
-        auto &mask = entities[entity];
-        accumulator_type accumulator = { true, (all = all && mask.test(identifier<Comp>::value))... };
-        (void)accumulator;
-        return all;
-    }
-
-    template<typename Comp>
-    const Comp & get(entity_type entity) const noexcept {
-        assert(valid(entity));
-        return std::get<identifier<Comp>::value>(pool).get(entity);
-    }
-
-    template<typename Comp>
-    Comp & get(entity_type entity) noexcept {
-        assert(valid(entity));
-        return std::get<identifier<Comp>::value>(pool).get(entity);
-    }
-
-    template<typename Comp, typename... Args>
-    Comp & replace(entity_type entity, Args... args) {
-        assert(valid(entity));
-        return (std::get<identifier<Comp>::value>(pool).get(entity) = Comp{args...});
-    }
-
-    template<typename Comp, typename... Args>
-    Comp & accomodate(entity_type entity, Args... args) {
-        assert(valid(entity));
-
-        return (entities[entity].test(identifier<Comp>::value)
-                ? this->template replace<Comp>(entity, std::forward<Args>(args)...)
-                : this->template assign<Comp>(entity, std::forward<Args>(args)...));
-    }
-
-    entity_type clone(entity_type from) {
-        assert(valid(from));
-        using accumulator_type = int[];
-        auto to = create();
-        accumulator_type accumulator = { 0, (clone<Component>(to, from), 0)... };
-        (void)accumulator;
-        return to;
-    }
-
-    template<typename Comp>
-    Comp & copy(entity_type to, entity_type from) {
-        assert(valid(to));
-        assert(valid(from));
-        auto &&cpool = std::get<identifier<Comp>::value>(pool);
-        return (cpool.get(to) = cpool.get(from));
-    }
-
-    void copy(entity_type to, entity_type from) {
-        assert(valid(to));
-        assert(valid(from));
-        using accumulator_type = int[];
-        accumulator_type accumulator = { 0, (sync<Component>(to, from), 0)... };
-        (void)accumulator;
-    }
-
-    template<typename Comp>
-    void swap(entity_type lhs, entity_type rhs) {
-        assert(valid(lhs));
-        assert(valid(rhs));
-        std::get<identifier<Comp>::value>(pool).swap(lhs, rhs);
-    }
-
-    template<typename Comp, typename Compare>
-    void sort(Compare compare) {
-        std::get<identifier<Comp>::value>(pool).sort(std::move(compare));
-    }
-
-    template<typename To, typename From>
-    void sort() {
-        auto &&to = std::get<identifier<To>::value>(pool);
-        auto &&from = std::get<identifier<From>::value>(pool);
-        to.respect(from);
-    }
-
-    template<typename Comp>
-    void reset(entity_type entity) {
-        assert(valid(entity));
-
-        if(entities[entity].test(identifier<Comp>::value)) {
-            remove<Comp>(entity);
-        }
-    }
-
-    template<typename Comp>
-    void reset() {
-        for(entity_type entity = 0, last = entity_type(entities.size()); entity < last; ++entity) {
-            if(entities[entity].test(identifier<Comp>::value)) {
-                remove<Comp>(entity);
-            }
-        }
-    }
-
-    void reset() {
-        using accumulator_type = int[];
-        accumulator_type acc = { 0, (std::get<identifier<Component>::value>(pool).reset(), 0)... };
-        entities.clear();
-        available.clear();
-        (void)acc;
-    }
-
-    template<typename... Comp>
-    // view_type<Comp...> is fine as well, but for the fact that MSVC dislikes it
-    std::enable_if_t<(sizeof...(Comp) == 1), View<pool_type, identifier<Comp>::value...>>
-    view() noexcept { return view_type<Comp...>{&pool}; }
-
-    template<typename... Comp>
-    // view_type<Comp...> is fine as well, but for the fact that MSVC dislikes it
-    std::enable_if_t<(sizeof...(Comp) > 1), View<pool_type, identifier<Comp>::value...>>
-    view() noexcept { return view_type<Comp...>{&pool, entities.data()}; }
-
-private:
-    std::vector<mask_type> entities;
-    std::vector<entity_type> available;
-    pool_type pool;
-};
-
-
-template<typename... Component>
-using DefaultRegistry = Registry<std::uint32_t, Component...>;
-
-
-}
-
-
-#endif // ENTT_REGISTRY_HPP

src/sparse_set.hpp

@@ -1,277 +0,0 @@
-#ifndef ENTT_COMPONENT_POOL_HPP
-#define ENTT_COMPONENT_POOL_HPP
-
-
-#include <algorithm>
-#include <utility>
-#include <numeric>
-#include <vector>
-#include <cstddef>
-#include <cassert>
-
-
-namespace entt {
-
-
-template<typename...>
-class SparseSet;
-
-
-template<typename Index>
-class SparseSet<Index> {
-    struct SparseSetIterator;
-
-public:
-    using index_type = Index;
-    using pos_type = index_type;
-    using size_type = std::size_t;
-    using iterator_type = SparseSetIterator;
-
-private:
-    struct SparseSetIterator {
-        using value_type = index_type;
-
-        SparseSetIterator(const std::vector<index_type> *direct, size_type pos)
-            : direct{direct}, pos{pos}
-        {}
-
-        SparseSetIterator & operator++() noexcept {
-            return --pos, *this;
-        }
-
-        SparseSetIterator operator++(int) noexcept {
-            SparseSetIterator orig = *this;
-            return ++(*this), orig;
-        }
-
-        bool operator==(const SparseSetIterator &other) const noexcept {
-            return other.pos == pos && other.direct == direct;
-        }
-
-        bool operator!=(const SparseSetIterator &other) const noexcept {
-            return !(*this == other);
-        }
-
-        value_type operator*() const noexcept {
-            return (*direct)[pos-1];
-        }
-
-    private:
-        const std::vector<index_type> *direct;
-        size_type pos;
-    };
-
-    inline bool valid(Index idx) const noexcept {
-        return idx < reverse.size() && reverse[idx] < direct.size() && direct[reverse[idx]] == idx;
-    }
-
-public:
-    explicit SparseSet() = default;
-
-    SparseSet(const SparseSet &) = delete;
-    SparseSet(SparseSet &&) = default;
-
-    ~SparseSet() noexcept {
-        assert(empty());
-    }
-
-    SparseSet & operator=(const SparseSet &) = delete;
-    SparseSet & operator=(SparseSet &&) = default;
-
-    size_type size() const noexcept {
-        return direct.size();
-    }
-
-    size_t capacity() const noexcept {
-        return direct.capacity();
-    }
-
-    bool empty() const noexcept {
-        return direct.empty();
-    }
-
-    const index_type * data() const noexcept {
-        return direct.data();
-    }
-
-    iterator_type begin() const noexcept {
-        return SparseSetIterator{&direct, direct.size()};
-    }
-
-    iterator_type end() const noexcept {
-        return SparseSetIterator{&direct, 0};
-    }
-
-    bool has(index_type idx) const noexcept {
-        return valid(idx);
-    }
-
-    pos_type get(index_type idx) const noexcept {
-        assert(valid(idx));
-        return reverse[idx];
-    }
-
-    pos_type construct(index_type idx) {
-        assert(!valid(idx));
-
-        if(!(idx < reverse.size())) {
-            reverse.resize(idx+1);
-        }
-
-        auto pos = pos_type(direct.size());
-        reverse[idx] = pos;
-        direct.emplace_back(idx);
-
-        return pos;
-    }
-
-    pos_type destroy(index_type idx) {
-        assert(valid(idx));
-
-        auto last = direct.size() - 1;
-        auto pos = reverse[idx];
-
-        reverse[direct[last]] = pos;
-        direct[pos] = direct[last];
-        direct.pop_back();
-
-        return pos;
-    }
-
-    void swap(index_type lhs, index_type rhs) {
-        assert(valid(lhs));
-        assert(valid(rhs));
-
-        std::swap(direct[reverse[lhs]], direct[reverse[rhs]]);
-        std::swap(reverse[lhs], reverse[rhs]);
-    }
-
-    void reset() {
-        reverse.clear();
-        direct.clear();
-    }
-
-private:
-    std::vector<pos_type> reverse;
-    std::vector<index_type> direct;
-};
-
-
-template<typename Index, typename Type>
-class SparseSet<Index, Type> final: public SparseSet<Index> {
-    template<typename Compare>
-    void arrange(Compare compare) {
-        const auto *data = SparseSet<Index>::data();
-        const auto size = SparseSet<Index>::size();
-        std::vector<pos_type> copy(size);
-
-        std::iota(copy.begin(), copy.end(), pos_type{});
-        std::sort(copy.begin(), copy.end(), compare);
-
-        for(pos_type i = 0; i < copy.size(); ++i) {
-            const auto target = i;
-            auto curr = i;
-
-            while(copy[curr] != target) {
-                SparseSet<Index>::swap(*(data + copy[curr]), *(data + curr));
-                std::swap(instances[copy[curr]], instances[curr]);
-                std::swap(copy[curr], curr);
-            }
-
-            copy[curr] = curr;
-        }
-    }
-
-public:
-    using type = Type;
-    using index_type = typename SparseSet<Index>::index_type;
-    using pos_type = typename SparseSet<Index>::pos_type;
-    using size_type = typename SparseSet<Index>::size_type;
-    using iterator_type = typename SparseSet<Index>::iterator_type;
-
-    explicit SparseSet() = default;
-
-    SparseSet(const SparseSet &) = delete;
-    SparseSet(SparseSet &&) = default;
-
-    SparseSet & operator=(const SparseSet &) = delete;
-    SparseSet & operator=(SparseSet &&) = default;
-
-    type * raw() noexcept {
-        return instances.data();
-    }
-
-    const type * raw() const noexcept {
-        return instances.data();
-    }
-
-    const type & get(index_type idx) const noexcept {
-        return instances[SparseSet<Index>::get(idx)];
-    }
-
-    type & get(index_type idx) noexcept {
-        return const_cast<type &>(const_cast<const SparseSet *>(this)->get(idx));
-    }
-
-    template<typename... Args>
-    type & construct(index_type idx, Args&&... args) {
-        SparseSet<Index>::construct(idx);
-        instances.push_back({ std::forward<Args>(args)... });
-        return instances.back();
-    }
-
-    void destroy(index_type idx) {
-        auto pos = SparseSet<Index>::destroy(idx);
-        instances[pos] = std::move(instances[SparseSet<Index>::size()]);
-        instances.pop_back();
-    }
-
-    void swap(index_type lhs, index_type rhs) {
-        std::swap(instances[SparseSet<Index>::get(lhs)], instances[SparseSet<Index>::get(rhs)]);
-    }
-
-    template<typename Compare>
-    void sort(Compare compare) {
-        arrange([this, compare = std::move(compare)](auto lhs, auto rhs) {
-            return !compare(instances[lhs], instances[rhs]);
-        });
-    }
-
-    template<typename Idx>
-    void respect(const SparseSet<Idx> &other) {
-        const auto *data = SparseSet<Index>::data();
-
-        arrange([data, &other](auto lhs, auto rhs) {
-            auto eLhs = *(data + lhs);
-            auto eRhs = *(data + rhs);
-
-            bool bLhs = other.has(eLhs);
-            bool bRhs = other.has(eRhs);
-            bool compare = false;
-
-            if(bLhs && bRhs) {
-                compare = other.get(eLhs) < other.get(eRhs);
-            } else if(!bLhs && !bRhs) {
-                compare = eLhs < eRhs;
-            } else {
-                compare = bRhs;
-            }
-
-            return compare;
-        });
-    }
-
-    void reset() {
-        SparseSet<Index>::reset();
-        instances.clear();
-    }
-
-private:
-    std::vector<type> instances;
-};
-
-
-}
-
-
-#endif // ENTT_COMPONENT_POOL_HPP

test/CMakeLists.txt

@@ -2,25 +2,96 @@
 # Tests configuration
 #
 
-set(COMMON_LINK_LIBS gtest_main Threads::Threads)
+include_directories($<TARGET_PROPERTY:EnTT,INTERFACE_INCLUDE_DIRECTORIES>)
+add_compile_options($<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_OPTIONS>)
 
-# List of available targets
+add_library(odr OBJECT odr.cpp)
+set_target_properties(odr PROPERTIES CXX_EXTENSIONS OFF)
+target_compile_definitions(odr PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_DEFINITIONS>)
+target_compile_features(odr PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_FEATURES>)
+target_compile_options(odr PRIVATE $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-pedantic -Wall>)
+target_compile_options(odr PRIVATE $<$<CXX_COMPILER_ID:MSVC>:/EHsc>)
 
-set(TARGET_ENTT entt)
-set(TARGET_BENCHMARK benchmark)
+macro(SETUP_AND_ADD_TEST TEST_NAME TEST_SOURCE)
+    add_executable(${TEST_NAME} $<TARGET_OBJECTS:odr> ${TEST_SOURCE})
+    set_target_properties(${TEST_NAME} PROPERTIES CXX_EXTENSIONS OFF)
+    target_link_libraries(${TEST_NAME} PRIVATE EnTT GTest::Main Threads::Threads)
+    target_compile_definitions(${TEST_NAME} PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_DEFINITIONS>)
+    target_compile_features(${TEST_NAME} PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_FEATURES>)
+    target_compile_options(${TEST_NAME} PRIVATE $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-pedantic -Wall>)
+    target_compile_options(${TEST_NAME} PRIVATE $<$<CXX_COMPILER_ID:MSVC>:/EHsc>)
+    add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
+endmacro()
 
-# Test TARGET_ENTT
+# Test benchmark
 
-add_executable(${TARGET_ENTT} ident.cpp registry.cpp sparse_set.cpp)
-target_include_directories(${TARGET_ENTT} PRIVATE ${PROJECT_SRC_DIR})
-target_link_libraries(${TARGET_ENTT} PRIVATE ${COMMON_LINK_LIBS})
-add_test(NAME ${TARGET_ENTT} COMMAND ${TARGET_ENTT})
+if(BUILD_BENCHMARK)
+    SETUP_AND_ADD_TEST(benchmark benchmark/benchmark.cpp)
+endif()
 
-# Test TARGET_BENCHMARK
+# Test mod
 
-IF(CMAKE_BUILD_TYPE MATCHES Release)
-    add_executable(${TARGET_BENCHMARK} benchmark.cpp)
-    target_include_directories(${TARGET_BENCHMARK} PRIVATE ${PROJECT_SRC_DIR})
-    target_link_libraries(${TARGET_BENCHMARK} PRIVATE ${COMMON_LINK_LIBS})
-    add_test(NAME ${TARGET_BENCHMARK} COMMAND ${TARGET_BENCHMARK})
-ENDIF()
+if(BUILD_MOD)
+    set(DUKTAPE_DEPS_DIR ${EnTT_SOURCE_DIR}/deps/duktape)
+    configure_file(${EnTT_SOURCE_DIR}/cmake/in/duktape.in ${DUKTAPE_DEPS_DIR}/CMakeLists.txt)
+    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY ${DUKTAPE_DEPS_DIR})
+    execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${DUKTAPE_DEPS_DIR})
+    set(DUKTAPE_SRC_DIR ${DUKTAPE_DEPS_DIR}/src/src)
+
+    set(MOD_TEST_SOURCE ${DUKTAPE_SRC_DIR}/duktape.c mod/mod.cpp)
+    SETUP_AND_ADD_TEST(mod "${MOD_TEST_SOURCE}")
+    target_include_directories(mod PRIVATE ${DUKTAPE_SRC_DIR})
+endif()
+
+# Test snapshot
+
+if(BUILD_SNAPSHOT)
+    set(CEREAL_DEPS_DIR ${EnTT_SOURCE_DIR}/deps/cereal)
+    configure_file(${EnTT_SOURCE_DIR}/cmake/in/cereal.in ${CEREAL_DEPS_DIR}/CMakeLists.txt)
+    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY ${CEREAL_DEPS_DIR})
+    execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${CEREAL_DEPS_DIR})
+    set(CEREAL_SRC_DIR ${CEREAL_DEPS_DIR}/src/include)
+
+    SETUP_AND_ADD_TEST(cereal snapshot/snapshot.cpp)
+    target_include_directories(cereal PRIVATE ${CEREAL_SRC_DIR})
+endif()
+
+# Test core
+
+SETUP_AND_ADD_TEST(algorithm entt/core/algorithm.cpp)
+SETUP_AND_ADD_TEST(family entt/core/family.cpp)
+SETUP_AND_ADD_TEST(hashed_string entt/core/hashed_string.cpp)
+SETUP_AND_ADD_TEST(ident entt/core/ident.cpp)
+SETUP_AND_ADD_TEST(monostate entt/core/monostate.cpp)
+
+# Test entity
+
+SETUP_AND_ADD_TEST(actor entt/entity/actor.cpp)
+SETUP_AND_ADD_TEST(attachee entt/entity/attachee.cpp)
+SETUP_AND_ADD_TEST(entity entt/entity/entity.cpp)
+SETUP_AND_ADD_TEST(helper entt/entity/helper.cpp)
+SETUP_AND_ADD_TEST(prototype entt/entity/prototype.cpp)
+SETUP_AND_ADD_TEST(registry entt/entity/registry.cpp)
+SETUP_AND_ADD_TEST(snapshot entt/entity/snapshot.cpp)
+SETUP_AND_ADD_TEST(sparse_set entt/entity/sparse_set.cpp)
+SETUP_AND_ADD_TEST(view entt/entity/view.cpp)
+
+# Test locator
+
+SETUP_AND_ADD_TEST(locator entt/locator/locator.cpp)
+
+# Test process
+
+SETUP_AND_ADD_TEST(process entt/process/process.cpp)
+SETUP_AND_ADD_TEST(scheduler entt/process/scheduler.cpp)
+
+# Test resource
+
+SETUP_AND_ADD_TEST(resource entt/resource/resource.cpp)
+
+# Test signal
+
+SETUP_AND_ADD_TEST(delegate entt/signal/delegate.cpp)
+SETUP_AND_ADD_TEST(dispatcher entt/signal/dispatcher.cpp)
+SETUP_AND_ADD_TEST(emitter entt/signal/emitter.cpp)
+SETUP_AND_ADD_TEST(sigh entt/signal/sigh.cpp)

test/benchmark.cpp

@@ -1,410 +0,0 @@
-#include <gtest/gtest.h>
-#include <registry.hpp>
-#include <iostream>
-#include <cstddef>
-#include <chrono>
-#include <vector>
-
-struct Position {
-    uint64_t x;
-    uint64_t y;
-};
-
-struct Velocity {
-    uint64_t x;
-    uint64_t y;
-};
-
-template<std::size_t>
-struct Comp {};
-
-struct Timer final {
-    Timer(): start{std::chrono::system_clock::now()} {}
-
-    void elapsed() {
-        auto now = std::chrono::system_clock::now();
-        std::cout << std::chrono::duration<double>(now - start).count() << " seconds" << std::endl;
-    }
-
-private:
-    std::chrono::time_point<std::chrono::system_clock> start;
-};
-
-TEST(DefaultRegistry, Construct) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity>;
-
-    registry_type registry;
-
-    std::cout << "Constructing 10000000 entities" << std::endl;
-
-    Timer timer;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        registry.create();
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, Destroy) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity>;
-
-    registry_type registry;
-    std::vector<registry_type::entity_type> entities{};
-
-    std::cout << "Destroying 10000000 entities" << std::endl;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        entities.push_back(registry.create());
-    }
-
-    Timer timer;
-
-    for (auto entity: entities) {
-        registry.destroy(entity);
-    }
-
-    timer.elapsed();
-}
-
-TEST(DefaultRegistry, IterateCreateDeleteSingleComponent) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity>;
-
-    registry_type registry;
-
-    std::cout << "Looping 10000 times creating and deleting a random number of entities" << std::endl;
-
-    Timer timer;
-
-    for(int i = 0; i < 10000; i++) {
-        for(int j = 0; j < 10000; j++) {
-            registry.create<Position>();
-        }
-
-        auto view = registry.view<Position>();
-
-        for(auto entity: view) {
-            if(rand() % 2 == 0) {
-                registry.destroy(entity);
-            }
-        }
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateSingleComponent10M) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 10000000 entities, one component" << std::endl;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        registry.create<Position>();
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        (void)position;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateTwoComponents10M) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 10000000 entities, two components" << std::endl;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        registry.create<Position, Velocity>();
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position, Velocity>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        auto &velocity = registry.get<Velocity>(entity);
-        (void)position;
-        (void)velocity;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateTwoComponents10MHalf) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 10000000 entities, two components, half of the entities have all the components" << std::endl;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        auto entity = registry.create<Velocity>();
-        if(i % 2) { registry.assign<Position>(entity); }
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position, Velocity>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        auto &velocity = registry.get<Velocity>(entity);
-        (void)position;
-        (void)velocity;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateTwoComponents10MOne) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 10000000 entities, two components, only one entity has all the components" << std::endl;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        auto entity = registry.create<Velocity>();
-        if(i == 5000000L) { registry.assign<Position>(entity); }
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position, Velocity>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        auto &velocity = registry.get<Velocity>(entity);
-        (void)position;
-        (void)velocity;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateSingleComponent50M) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 50000000 entities, one component" << std::endl;
-
-    for (uint64_t i = 0; i < 50000000L; i++) {
-        registry.create<Position>();
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        (void)position;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateTwoComponents50M) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 50000000 entities, two components" << std::endl;
-
-    for (uint64_t i = 0; i < 50000000L; i++) {
-        registry.create<Position, Velocity>();
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position, Velocity>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        auto &velocity = registry.get<Velocity>(entity);
-        (void)position;
-        (void)velocity;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateFiveComponents10M) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 10000000 entities, five components" << std::endl;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>();
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        auto &velocity = registry.get<Velocity>(entity);
-        auto &comp1 = registry.get<Comp<1>>(entity);
-        auto &comp2 = registry.get<Comp<2>>(entity);
-        auto &comp3 = registry.get<Comp<3>>(entity);
-        (void)position;
-        (void)velocity;
-        (void)comp1;
-        (void)comp2;
-        (void)comp3;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateTenComponents10M) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 10000000 entities, ten components" << std::endl;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        auto &velocity = registry.get<Velocity>(entity);
-        auto &comp1 = registry.get<Comp<1>>(entity);
-        auto &comp2 = registry.get<Comp<2>>(entity);
-        auto &comp3 = registry.get<Comp<3>>(entity);
-        auto &comp4 = registry.get<Comp<4>>(entity);
-        auto &comp5 = registry.get<Comp<5>>(entity);
-        auto &comp6 = registry.get<Comp<6>>(entity);
-        auto &comp7 = registry.get<Comp<7>>(entity);
-        auto &comp8 = registry.get<Comp<8>>(entity);
-        (void)position;
-        (void)velocity;
-        (void)comp1;
-        (void)comp2;
-        (void)comp3;
-        (void)comp4;
-        (void)comp5;
-        (void)comp6;
-        (void)comp7;
-        (void)comp8;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateTenComponents10MHalf) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 10000000 entities, ten components, half of the entities have all the components" << std::endl;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        auto entity = registry.create<Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
-        if(i % 2) { registry.assign<Position>(entity); }
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        auto &velocity = registry.get<Velocity>(entity);
-        auto &comp1 = registry.get<Comp<1>>(entity);
-        auto &comp2 = registry.get<Comp<2>>(entity);
-        auto &comp3 = registry.get<Comp<3>>(entity);
-        auto &comp4 = registry.get<Comp<4>>(entity);
-        auto &comp5 = registry.get<Comp<5>>(entity);
-        auto &comp6 = registry.get<Comp<6>>(entity);
-        auto &comp7 = registry.get<Comp<7>>(entity);
-        auto &comp8 = registry.get<Comp<8>>(entity);
-        (void)position;
-        (void)velocity;
-        (void)comp1;
-        (void)comp2;
-        (void)comp3;
-        (void)comp4;
-        (void)comp5;
-        (void)comp6;
-        (void)comp7;
-        (void)comp8;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}
-
-TEST(DefaultRegistry, IterateTenComponents10MOne) {
-    using registry_type = entt::DefaultRegistry<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>;
-
-    registry_type registry;
-
-    std::cout << "Iterating over 10000000 entities, ten components, only one entity has all the components" << std::endl;
-
-    for (uint64_t i = 0; i < 10000000L; i++) {
-        auto entity = registry.create<Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
-        if(i == 5000000L) { registry.assign<Position>(entity); }
-    }
-
-    Timer timer;
-
-    auto view = registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
-
-    for(auto entity: view) {
-        auto &position = registry.get<Position>(entity);
-        auto &velocity = registry.get<Velocity>(entity);
-        auto &comp1 = registry.get<Comp<1>>(entity);
-        auto &comp2 = registry.get<Comp<2>>(entity);
-        auto &comp3 = registry.get<Comp<3>>(entity);
-        auto &comp4 = registry.get<Comp<4>>(entity);
-        auto &comp5 = registry.get<Comp<5>>(entity);
-        auto &comp6 = registry.get<Comp<6>>(entity);
-        auto &comp7 = registry.get<Comp<7>>(entity);
-        auto &comp8 = registry.get<Comp<8>>(entity);
-        (void)position;
-        (void)velocity;
-        (void)comp1;
-        (void)comp2;
-        (void)comp3;
-        (void)comp4;
-        (void)comp5;
-        (void)comp6;
-        (void)comp7;
-        (void)comp8;
-    }
-
-    timer.elapsed();
-    registry.reset();
-}

test/entt/core/algorithm.cpp

@@ -0,0 +1,40 @@
+#include <array>
+#include <gtest/gtest.h>
+#include <entt/core/algorithm.hpp>
+
+TEST(Algorithm, StdSort) {
+    // well, I'm pretty sure it works, it's std::sort!!
+    std::array<int, 5> arr{{4, 1, 3, 2, 0}};
+    entt::StdSort sort;
+
+    sort(arr.begin(), arr.end());
+
+    for(typename decltype(arr)::size_type i = 0; i < (arr.size() - 1); ++i) {
+        ASSERT_LT(arr[i], arr[i+1]);
+    }
+}
+
+TEST(Algorithm, InsertionSort) {
+    std::array<int, 5> arr{{4, 1, 3, 2, 0}};
+    entt::InsertionSort sort;
+
+    sort(arr.begin(), arr.end());
+
+    for(typename decltype(arr)::size_type i = 0; i < (arr.size() - 1); ++i) {
+        ASSERT_LT(arr[i], arr[i+1]);
+    }
+}
+
+TEST(Algorithm, OneShotBubbleSort) {
+    std::array<int, 5> arr{{4, 1, 3, 2, 0}};
+    entt::OneShotBubbleSort sort;
+
+    sort(arr.begin(), arr.end());
+    sort(arr.begin(), arr.end());
+    sort(arr.begin(), arr.end());
+    sort(arr.begin(), arr.end());
+
+    for(typename decltype(arr)::size_type i = 0; i < (arr.size() - 1); ++i) {
+        ASSERT_LT(arr[i], arr[i+1]);
+    }
+}

test/entt/core/family.cpp

@@ -0,0 +1,22 @@
+#include <gtest/gtest.h>
+#include <entt/core/family.hpp>
+
+using my_family = entt::Family<struct MyFamily>;
+using your_family = entt::Family<struct YourFamily>;
+
+TEST(Family, Functionalities) {
+    auto myFamilyType = my_family::type<struct MyFamilyType>();
+    auto mySameFamilyType = my_family::type<struct MyFamilyType>();
+    auto myOtherFamilyType = my_family::type<struct MyOtherFamilyType>();
+    auto yourFamilyType = your_family::type<struct YourFamilyType>();
+
+    ASSERT_EQ(myFamilyType, mySameFamilyType);
+    ASSERT_NE(myFamilyType, myOtherFamilyType);
+    ASSERT_EQ(myFamilyType, yourFamilyType);
+}
+
+TEST(Family, Uniqueness) {
+    ASSERT_EQ(my_family::type<int>(), my_family::type<int &>());
+    ASSERT_EQ(my_family::type<int>(), my_family::type<int &&>());
+    ASSERT_EQ(my_family::type<int>(), my_family::type<const int &>());
+}

test/entt/core/hashed_string.cpp

@@ -0,0 +1,34 @@
+#include <type_traits>
+#include <gtest/gtest.h>
+#include <entt/core/hashed_string.hpp>
+
+TEST(HashedString, Functionalities) {
+    using hash_type = entt::HashedString::hash_type;
+
+    const char *bar = "bar";
+
+    auto fooHs = entt::HashedString{"foo"};
+    auto barHs = entt::HashedString{bar};
+
+    ASSERT_NE(static_cast<hash_type>(fooHs), static_cast<hash_type>(barHs));
+    ASSERT_STREQ(static_cast<const char *>(fooHs), "foo");
+    ASSERT_STREQ(static_cast<const char *>(barHs), bar);
+
+    ASSERT_EQ(fooHs, fooHs);
+    ASSERT_NE(fooHs, barHs);
+
+    entt::HashedString hs{"foobar"};
+
+    ASSERT_EQ(static_cast<hash_type>(hs), 0x85944171f73967e8);
+
+    ASSERT_EQ(fooHs, "foo"_hs);
+    ASSERT_NE(barHs, "foo"_hs);
+}
+
+TEST(HashedString, Constexprness) {
+    using hash_type = entt::HashedString::hash_type;
+    // how would you test a constexpr otherwise?
+    (void)std::integral_constant<hash_type, entt::HashedString{"quux"}>{};
+    (void)std::integral_constant<hash_type, "quux"_hs>{};
+    ASSERT_TRUE(true);
+}

test/entt/core/ident.cpp

@@ -0,0 +1,32 @@
+#include <type_traits>
+#include <gtest/gtest.h>
+#include <entt/core/ident.hpp>
+
+struct AType {};
+struct AnotherType {};
+
+TEST(Identifier, Uniqueness) {
+    using ID = entt::Identifier<AType, AnotherType>;
+    constexpr AType anInstance;
+    constexpr AnotherType anotherInstance;
+
+    ASSERT_NE(ID::get<AType>(), ID::get<AnotherType>());
+    ASSERT_EQ(ID::get<AType>(), ID::get<decltype(anInstance)>());
+    ASSERT_NE(ID::get<AType>(), ID::get<decltype(anotherInstance)>());
+    ASSERT_EQ(ID::get<AType>(), ID::get<AType>());
+    ASSERT_EQ(ID::get<AnotherType>(), ID::get<AnotherType>());
+
+    // test uses in constant expressions
+    switch(ID::get<AnotherType>()) {
+    case ID::get<AType>():
+        FAIL();
+    case ID::get<AnotherType>():
+        SUCCEED();
+    }
+}
+
+TEST(Identifier, SingleType) {
+    using ID = entt::Identifier<AType>;
+    std::integral_constant<ID::identifier_type, ID::get<AType>()> ic;
+    (void)ic;
+}

test/entt/core/monostate.cpp

@@ -0,0 +1,20 @@
+#include <gtest/gtest.h>
+#include <entt/core/hashed_string.hpp>
+#include <entt/core/monostate.hpp>
+
+TEST(Monostate, Functionalities) {
+    const bool bPre = entt::Monostate<entt::HashedString{"foobar"}>{};
+    const int iPre = entt::Monostate<"foobar"_hs>{};
+
+    ASSERT_FALSE(bPre);
+    ASSERT_EQ(iPre, int{});
+
+    entt::Monostate<"foobar"_hs>{} = true;
+    entt::Monostate<"foobar"_hs>{} = 42;
+
+    const bool &bPost = entt::Monostate<"foobar"_hs>{};
+    const int &iPost = entt::Monostate<entt::HashedString{"foobar"}>{};
+
+    ASSERT_TRUE(bPost);
+    ASSERT_EQ(iPost, 42);
+}

test/entt/entity/actor.cpp

@@ -0,0 +1,76 @@
+#include <functional>
+#include <gtest/gtest.h>
+#include <entt/entity/actor.hpp>
+#include <entt/entity/registry.hpp>
+
+struct ActorComponent final {};
+struct ActorTag final {};
+
+TEST(Actor, Component) {
+    entt::DefaultRegistry registry;
+    entt::DefaultActor actor{registry};
+    const auto &cactor = actor;
+
+    ASSERT_EQ(&registry, &actor.registry());
+    ASSERT_EQ(&registry, &cactor.registry());
+    ASSERT_TRUE(registry.empty<ActorComponent>());
+    ASSERT_FALSE(registry.empty());
+    ASSERT_FALSE(actor.has<ActorComponent>());
+
+    const auto &component = actor.assign<ActorComponent>();
+
+    ASSERT_EQ(&component, &actor.get<ActorComponent>());
+    ASSERT_EQ(&component, &cactor.get<ActorComponent>());
+    ASSERT_FALSE(registry.empty<ActorComponent>());
+    ASSERT_FALSE(registry.empty());
+    ASSERT_TRUE(actor.has<ActorComponent>());
+
+    actor.remove<ActorComponent>();
+
+    ASSERT_TRUE(registry.empty<ActorComponent>());
+    ASSERT_FALSE(registry.empty());
+    ASSERT_FALSE(actor.has<ActorComponent>());
+}
+
+TEST(Actor, Tag) {
+    entt::DefaultRegistry registry;
+    entt::DefaultActor actor{registry};
+    const auto &cactor = actor;
+
+    ASSERT_EQ(&registry, &actor.registry());
+    ASSERT_EQ(&registry, &cactor.registry());
+    ASSERT_FALSE(registry.has<ActorTag>());
+    ASSERT_FALSE(actor.has<ActorTag>(entt::tag_t{}));
+
+    const auto &tag = actor.assign<ActorTag>(entt::tag_t{});
+
+    ASSERT_EQ(&tag, &actor.get<ActorTag>(entt::tag_t{}));
+    ASSERT_EQ(&tag, &cactor.get<ActorTag>(entt::tag_t{}));
+    ASSERT_TRUE(registry.has<ActorTag>());
+    ASSERT_FALSE(registry.empty());
+    ASSERT_TRUE(actor.has<ActorTag>(entt::tag_t{}));
+
+    actor.remove<ActorTag>(entt::tag_t{});
+
+    ASSERT_FALSE(registry.has<ActorTag>());
+    ASSERT_FALSE(registry.empty());
+    ASSERT_FALSE(actor.has<ActorTag>(entt::tag_t{}));
+}
+
+TEST(Actor, EntityLifetime) {
+    entt::DefaultRegistry registry;
+    auto *actor = new entt::DefaultActor{registry};
+    actor->assign<ActorComponent>();
+
+    ASSERT_FALSE(registry.empty<ActorComponent>());
+    ASSERT_FALSE(registry.empty());
+
+    registry.each([actor](const auto entity) {
+        ASSERT_EQ(actor->entity(), entity);
+    });
+
+    delete actor;
+
+    ASSERT_TRUE(registry.empty<ActorComponent>());
+    ASSERT_TRUE(registry.empty());
+}

test/entt/entity/attachee.cpp

@@ -0,0 +1,69 @@
+#include <unordered_set>
+#include <gtest/gtest.h>
+#include <entt/entity/attachee.hpp>
+
+TEST(AttacheeNoType, Functionalities) {
+    entt::Attachee<std::uint64_t> attachee;
+
+    attachee.construct(42u);
+
+    ASSERT_EQ(attachee.get(), 42u);
+
+    attachee.destroy();
+
+    ASSERT_NE(attachee.get(), 42u);
+
+    (void)entt::Attachee<std::uint64_t>{std::move(attachee)};
+    entt::Attachee<std::uint64_t> other;
+    other = std::move(attachee);
+}
+
+TEST(AttacheeWithType, Functionalities) {
+    entt::Attachee<std::uint64_t, int> attachee;
+    const auto &cattachee = attachee;
+
+    attachee.construct(42u, 3);
+
+    ASSERT_EQ(attachee.get(), 3);
+    ASSERT_EQ(cattachee.get(), 3);
+    ASSERT_EQ(attachee.Attachee<std::uint64_t>::get(), 42u);
+
+    attachee.move(0u);
+
+    ASSERT_EQ(attachee.get(), 3);
+    ASSERT_EQ(cattachee.get(), 3);
+    ASSERT_EQ(attachee.Attachee<std::uint64_t>::get(), 0u);
+
+    attachee.destroy();
+
+    ASSERT_NE(attachee.Attachee<std::uint64_t>::get(), 0u);
+    ASSERT_NE(attachee.Attachee<std::uint64_t>::get(), 42u);
+}
+
+TEST(AttacheeWithType, AggregatesMustWork) {
+    struct AggregateType { int value; };
+    // the goal of this test is to enforce the requirements for aggregate types
+    entt::Attachee<std::uint64_t, AggregateType>{}.construct(0, 42);
+}
+
+TEST(AttacheeWithType, TypesFromStandardTemplateLibraryMustWork) {
+    // see #37 - this test shouldn't crash, that's all
+    entt::Attachee<std::uint64_t, std::unordered_set<int>> attachee;
+    attachee.construct(0).insert(42);
+    attachee.destroy();
+}
+
+TEST(AttacheeWithType, MoveOnlyComponent) {
+    struct MoveOnlyComponent {
+        MoveOnlyComponent() = default;
+        ~MoveOnlyComponent() = default;
+        MoveOnlyComponent(const MoveOnlyComponent &) = delete;
+        MoveOnlyComponent(MoveOnlyComponent &&) = default;
+        MoveOnlyComponent & operator=(const MoveOnlyComponent &) = delete;
+        MoveOnlyComponent & operator=(MoveOnlyComponent &&) = default;
+    };
+
+    // it's purpose is to ensure that move only components are always accepted
+    entt::Attachee<std::uint64_t, MoveOnlyComponent> attachee;
+    (void)attachee;
+}

test/entt/entity/entity.cpp

@@ -0,0 +1,27 @@
+#include <functional>
+#include <gtest/gtest.h>
+#include <entt/entity/entity.hpp>
+#include <entt/entity/registry.hpp>
+
+template<bool>
+struct S {};
+
+TEST(Traits, Null) {
+    entt::DefaultRegistry registry{};
+
+    const auto entity = registry.create();
+    registry.assign<int>(entity, 42);
+
+    ASSERT_TRUE(~typename entt::DefaultRegistry::entity_type{} == entt::null);
+
+    ASSERT_TRUE(entt::null == entt::null);
+    ASSERT_FALSE(entt::null != entt::null);
+
+    ASSERT_FALSE(entity == entt::null);
+    ASSERT_FALSE(entt::null == entity);
+
+    ASSERT_TRUE(entity != entt::null);
+    ASSERT_TRUE(entt::null != entity);
+
+    ASSERT_FALSE(registry.valid(entt::null));
+}

test/entt/entity/helper.cpp

@@ -0,0 +1,75 @@
+#include <gtest/gtest.h>
+#include <entt/core/hashed_string.hpp>
+#include <entt/entity/helper.hpp>
+#include <entt/entity/registry.hpp>
+
+TEST(Helper, Dependency) {
+    entt::DefaultRegistry registry;
+    const auto entity = registry.create();
+    entt::connect<double, float>(registry.construction<int>());
+
+    ASSERT_FALSE(registry.has<double>(entity));
+    ASSERT_FALSE(registry.has<float>(entity));
+
+    registry.assign<char>(entity);
+
+    ASSERT_FALSE(registry.has<double>(entity));
+    ASSERT_FALSE(registry.has<float>(entity));
+
+    registry.assign<int>(entity);
+
+    ASSERT_TRUE(registry.has<double>(entity));
+    ASSERT_TRUE(registry.has<float>(entity));
+    ASSERT_EQ(registry.get<double>(entity), .0);
+    ASSERT_EQ(registry.get<float>(entity), .0f);
+
+    registry.get<double>(entity) = .3;
+    registry.get<float>(entity) = .1f;
+    registry.remove<int>(entity);
+    registry.assign<int>(entity);
+
+    ASSERT_EQ(registry.get<double>(entity), .3);
+    ASSERT_EQ(registry.get<float>(entity), .1f);
+
+    registry.remove<int>(entity);
+    registry.remove<float>(entity);
+    registry.assign<int>(entity);
+
+    ASSERT_TRUE(registry.has<float>(entity));
+    ASSERT_EQ(registry.get<double>(entity), .3);
+    ASSERT_EQ(registry.get<float>(entity), .0f);
+
+    registry.remove<int>(entity);
+    registry.remove<double>(entity);
+    registry.remove<float>(entity);
+    entt::disconnect<double, float>(registry.construction<int>());
+    registry.assign<int>(entity);
+
+    ASSERT_FALSE(registry.has<double>(entity));
+    ASSERT_FALSE(registry.has<float>(entity));
+}
+
+TEST(Helper, Label) {
+    entt::DefaultRegistry registry;
+    const auto entity = registry.create();
+    registry.assign<entt::label<"foobar"_hs>>(entity);
+    registry.assign<int>(entity, 42);
+    int counter{};
+
+    ASSERT_FALSE(registry.has<entt::label<"barfoo"_hs>>(entity));
+    ASSERT_TRUE(registry.has<entt::label<"foobar"_hs>>(entity));
+
+    for(auto entity: registry.view<int, entt::label<"foobar"_hs>>()) {
+        (void)entity;
+        ++counter;
+    }
+
+    ASSERT_NE(counter, 0);
+
+    for(auto entity: registry.view<entt::label<"foobar"_hs>>()) {
+        (void)entity;
+        --counter;
+    }
+
+    ASSERT_EQ(counter, 0);
+}

test/entt/entity/prototype.cpp

@@ -0,0 +1,153 @@
+#include <gtest/gtest.h>
+#include <entt/entity/prototype.hpp>
+#include <entt/entity/registry.hpp>
+
+TEST(Prototype, SameRegistry) {
+    entt::DefaultRegistry registry;
+    entt::DefaultPrototype prototype{registry};
+    const auto &cprototype = prototype;
+
+    ASSERT_FALSE(registry.empty());
+    ASSERT_FALSE((prototype.has<int, char>()));
+
+    ASSERT_EQ(prototype.set<int>(2), 2);
+    ASSERT_EQ(prototype.set<int>(3), 3);
+    ASSERT_EQ(prototype.set<char>('c'), 'c');
+
+    ASSERT_EQ(prototype.get<int>(), 3);
+    ASSERT_EQ(cprototype.get<char>(), 'c');
+    ASSERT_EQ(std::get<0>(prototype.get<int, char>()), 3);
+    ASSERT_EQ(std::get<1>(cprototype.get<int, char>()), 'c');
+
+    const auto e0 = prototype.create();
+
+    ASSERT_TRUE((prototype.has<int, char>()));
+    ASSERT_FALSE(registry.orphan(e0));
+
+    const auto e1 = prototype();
+    prototype(e0);
+
+    ASSERT_FALSE(registry.orphan(e0));
+    ASSERT_FALSE(registry.orphan(e1));
+
+    ASSERT_TRUE((registry.has<int, char>(e0)));
+    ASSERT_TRUE((registry.has<int, char>(e1)));
+
+    registry.remove<int>(e0);
+    registry.remove<int>(e1);
+    prototype.unset<int>();
+
+    ASSERT_FALSE((prototype.has<int, char>()));
+    ASSERT_FALSE((prototype.has<int>()));
+    ASSERT_TRUE((prototype.has<char>()));
+
+    prototype(e0);
+    prototype(e1);
+
+    ASSERT_FALSE(registry.has<int>(e0));
+    ASSERT_FALSE(registry.has<int>(e1));
+
+    ASSERT_EQ(registry.get<char>(e0), 'c');
+    ASSERT_EQ(registry.get<char>(e1), 'c');
+
+    registry.get<char>(e0) = '*';
+    prototype.assign(e0);
+
+    ASSERT_EQ(registry.get<char>(e0), '*');
+
+    registry.get<char>(e1) = '*';
+    prototype.accommodate(e1);
+
+    ASSERT_EQ(registry.get<char>(e1), 'c');
+}
+
+TEST(Prototype, OtherRegistry) {
+    entt::DefaultRegistry registry;
+    entt::DefaultRegistry repository;
+    entt::DefaultPrototype prototype{repository};
+    const auto &cprototype = prototype;
+
+    ASSERT_TRUE(registry.empty());
+    ASSERT_FALSE((prototype.has<int, char>()));
+
+    ASSERT_EQ(prototype.set<int>(2), 2);
+    ASSERT_EQ(prototype.set<int>(3), 3);
+    ASSERT_EQ(prototype.set<char>('c'), 'c');
+
+    ASSERT_EQ(prototype.get<int>(), 3);
+    ASSERT_EQ(cprototype.get<char>(), 'c');
+    ASSERT_EQ(std::get<0>(prototype.get<int, char>()), 3);
+    ASSERT_EQ(std::get<1>(cprototype.get<int, char>()), 'c');
+
+    const auto e0 = prototype.create(registry);
+
+    ASSERT_TRUE((prototype.has<int, char>()));
+    ASSERT_FALSE(registry.orphan(e0));
+
+    const auto e1 = prototype(registry);
+    prototype(registry, e0);
+
+    ASSERT_FALSE(registry.orphan(e0));
+    ASSERT_FALSE(registry.orphan(e1));
+
+    ASSERT_TRUE((registry.has<int, char>(e0)));
+    ASSERT_TRUE((registry.has<int, char>(e1)));
+
+    registry.remove<int>(e0);
+    registry.remove<int>(e1);
+    prototype.unset<int>();
+
+    ASSERT_FALSE((prototype.has<int, char>()));
+    ASSERT_FALSE((prototype.has<int>()));
+    ASSERT_TRUE((prototype.has<char>()));
+
+    prototype(registry, e0);
+    prototype(registry, e1);
+
+    ASSERT_FALSE(registry.has<int>(e0));
+    ASSERT_FALSE(registry.has<int>(e1));
+
+    ASSERT_EQ(registry.get<char>(e0), 'c');
+    ASSERT_EQ(registry.get<char>(e1), 'c');
+
+    registry.get<char>(e0) = '*';
+    prototype.assign(registry, e0);
+
+    ASSERT_EQ(registry.get<char>(e0), '*');
+
+    registry.get<char>(e1) = '*';
+    prototype.accommodate(registry, e1);
+
+    ASSERT_EQ(registry.get<char>(e1), 'c');
+}
+
+TEST(Prototype, RAII) {
+    entt::DefaultRegistry registry;
+
+    {
+        entt::DefaultPrototype prototype{registry};
+        prototype.set<int>(0);
+
+        ASSERT_FALSE(registry.empty());
+    }
+
+    ASSERT_TRUE(registry.empty());
+}
+
+TEST(Prototype, MoveConstructionAssignment) {
+    entt::DefaultRegistry registry;
+
+    entt::DefaultPrototype prototype{registry};
+    prototype.set<int>(0);
+    auto other{std::move(prototype)};
+    const auto e0 = other();
+
+    ASSERT_EQ(registry.size(), entt::DefaultRegistry::size_type{2});
+    ASSERT_TRUE(registry.has<int>(e0));
+
+    prototype = std::move(other);
+    const auto e1 = prototype();
+
+    ASSERT_EQ(registry.size(), entt::DefaultRegistry::size_type{3});
+    ASSERT_TRUE(registry.has<int>(e1));
+}

test/entt/entity/registry.cpp

@@ -0,0 +1,827 @@
+#include <unordered_map>
+#include <unordered_set>
+#include <functional>
+#include <type_traits>
+#include <gtest/gtest.h>
+#include <entt/entity/entt_traits.hpp>
+#include <entt/entity/registry.hpp>
+
+struct Listener {
+    template<typename Component>
+    void incrComponent(entt::DefaultRegistry &registry, entt::DefaultRegistry::entity_type entity) {
+        ASSERT_TRUE(registry.valid(entity));
+        ASSERT_TRUE(registry.has<Component>(entity));
+        last = entity;
+        ++counter;
+    }
+
+    template<typename Tag>
+    void incrTag(entt::DefaultRegistry &registry, entt::DefaultRegistry::entity_type entity) {
+        ASSERT_TRUE(registry.valid(entity));
+        ASSERT_TRUE(registry.has<Tag>());
+        ASSERT_EQ(registry.attachee<Tag>(), entity);
+        last = entity;
+        ++counter;
+    }
+
+    template<typename Component>
+    void decrComponent(entt::DefaultRegistry &registry, entt::DefaultRegistry::entity_type entity) {
+        ASSERT_TRUE(registry.valid(entity));
+        ASSERT_TRUE(registry.has<Component>(entity));
+        last = entity;
+        --counter;
+    }
+
+    template<typename Tag>
+    void decrTag(entt::DefaultRegistry &registry, entt::DefaultRegistry::entity_type entity) {
+        ASSERT_TRUE(registry.valid(entity));
+        ASSERT_TRUE(registry.has<Tag>());
+        ASSERT_EQ(registry.attachee<Tag>(), entity);
+        last = entity;
+        --counter;
+    }
+
+    entt::DefaultRegistry::entity_type last;
+    int counter{0};
+};
+
+TEST(DefaultRegistry, Types) {
+    entt::DefaultRegistry registry;
+
+    ASSERT_EQ(registry.type<int>(entt::tag_t{}), registry.type<int>(entt::tag_t{}));
+    ASSERT_EQ(registry.type<int>(), registry.type<int>());
+
+    ASSERT_NE(registry.type<int>(entt::tag_t{}), registry.type<double>(entt::tag_t{}));
+    ASSERT_NE(registry.type<int>(), registry.type<double>(entt::tag_t{}));
+}
+
+TEST(DefaultRegistry, Functionalities) {
+    entt::DefaultRegistry registry;
+
+    ASSERT_EQ(registry.size(), entt::DefaultRegistry::size_type{0});
+    ASSERT_EQ(registry.alive(), entt::DefaultRegistry::size_type{0});
+    ASSERT_NO_THROW(registry.reserve(42));
+    ASSERT_NO_THROW(registry.reserve<int>(8));
+    ASSERT_NO_THROW(registry.reserve<char>(8));
+    ASSERT_TRUE(registry.empty());
+
+    ASSERT_EQ(registry.capacity(), entt::DefaultRegistry::size_type{42});
+    ASSERT_EQ(registry.capacity<int>(), entt::DefaultRegistry::size_type{8});
+    ASSERT_EQ(registry.capacity<char>(), entt::DefaultRegistry::size_type{8});
+    ASSERT_EQ(registry.size<int>(), entt::DefaultRegistry::size_type{0});
+    ASSERT_EQ(registry.size<char>(), entt::DefaultRegistry::size_type{0});
+    ASSERT_TRUE(registry.empty<int>());
+    ASSERT_TRUE(registry.empty<char>());
+
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    ASSERT_TRUE(registry.has<>(e0));
+    ASSERT_TRUE(registry.has<>(e1));
+
+    ASSERT_EQ(registry.size<int>(), entt::DefaultRegistry::size_type{1});
+    ASSERT_EQ(registry.size<char>(), entt::DefaultRegistry::size_type{1});
+    ASSERT_FALSE(registry.empty<int>());
+    ASSERT_FALSE(registry.empty<char>());
+
+    ASSERT_NE(e0, e1);
+
+    ASSERT_FALSE(registry.has<int>(e0));
+    ASSERT_TRUE(registry.has<int>(e1));
+    ASSERT_FALSE(registry.has<char>(e0));
+    ASSERT_TRUE(registry.has<char>(e1));
+    ASSERT_FALSE((registry.has<int, char>(e0)));
+    ASSERT_TRUE((registry.has<int, char>(e1)));
+
+    ASSERT_EQ(registry.assign<int>(e0, 42), 42);
+    ASSERT_EQ(registry.assign<char>(e0, 'c'), 'c');
+    ASSERT_NO_THROW(registry.remove<int>(e1));
+    ASSERT_NO_THROW(registry.remove<char>(e1));
+
+    ASSERT_TRUE(registry.has<int>(e0));
+    ASSERT_FALSE(registry.has<int>(e1));
+    ASSERT_TRUE(registry.has<char>(e0));
+    ASSERT_FALSE(registry.has<char>(e1));
+    ASSERT_TRUE((registry.has<int, char>(e0)));
+    ASSERT_FALSE((registry.has<int, char>(e1)));
+
+    const auto e2 = registry.create();
+
+    registry.accommodate<int>(e2, registry.get<int>(e0));
+    registry.accommodate<char>(e2, registry.get<char>(e0));
+
+    ASSERT_TRUE(registry.has<int>(e2));
+    ASSERT_TRUE(registry.has<char>(e2));
+    ASSERT_EQ(registry.get<int>(e0), 42);
+    ASSERT_EQ(registry.get<char>(e0), 'c');
+
+    ASSERT_EQ(std::get<0>(registry.get<int, char>(e0)), 42);
+    ASSERT_EQ(std::get<1>(static_cast<const entt::DefaultRegistry &>(registry).get<int, char>(e0)), 'c');
+
+    ASSERT_EQ(registry.get<int>(e0), registry.get<int>(e2));
+    ASSERT_EQ(registry.get<char>(e0), registry.get<char>(e2));
+    ASSERT_NE(&registry.get<int>(e0), &registry.get<int>(e2));
+    ASSERT_NE(&registry.get<char>(e0), &registry.get<char>(e2));
+
+    ASSERT_NO_THROW(registry.replace<int>(e0, 0));
+    ASSERT_EQ(registry.get<int>(e0), 0);
+
+    ASSERT_NO_THROW(registry.accommodate<int>(e0, 1));
+    ASSERT_NO_THROW(registry.accommodate<int>(e1, 1));
+    ASSERT_EQ(static_cast<const entt::DefaultRegistry &>(registry).get<int>(e0), 1);
+    ASSERT_EQ(static_cast<const entt::DefaultRegistry &>(registry).get<int>(e1), 1);
+
+    ASSERT_EQ(registry.size(), entt::DefaultRegistry::size_type{3});
+    ASSERT_EQ(registry.alive(), entt::DefaultRegistry::size_type{3});
+    ASSERT_FALSE(registry.empty());
+
+    ASSERT_EQ(registry.version(e2), entt::DefaultRegistry::version_type{0});
+    ASSERT_EQ(registry.current(e2), entt::DefaultRegistry::version_type{0});
+    ASSERT_NO_THROW(registry.destroy(e2));
+    ASSERT_EQ(registry.version(e2), entt::DefaultRegistry::version_type{0});
+    ASSERT_EQ(registry.current(e2), entt::DefaultRegistry::version_type{1});
+
+    ASSERT_TRUE(registry.valid(e0));
+    ASSERT_TRUE(registry.fast(e0));
+    ASSERT_TRUE(registry.valid(e1));
+    ASSERT_TRUE(registry.fast(e1));
+    ASSERT_FALSE(registry.valid(e2));
+    ASSERT_FALSE(registry.fast(e2));
+
+    ASSERT_EQ(registry.size(), entt::DefaultRegistry::size_type{3});
+    ASSERT_EQ(registry.alive(), entt::DefaultRegistry::size_type{2});
+    ASSERT_FALSE(registry.empty());
+
+    ASSERT_NO_THROW(registry.reset());
+
+    ASSERT_EQ(registry.size(), entt::DefaultRegistry::size_type{3});
+    ASSERT_EQ(registry.alive(), entt::DefaultRegistry::size_type{0});
+    ASSERT_TRUE(registry.empty());
+
+    const auto e3 = registry.create();
+
+    registry.assign<int>(e3);
+    registry.assign<char>(e3);
+
+    ASSERT_EQ(registry.size<int>(), entt::DefaultRegistry::size_type{1});
+    ASSERT_EQ(registry.size<char>(), entt::DefaultRegistry::size_type{1});
+    ASSERT_FALSE(registry.empty<int>());
+    ASSERT_FALSE(registry.empty<char>());
+
+    ASSERT_NO_THROW(registry.reset<int>());
+
+    ASSERT_EQ(registry.size<int>(), entt::DefaultRegistry::size_type{0});
+    ASSERT_EQ(registry.size<char>(), entt::DefaultRegistry::size_type{1});
+    ASSERT_TRUE(registry.empty<int>());
+    ASSERT_FALSE(registry.empty<char>());
+
+    ASSERT_NO_THROW(registry.reset());
+
+    ASSERT_EQ(registry.size<int>(), entt::DefaultRegistry::size_type{0});
+    ASSERT_EQ(registry.size<char>(), entt::DefaultRegistry::size_type{0});
+    ASSERT_TRUE(registry.empty<int>());
+    ASSERT_TRUE(registry.empty<char>());
+
+    const auto e4 = registry.create();
+    const auto e5 = registry.create();
+
+    registry.assign<int>(e4);
+
+    ASSERT_NO_THROW(registry.reset<int>(e4));
+    ASSERT_NO_THROW(registry.reset<int>(e5));
+
+    ASSERT_EQ(registry.size<int>(), entt::DefaultRegistry::size_type{0});
+    ASSERT_EQ(registry.size<char>(), entt::DefaultRegistry::size_type{0});
+    ASSERT_TRUE(registry.empty<int>());
+}
+
+TEST(DefaultRegistry, Identifiers) {
+    entt::DefaultRegistry registry;
+    const auto pre = registry.create();
+
+    ASSERT_EQ(pre, registry.entity(pre));
+
+    registry.destroy(pre);
+    const auto post = registry.create();
+
+    ASSERT_NE(pre, post);
+    ASSERT_EQ(registry.entity(pre), registry.entity(post));
+    ASSERT_NE(registry.version(pre), registry.version(post));
+    ASSERT_NE(registry.version(pre), registry.current(pre));
+    ASSERT_EQ(registry.version(post), registry.current(post));
+}
+
+TEST(DefaultRegistry, RawData) {
+    entt::DefaultRegistry registry;
+    const entt::DefaultRegistry &cregistry = registry;
+    const auto entity = registry.create();
+
+    ASSERT_EQ(registry.raw<int>(), nullptr);
+    ASSERT_EQ(cregistry.raw<int>(), nullptr);
+    ASSERT_EQ(cregistry.data<int>(), nullptr);
+
+    registry.assign<int>(entity, 42);
+
+    ASSERT_NE(registry.raw<int>(), nullptr);
+    ASSERT_NE(cregistry.raw<int>(), nullptr);
+    ASSERT_NE(cregistry.data<int>(), nullptr);
+
+    ASSERT_EQ(*registry.raw<int>(), 42);
+    ASSERT_EQ(*cregistry.raw<int>(), 42);
+    ASSERT_EQ(*cregistry.data<int>(), entity);
+}
+
+TEST(DefaultRegistry, CreateDestroyCornerCase) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+
+    registry.destroy(e0);
+    registry.destroy(e1);
+
+    registry.each([](auto) { FAIL(); });
+
+    ASSERT_EQ(registry.current(e0), entt::DefaultRegistry::version_type{1});
+    ASSERT_EQ(registry.current(e1), entt::DefaultRegistry::version_type{1});
+}
+
+TEST(DefaultRegistry, VersionOverflow) {
+    entt::DefaultRegistry registry;
+
+    const auto entity = registry.create();
+    registry.destroy(entity);
+
+    ASSERT_EQ(registry.version(entity), entt::DefaultRegistry::version_type{});
+
+    for(auto i = entt::entt_traits<entt::DefaultRegistry::entity_type>::version_mask; i; --i) {
+        ASSERT_NE(registry.current(entity), registry.version(entity));
+        registry.destroy(registry.create());
+    }
+
+    ASSERT_EQ(registry.current(entity), registry.version(entity));
+}
+
+TEST(DefaultRegistry, Each) {
+    entt::DefaultRegistry registry;
+    entt::DefaultRegistry::size_type tot;
+    entt::DefaultRegistry::size_type match;
+
+    registry.create();
+    registry.assign<int>(registry.create());
+    registry.create();
+    registry.assign<int>(registry.create());
+    registry.create();
+
+    tot = 0u;
+    match = 0u;
+
+    registry.each([&](auto entity) {
+        if(registry.has<int>(entity)) { ++match; }
+        registry.create();
+        ++tot;
+    });
+
+    ASSERT_EQ(tot, 5u);
+    ASSERT_EQ(match, 2u);
+
+    tot = 0u;
+    match = 0u;
+
+    registry.each([&](auto entity) {
+        if(registry.has<int>(entity)) {
+            registry.destroy(entity);
+            ++match;
+        }
+
+        ++tot;
+    });
+
+    ASSERT_EQ(tot, 10u);
+    ASSERT_EQ(match, 2u);
+
+    tot = 0u;
+    match = 0u;
+
+    registry.each([&](auto entity) {
+        if(registry.has<int>(entity)) { ++match; }
+        registry.destroy(entity);
+        ++tot;
+    });
+
+    ASSERT_EQ(tot, 8u);
+    ASSERT_EQ(match, 0u);
+
+    registry.each([&](auto) { FAIL(); });
+}
+
+TEST(DefaultRegistry, Orphans) {
+    entt::DefaultRegistry registry;
+    entt::DefaultRegistry::size_type tot{};
+
+    registry.assign<int>(registry.create());
+    registry.create();
+    registry.assign<int>(registry.create());
+    registry.create();
+    registry.assign<double>(entt::tag_t{}, registry.create());
+
+    registry.orphans([&](auto) { ++tot; });
+    ASSERT_EQ(tot, 2u);
+    tot = 0u;
+
+    registry.each([&](auto entity) { registry.reset<int>(entity); });
+    registry.orphans([&](auto) { ++tot; });
+    ASSERT_EQ(tot, 4u);
+    registry.reset();
+    tot = 0u;
+
+    registry.orphans([&](auto) { ++tot; });
+    ASSERT_EQ(tot, 0u);
+}
+
+TEST(DefaultRegistry, CreateDestroyEntities) {
+    entt::DefaultRegistry registry;
+    entt::DefaultRegistry::entity_type pre{}, post{};
+
+    for(int i = 0; i < 10; ++i) {
+        const auto entity = registry.create();
+        registry.assign<double>(entity);
+    }
+
+    registry.reset();
+
+    for(int i = 0; i < 7; ++i) {
+        const auto entity = registry.create();
+        registry.assign<int>(entity);
+        if(i == 3) { pre = entity; }
+    }
+
+    registry.reset();
+
+    for(int i = 0; i < 5; ++i) {
+        const auto entity = registry.create();
+        if(i == 3) { post = entity; }
+    }
+
+    ASSERT_FALSE(registry.valid(pre));
+    ASSERT_TRUE(registry.valid(post));
+    ASSERT_NE(registry.version(pre), registry.version(post));
+    ASSERT_EQ(registry.version(pre) + 1, registry.version(post));
+    ASSERT_EQ(registry.current(pre), registry.current(post));
+}
+
+TEST(DefaultRegistry, AttachSetRemoveTags) {
+    entt::DefaultRegistry registry;
+    const auto &cregistry = registry;
+    const typename decltype(registry)::entity_type null = entt::null;
+
+    ASSERT_FALSE(registry.has<int>());
+    ASSERT_EQ(registry.attachee<int>(), null);
+
+    const auto entity = registry.create();
+    registry.assign<int>(entt::tag_t{}, entity, 42);
+
+    ASSERT_TRUE(registry.has<int>());
+    ASSERT_TRUE(registry.has<int>(entt::tag_t{}, entity));
+    ASSERT_EQ(registry.get<int>(), 42);
+    ASSERT_EQ(cregistry.get<int>(), 42);
+    ASSERT_EQ(registry.attachee<int>(), entity);
+
+    registry.replace<int>(entt::tag_t{}, 3);
+
+    ASSERT_TRUE(registry.has<int>());
+    ASSERT_TRUE(registry.has<int>(entt::tag_t{}, entity));
+    ASSERT_EQ(registry.get<int>(), 3);
+    ASSERT_EQ(cregistry.get<int>(), 3);
+    ASSERT_EQ(registry.attachee<int>(), entity);
+
+    const auto other = registry.create();
+    registry.move<int>(other);
+
+    ASSERT_TRUE(registry.has<int>());
+    ASSERT_FALSE(registry.has<int>(entt::tag_t{}, entity));
+    ASSERT_TRUE(registry.has<int>(entt::tag_t{}, other));
+    ASSERT_EQ(registry.get<int>(), 3);
+    ASSERT_EQ(cregistry.get<int>(), 3);
+    ASSERT_EQ(registry.attachee<int>(), other);
+
+    registry.remove<int>();
+
+    ASSERT_FALSE(registry.has<int>());
+    ASSERT_FALSE(registry.has<int>(entt::tag_t{}, entity));
+    ASSERT_FALSE(registry.has<int>(entt::tag_t{}, other));
+    ASSERT_EQ(registry.attachee<int>(), null);
+
+    registry.assign<int>(entt::tag_t{}, entity, 42);
+    registry.destroy(entity);
+
+    ASSERT_FALSE(registry.has<int>());
+    ASSERT_FALSE(registry.has<int>(entt::tag_t{}, entity));
+    ASSERT_FALSE(registry.has<int>(entt::tag_t{}, other));
+}
+
+TEST(DefaultRegistry, StandardView) {
+    entt::DefaultRegistry registry;
+    auto mview = registry.view<int, char>();
+    auto iview = registry.view<int>();
+    auto cview = registry.view<char>();
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0, 0);
+    registry.assign<char>(e0, 'c');
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1, 0);
+
+    const auto e2 = registry.create();
+    registry.assign<int>(e2, 0);
+    registry.assign<char>(e2, 'c');
+
+    ASSERT_EQ(iview.size(), decltype(iview)::size_type{3});
+    ASSERT_EQ(cview.size(), decltype(cview)::size_type{2});
+
+    decltype(mview)::size_type cnt{0};
+    mview.each([&cnt](auto...) { ++cnt; });
+
+    ASSERT_EQ(cnt, decltype(mview)::size_type{2});
+}
+
+TEST(DefaultRegistry, PersistentView) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int, char>(entt::persistent_t{});
+
+    ASSERT_TRUE((registry.contains<int, char>()));
+    ASSERT_FALSE((registry.contains<int, double>()));
+
+    registry.prepare<int, double>();
+
+    ASSERT_TRUE((registry.contains<int, double>()));
+
+    registry.discard<int, double>();
+
+    ASSERT_FALSE((registry.contains<int, double>()));
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0, 0);
+    registry.assign<char>(e0, 'c');
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1, 0);
+
+    const auto e2 = registry.create();
+    registry.assign<int>(e2, 0);
+    registry.assign<char>(e2, 'c');
+
+    decltype(view)::size_type cnt{0};
+    view.each([&cnt](auto...) { ++cnt; });
+
+    ASSERT_EQ(cnt, decltype(view)::size_type{2});
+}
+
+TEST(DefaultRegistry, RawView) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int>(entt::raw_t{});
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0, 0);
+    registry.assign<char>(e0, 'c');
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1, 0);
+    registry.assign<char>(e1, 'c');
+
+    decltype(view)::size_type cnt{0};
+    view.each([&cnt](auto &...) { ++cnt; });
+
+    ASSERT_EQ(cnt, decltype(view)::size_type{2});
+}
+
+TEST(DefaultRegistry, CleanStandardViewAfterReset) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int>();
+    registry.assign<int>(registry.create(), 0);
+
+    ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{1});
+
+    registry.reset();
+
+    ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{0});
+}
+
+TEST(DefaultRegistry, CleanPersistentViewAfterReset) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int, char>(entt::persistent_t{});
+
+    const auto entity = registry.create();
+    registry.assign<int>(entity, 0);
+    registry.assign<char>(entity, 'c');
+
+    ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{1});
+
+    registry.reset();
+
+    ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{0});
+}
+
+TEST(DefaultRegistry, CleanRawViewAfterReset) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int>(entt::raw_t{});
+    registry.assign<int>(registry.create(), 0);
+
+    ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{1});
+
+    registry.reset();
+
+    ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{0});
+}
+
+TEST(DefaultRegistry, CleanTagsAfterReset) {
+    entt::DefaultRegistry registry;
+    const auto entity = registry.create();
+    registry.assign<int>(entt::tag_t{}, entity);
+
+    ASSERT_TRUE(registry.has<int>());
+
+    registry.reset();
+
+    ASSERT_FALSE(registry.has<int>());
+}
+
+TEST(DefaultRegistry, SortSingle) {
+    entt::DefaultRegistry registry;
+
+    int val = 0;
+
+    registry.assign<int>(registry.create(), val++);
+    registry.assign<int>(registry.create(), val++);
+    registry.assign<int>(registry.create(), val++);
+
+    for(auto entity: registry.view<int>()) {
+        ASSERT_EQ(registry.get<int>(entity), --val);
+    }
+
+    registry.sort<int>(std::less<int>{});
+
+    for(auto entity: registry.view<int>()) {
+        ASSERT_EQ(registry.get<int>(entity), val++);
+    }
+}
+
+TEST(DefaultRegistry, SortMulti) {
+    entt::DefaultRegistry registry;
+
+    unsigned int uval = 0u;
+    int ival = 0;
+
+    for(auto i = 0; i < 3; ++i) {
+        const auto entity = registry.create();
+        registry.assign<unsigned int>(entity, uval++);
+        registry.assign<int>(entity, ival++);
+    }
+
+    for(auto entity: registry.view<unsigned int>()) {
+        ASSERT_EQ(registry.get<unsigned int>(entity), --uval);
+    }
+
+    for(auto entity: registry.view<int>()) {
+        ASSERT_EQ(registry.get<int>(entity), --ival);
+    }
+
+    registry.sort<unsigned int>(std::less<unsigned int>{});
+    registry.sort<int, unsigned int>();
+
+    for(auto entity: registry.view<unsigned int>()) {
+        ASSERT_EQ(registry.get<unsigned int>(entity), uval++);
+    }
+
+    for(auto entity: registry.view<int>()) {
+        ASSERT_EQ(registry.get<int>(entity), ival++);
+    }
+}
+
+TEST(DefaultRegistry, ComponentsWithTypesFromStandardTemplateLibrary) {
+    // see #37 - the test shouldn't crash, that's all
+    entt::DefaultRegistry registry;
+    const auto entity = registry.create();
+    registry.assign<std::unordered_set<int>>(entity).insert(42);
+    registry.destroy(entity);
+}
+
+TEST(DefaultRegistry, ConstructWithComponents) {
+    // it should compile, that's all
+    entt::DefaultRegistry registry;
+    const auto value = 0;
+    registry.assign<int>(registry.create(), value);
+}
+
+TEST(DefaultRegistry, MergeTwoRegistries) {
+    using entity_type = entt::DefaultRegistry::entity_type;
+
+    entt::DefaultRegistry src;
+    entt::DefaultRegistry dst;
+
+    std::unordered_map<entity_type, entity_type> ref;
+
+    auto merge = [&ref](const auto &view, auto &dst) {
+        view.each([&](auto entity, const auto &component) {
+            if(ref.find(entity) == ref.cend()) {
+                const auto other = dst.create();
+                dst.template assign<std::decay_t<decltype(component)>>(other, component);
+                ref.emplace(entity, other);
+            } else {
+                using component_type = std::decay_t<decltype(component)>;
+                dst.template assign<component_type>(ref[entity], component);
+            }
+        });
+    };
+
+    auto e0 = src.create();
+    src.assign<int>(e0);
+    src.assign<float>(e0);
+    src.assign<double>(e0);
+
+    auto e1 = src.create();
+    src.assign<char>(e1);
+    src.assign<float>(e1);
+    src.assign<int>(e1);
+
+    auto e2 = dst.create();
+    dst.assign<int>(e2);
+    dst.assign<char>(e2);
+    dst.assign<double>(e2);
+
+    auto e3 = dst.create();
+    dst.assign<float>(e3);
+    dst.assign<int>(e3);
+
+    auto eq = [](auto begin, auto end) { ASSERT_EQ(begin, end); };
+    auto ne = [](auto begin, auto end) { ASSERT_NE(begin, end); };
+
+    eq(dst.view<int, float, double>().begin(), dst.view<int, float, double>().end());
+    eq(dst.view<char, float, int>().begin(), dst.view<char, float, int>().end());
+
+    merge(src.view<int>(), dst);
+    merge(src.view<char>(), dst);
+    merge(src.view<double>(), dst);
+    merge(src.view<float>(), dst);
+
+    ne(dst.view<int, float, double>().begin(), dst.view<int, float, double>().end());
+    ne(dst.view<char, float, int>().begin(), dst.view<char, float, int>().end());
+}
+
+TEST(DefaultRegistry, ComponentSignals) {
+    entt::DefaultRegistry registry;
+    Listener listener;
+
+    registry.construction<int>().connect<Listener, &Listener::incrComponent<int>>(&listener);
+    registry.destruction<int>().connect<Listener, &Listener::decrComponent<int>>(&listener);
+
+    auto e0 = registry.create();
+    auto e1 = registry.create();
+
+    registry.assign<int>(e0);
+    registry.assign<int>(e1);
+
+    ASSERT_EQ(listener.counter, 2);
+    ASSERT_EQ(listener.last, e1);
+
+    registry.remove<int>(e0);
+
+    ASSERT_EQ(listener.counter, 1);
+    ASSERT_EQ(listener.last, e0);
+
+    registry.destruction<int>().disconnect<Listener, &Listener::decrComponent<int>>(&listener);
+    registry.remove<int>(e1);
+
+    ASSERT_EQ(listener.counter, 1);
+    ASSERT_EQ(listener.last, e0);
+
+    registry.construction<int>().disconnect<Listener, &Listener::incrComponent<int>>(&listener);
+    registry.assign<int>(e1);
+
+    ASSERT_EQ(listener.counter, 1);
+    ASSERT_EQ(listener.last, e0);
+
+    registry.construction<int>().connect<Listener, &Listener::incrComponent<int>>(&listener);
+    registry.destruction<int>().connect<Listener, &Listener::decrComponent<int>>(&listener);
+    registry.assign<int>(e0);
+    registry.reset<int>(e1);
+
+    ASSERT_EQ(listener.counter, 1);
+    ASSERT_EQ(listener.last, e1);
+
+    registry.reset<int>();
+
+    ASSERT_EQ(listener.counter, 0);
+    ASSERT_EQ(listener.last, e0);
+
+    registry.assign<int>(e0);
+    registry.assign<int>(e1);
+    registry.destroy(e1);
+
+    ASSERT_EQ(listener.counter, 1);
+    ASSERT_EQ(listener.last, e1);
+}
+
+TEST(DefaultRegistry, TagSignals) {
+    entt::DefaultRegistry registry;
+    Listener listener;
+
+    registry.construction<int>(entt::tag_t{}).connect<Listener, &Listener::incrTag<int>>(&listener);
+    registry.destruction<int>(entt::tag_t{}).connect<Listener, &Listener::decrTag<int>>(&listener);
+
+    auto e0 = registry.create();
+    registry.assign<int>(entt::tag_t{}, e0);
+
+    ASSERT_EQ(listener.counter, 1);
+    ASSERT_EQ(listener.last, e0);
+
+    auto e1 = registry.create();
+    registry.move<int>(e1);
+    registry.remove<int>();
+
+    ASSERT_EQ(listener.counter, 0);
+    ASSERT_EQ(listener.last, e1);
+
+    registry.construction<int>(entt::tag_t{}).disconnect<Listener, &Listener::incrTag<int>>(&listener);
+    registry.destruction<int>(entt::tag_t{}).disconnect<Listener, &Listener::decrTag<int>>(&listener);
+    registry.assign<int>(entt::tag_t{}, e0);
+    registry.remove<int>();
+
+    ASSERT_EQ(listener.counter, 0);
+    ASSERT_EQ(listener.last, e1);
+
+    registry.construction<int>(entt::tag_t{}).connect<Listener, &Listener::incrTag<int>>(&listener);
+    registry.destruction<int>(entt::tag_t{}).connect<Listener, &Listener::decrTag<int>>(&listener);
+
+    registry.assign<int>(entt::tag_t{}, e0);
+    registry.destroy(e0);
+
+    ASSERT_EQ(listener.counter, 0);
+    ASSERT_EQ(listener.last, e0);
+}
+
+TEST(DefaultRegistry, DestroyByTagAndComponents) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+    const auto e2 = registry.create();
+    const auto e3 = registry.create();
+
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+    registry.assign<double>(e0);
+
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    registry.assign<int>(e2);
+
+    registry.assign<float>(entt::tag_t{}, e3);
+
+    ASSERT_TRUE(registry.valid(e0));
+    ASSERT_TRUE(registry.valid(e1));
+    ASSERT_TRUE(registry.valid(e2));
+    ASSERT_TRUE(registry.valid(e3));
+
+    registry.destroy<int, char, double>(entt::persistent_t{});
+
+    ASSERT_FALSE(registry.valid(e0));
+    ASSERT_TRUE(registry.valid(e1));
+    ASSERT_TRUE(registry.valid(e2));
+    ASSERT_TRUE(registry.valid(e3));
+
+    registry.destroy<int, char>();
+
+    ASSERT_FALSE(registry.valid(e0));
+    ASSERT_FALSE(registry.valid(e1));
+    ASSERT_TRUE(registry.valid(e2));
+    ASSERT_TRUE(registry.valid(e3));
+
+    registry.destroy<int>();
+
+    ASSERT_FALSE(registry.valid(e0));
+    ASSERT_FALSE(registry.valid(e1));
+    ASSERT_FALSE(registry.valid(e2));
+    ASSERT_TRUE(registry.valid(e3));
+
+    registry.destroy<int>(entt::tag_t{});
+    registry.destroy<char>(entt::tag_t{});
+    registry.destroy<double>(entt::tag_t{});
+    registry.destroy<float>(entt::tag_t{});
+}
+
+TEST(DefaultRegistry, SignalsOnAccommodate) {
+    entt::DefaultRegistry registry;
+    const auto entity = registry.create();
+
+    registry.prepare<int, char>();
+    registry.assign<int>(entity);
+    registry.accommodate<char>(entity);
+
+    ASSERT_FALSE((registry.view<int, char>(entt::persistent_t{}).empty()));
+}

test/entt/entity/snapshot.cpp

@@ -0,0 +1,575 @@
+#include <tuple>
+#include <queue>
+#include <vector>
+#include <gtest/gtest.h>
+#include <entt/entity/registry.hpp>
+
+template<typename Storage>
+struct OutputArchive {
+    OutputArchive(Storage &storage)
+        : storage{storage}
+    {}
+
+    template<typename... Value>
+    void operator()(const Value &... value) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (std::get<std::queue<Value>>(storage).push(value), 0)... };
+        (void)accumulator;
+    }
+
+private:
+    Storage &storage;
+};
+
+template<typename Storage>
+struct InputArchive {
+    InputArchive(Storage &storage)
+        : storage{storage}
+    {}
+
+    template<typename... Value>
+    void operator()(Value &... value) {
+        auto assign = [this](auto &value) {
+            auto &queue = std::get<std::queue<std::decay_t<decltype(value)>>>(storage);
+            value = queue.front();
+            queue.pop();
+        };
+
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (assign(value), 0)... };
+        (void)accumulator;
+    }
+
+private:
+    Storage &storage;
+};
+
+struct AComponent {};
+
+struct AnotherComponent {
+    int key;
+    int value;
+};
+
+struct WhatAComponent {
+    entt::DefaultRegistry::entity_type bar;
+    std::vector<entt::DefaultRegistry::entity_type> quux;
+};
+
+TEST(Snapshot, Dump) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0, 42);
+    registry.assign<char>(e0, 'c');
+    registry.assign<double>(e0, .1);
+
+    const auto e1 = registry.create();
+
+    const auto e2 = registry.create();
+    registry.assign<int>(e2, 3);
+
+    const auto e3 = registry.create();
+    registry.assign<char>(e3, '0');
+    registry.assign<float>(entt::tag_t{}, e3, .3f);
+
+    const auto e4 = registry.create();
+    registry.assign<AComponent>(entt::tag_t{}, e4);
+
+    registry.destroy(e1);
+    auto v1 = registry.current(e1);
+
+    using storage_type = std::tuple<
+        std::queue<entt::DefaultRegistry::entity_type>,
+        std::queue<int>,
+        std::queue<char>,
+        std::queue<double>,
+        std::queue<float>,
+        std::queue<bool>,
+        std::queue<AComponent>,
+        std::queue<AnotherComponent>,
+        std::queue<WhatAComponent>
+    >;
+
+    storage_type storage;
+    OutputArchive<storage_type> output{storage};
+    InputArchive<storage_type> input{storage};
+
+    registry.snapshot()
+            .entities(output)
+            .destroyed(output)
+            .component<int, char, AnotherComponent, double>(output)
+            .tag<float, bool, AComponent>(output);
+
+    registry.reset();
+
+    ASSERT_FALSE(registry.valid(e0));
+    ASSERT_FALSE(registry.valid(e1));
+    ASSERT_FALSE(registry.valid(e2));
+    ASSERT_FALSE(registry.valid(e3));
+    ASSERT_FALSE(registry.valid(e4));
+
+    registry.restore()
+            .entities(input)
+            .destroyed(input)
+            .component<int, char, AnotherComponent, double>(input)
+            .tag<float, bool, AComponent>(input)
+            .orphans();
+
+    ASSERT_TRUE(registry.valid(e0));
+    ASSERT_FALSE(registry.valid(e1));
+    ASSERT_TRUE(registry.valid(e2));
+    ASSERT_TRUE(registry.valid(e3));
+    ASSERT_TRUE(registry.valid(e4));
+
+    ASSERT_FALSE(registry.orphan(e0));
+    ASSERT_FALSE(registry.orphan(e2));
+    ASSERT_FALSE(registry.orphan(e3));
+    ASSERT_FALSE(registry.orphan(e4));
+
+    ASSERT_EQ(registry.get<int>(e0), 42);
+    ASSERT_EQ(registry.get<char>(e0), 'c');
+    ASSERT_EQ(registry.get<double>(e0), .1);
+    ASSERT_EQ(registry.current(e1), v1);
+    ASSERT_EQ(registry.get<int>(e2), 3);
+    ASSERT_EQ(registry.get<char>(e3), '0');
+
+    ASSERT_TRUE(registry.has<float>());
+    ASSERT_EQ(registry.attachee<float>(), e3);
+    ASSERT_EQ(registry.get<float>(), .3f);
+
+    ASSERT_TRUE(registry.has<AComponent>());
+    ASSERT_EQ(registry.attachee<AComponent>(), e4);
+
+    ASSERT_TRUE(registry.empty<AnotherComponent>());
+    ASSERT_FALSE(registry.has<long int>());
+}
+
+TEST(Snapshot, Partial) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0, 42);
+    registry.assign<char>(e0, 'c');
+    registry.assign<double>(e0, .1);
+
+    const auto e1 = registry.create();
+
+    const auto e2 = registry.create();
+    registry.assign<int>(e2, 3);
+
+    const auto e3 = registry.create();
+    registry.assign<char>(e3, '0');
+    registry.assign<float>(entt::tag_t{}, e3, .3f);
+
+    const auto e4 = registry.create();
+    registry.assign<AComponent>(entt::tag_t{}, e4);
+
+    registry.destroy(e1);
+    auto v1 = registry.current(e1);
+
+    using storage_type = std::tuple<
+        std::queue<entt::DefaultRegistry::entity_type>,
+        std::queue<int>,
+        std::queue<char>,
+        std::queue<double>,
+        std::queue<float>,
+        std::queue<bool>,
+        std::queue<AComponent>,
+        std::queue<WhatAComponent>
+    >;
+
+    storage_type storage;
+    OutputArchive<storage_type> output{storage};
+    InputArchive<storage_type> input{storage};
+
+    registry.snapshot()
+            .entities(output)
+            .destroyed(output)
+            .component<char, int>(output)
+            .tag<bool, float>(output);
+
+    registry.reset();
+
+    ASSERT_FALSE(registry.valid(e0));
+    ASSERT_FALSE(registry.valid(e1));
+    ASSERT_FALSE(registry.valid(e2));
+    ASSERT_FALSE(registry.valid(e3));
+    ASSERT_FALSE(registry.valid(e4));
+
+    registry.restore()
+            .entities(input)
+            .destroyed(input)
+            .component<char, int>(input)
+            .tag<bool, float>(input);
+
+    ASSERT_TRUE(registry.valid(e0));
+    ASSERT_FALSE(registry.valid(e1));
+    ASSERT_TRUE(registry.valid(e2));
+    ASSERT_TRUE(registry.valid(e3));
+    ASSERT_TRUE(registry.valid(e4));
+
+    ASSERT_EQ(registry.get<int>(e0), 42);
+    ASSERT_EQ(registry.get<char>(e0), 'c');
+    ASSERT_FALSE(registry.has<double>(e0));
+    ASSERT_EQ(registry.current(e1), v1);
+    ASSERT_EQ(registry.get<int>(e2), 3);
+    ASSERT_EQ(registry.get<char>(e3), '0');
+    ASSERT_TRUE(registry.orphan(e4));
+
+    ASSERT_TRUE(registry.has<float>());
+    ASSERT_EQ(registry.attachee<float>(), e3);
+    ASSERT_EQ(registry.get<float>(), .3f);
+    ASSERT_FALSE(registry.has<long int>());
+
+    registry.snapshot()
+            .tag<float>(output)
+            .destroyed(output)
+            .entities(output);
+
+    registry.reset();
+
+    ASSERT_FALSE(registry.valid(e0));
+    ASSERT_FALSE(registry.valid(e1));
+    ASSERT_FALSE(registry.valid(e2));
+    ASSERT_FALSE(registry.valid(e3));
+    ASSERT_FALSE(registry.valid(e4));
+
+    registry.restore()
+            .tag<float>(input)
+            .destroyed(input)
+            .entities(input)
+            .orphans();
+
+    ASSERT_FALSE(registry.valid(e0));
+    ASSERT_FALSE(registry.valid(e1));
+    ASSERT_FALSE(registry.valid(e2));
+    ASSERT_TRUE(registry.valid(e3));
+    ASSERT_FALSE(registry.valid(e4));
+}
+
+TEST(Snapshot, Iterator) {
+    entt::DefaultRegistry registry;
+
+    for(auto i = 0; i < 50; ++i) {
+        const auto entity = registry.create();
+        registry.assign<AnotherComponent>(entity, i, i);
+
+        if(i % 2) {
+            registry.assign<AComponent>(entity);
+        }
+    }
+
+    using storage_type = std::tuple<
+        std::queue<entt::DefaultRegistry::entity_type>,
+        std::queue<AnotherComponent>
+    >;
+
+    storage_type storage;
+    OutputArchive<storage_type> output{storage};
+    InputArchive<storage_type> input{storage};
+
+    const auto view = registry.view<AComponent>();
+    const auto size = view.size();
+
+    registry.snapshot().component<AnotherComponent>(output, view.cbegin(), view.cend());
+    registry.reset();
+    registry.restore().component<AnotherComponent>(input);
+
+    ASSERT_EQ(registry.view<AnotherComponent>().size(), size);
+
+    registry.view<AnotherComponent>().each([](const auto entity, auto &&...) {
+        ASSERT_TRUE(entity % 2);
+    });
+}
+
+TEST(Snapshot, Continuous) {
+    using entity_type = entt::DefaultRegistry::entity_type;
+
+    entt::DefaultRegistry src;
+    entt::DefaultRegistry dst;
+
+    entt::ContinuousLoader<entity_type> loader{dst};
+
+    std::vector<entity_type> entities;
+    entity_type entity;
+
+    using storage_type = std::tuple<
+        std::queue<entity_type>,
+        std::queue<AComponent>,
+        std::queue<AnotherComponent>,
+        std::queue<WhatAComponent>,
+        std::queue<double>
+    >;
+
+    storage_type storage;
+    OutputArchive<storage_type> output{storage};
+    InputArchive<storage_type> input{storage};
+
+    for(int i = 0; i < 10; ++i) {
+        src.create();
+    }
+
+    src.reset();
+
+    for(int i = 0; i < 5; ++i) {
+        entity = src.create();
+        entities.push_back(entity);
+
+        src.assign<AComponent>(entity);
+        src.assign<AnotherComponent>(entity, i, i);
+
+        if(i % 2) {
+            src.assign<WhatAComponent>(entity, entity);
+        } else if(i == 2) {
+            src.assign<double>(entt::tag_t{}, entity, .3);
+        }
+    }
+
+    src.view<WhatAComponent>().each([&entities](auto, auto &whatAComponent) {
+        whatAComponent.quux.insert(whatAComponent.quux.begin(), entities.begin(), entities.end());
+    });
+
+    entity = dst.create();
+    dst.assign<AComponent>(entity);
+    dst.assign<AnotherComponent>(entity, -1, -1);
+
+    src.snapshot()
+            .entities(output)
+            .destroyed(output)
+            .component<AComponent, AnotherComponent, WhatAComponent>(output)
+            .tag<double>(output);
+
+    loader.entities(input)
+            .destroyed(input)
+            .component<AComponent, AnotherComponent, WhatAComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
+            .tag<double>(input)
+            .orphans();
+
+    decltype(dst.size()) aComponentCnt{};
+    decltype(dst.size()) anotherComponentCnt{};
+    decltype(dst.size()) whatAComponentCnt{};
+
+    dst.each([&dst, &aComponentCnt](auto entity) {
+        ASSERT_TRUE(dst.has<AComponent>(entity));
+        ++aComponentCnt;
+    });
+
+    dst.view<AnotherComponent>().each([&anotherComponentCnt](auto, const auto &component) {
+        ASSERT_EQ(component.value, component.key < 0 ? -1 : component.key);
+        ++anotherComponentCnt;
+    });
+
+    dst.view<WhatAComponent>().each([&dst, &whatAComponentCnt](auto entity, const auto &component) {
+        ASSERT_EQ(entity, component.bar);
+
+        for(auto entity: component.quux) {
+            ASSERT_TRUE(dst.valid(entity));
+        }
+
+        ++whatAComponentCnt;
+    });
+
+    ASSERT_TRUE(dst.has<double>());
+    ASSERT_EQ(dst.get<double>(), .3);
+
+    src.view<AnotherComponent>().each([](auto, auto &component) {
+        component.value = 2 * component.key;
+    });
+
+    auto size = dst.size();
+
+    src.snapshot()
+            .entities(output)
+            .destroyed(output)
+            .component<AComponent, WhatAComponent, AnotherComponent>(output)
+            .tag<double>(output);
+
+    loader.entities(input)
+            .destroyed(input)
+            .component<AComponent, WhatAComponent, AnotherComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
+            .tag<double>(input)
+            .orphans();
+
+    ASSERT_EQ(size, dst.size());
+
+    ASSERT_EQ(dst.size<AComponent>(), aComponentCnt);
+    ASSERT_EQ(dst.size<AnotherComponent>(), anotherComponentCnt);
+    ASSERT_EQ(dst.size<WhatAComponent>(), whatAComponentCnt);
+    ASSERT_TRUE(dst.has<double>());
+
+    dst.view<AnotherComponent>().each([](auto, auto &component) {
+        ASSERT_EQ(component.value, component.key < 0 ? -1 : (2 * component.key));
+    });
+
+    entity = src.create();
+
+    src.view<WhatAComponent>().each([entity](auto, auto &component) {
+        component.bar = entity;
+    });
+
+    src.snapshot()
+            .entities(output)
+            .destroyed(output)
+            .component<WhatAComponent, AComponent, AnotherComponent>(output)
+            .tag<double>(output);
+
+    loader.entities(input)
+            .destroyed(input)
+            .component<WhatAComponent, AComponent, AnotherComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
+            .tag<double>(input)
+            .orphans();
+
+    dst.view<WhatAComponent>().each([&loader, entity](auto, auto &component) {
+        ASSERT_EQ(component.bar, loader.map(entity));
+    });
+
+    entities.clear();
+    for(auto entity: src.view<AComponent>()) {
+        entities.push_back(entity);
+    }
+
+    src.destroy(entity);
+    loader.shrink();
+
+    src.snapshot()
+            .entities(output)
+            .destroyed(output)
+            .component<AComponent, AnotherComponent, WhatAComponent>(output)
+            .tag<double>(output);
+
+    loader.entities(input)
+            .destroyed(input)
+            .component<AComponent, AnotherComponent, WhatAComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
+            .tag<double>(input)
+            .orphans()
+            .shrink();
+
+    dst.view<WhatAComponent>().each([&dst](auto, auto &component) {
+        ASSERT_FALSE(dst.valid(component.bar));
+    });
+
+    ASSERT_FALSE(loader.has(entity));
+
+    entity = src.create();
+
+    src.view<WhatAComponent>().each([entity](auto, auto &component) {
+        component.bar = entity;
+    });
+
+    dst.reset<AComponent>();
+    aComponentCnt = src.size<AComponent>();
+
+    src.snapshot()
+            .entities(output)
+            .destroyed(output)
+            .component<AComponent, WhatAComponent, AnotherComponent>(output)
+            .tag<double>(output);
+
+    loader.entities(input)
+            .destroyed(input)
+            .component<AComponent, WhatAComponent, AnotherComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
+            .tag<double>(input)
+            .orphans();
+
+    ASSERT_EQ(dst.size<AComponent>(), aComponentCnt);
+    ASSERT_TRUE(dst.has<double>());
+
+    src.reset<AComponent>();
+    src.remove<double>();
+    aComponentCnt = {};
+
+    src.snapshot()
+            .entities(output)
+            .destroyed(output)
+            .component<WhatAComponent, AComponent, AnotherComponent>(output)
+            .tag<double>(output);
+
+    loader.entities(input)
+            .destroyed(input)
+            .component<WhatAComponent, AComponent, AnotherComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
+            .tag<double>(input)
+            .orphans();
+
+    ASSERT_EQ(dst.size<AComponent>(), aComponentCnt);
+    ASSERT_FALSE(dst.has<double>());
+}
+
+TEST(Snapshot, ContinuousMoreOnShrink) {
+    using entity_type = entt::DefaultRegistry::entity_type;
+
+    entt::DefaultRegistry src;
+    entt::DefaultRegistry dst;
+
+    entt::ContinuousLoader<entity_type> loader{dst};
+
+    using storage_type = std::tuple<
+        std::queue<entity_type>,
+        std::queue<AComponent>
+    >;
+
+    storage_type storage;
+    OutputArchive<storage_type> output{storage};
+    InputArchive<storage_type> input{storage};
+
+    auto entity = src.create();
+    src.snapshot().entities(output);
+    loader.entities(input).shrink();
+
+    ASSERT_TRUE(dst.valid(entity));
+
+    loader.shrink();
+
+    ASSERT_FALSE(dst.valid(entity));
+}
+
+TEST(Snapshot, SyncDataMembers) {
+    using entity_type = entt::DefaultRegistry::entity_type;
+
+    entt::DefaultRegistry src;
+    entt::DefaultRegistry dst;
+
+    entt::ContinuousLoader<entity_type> loader{dst};
+
+    using storage_type = std::tuple<
+        std::queue<entity_type>,
+        std::queue<WhatAComponent>
+    >;
+
+    storage_type storage;
+    OutputArchive<storage_type> output{storage};
+    InputArchive<storage_type> input{storage};
+
+    src.create();
+    src.create();
+
+    src.reset();
+
+    auto parent = src.create();
+    auto child = src.create();
+
+    src.assign<WhatAComponent>(entt::tag_t{}, child, parent).quux.push_back(parent);
+    src.assign<WhatAComponent>(child, child).quux.push_back(child);
+
+    src.snapshot().entities(output)
+            .component<WhatAComponent>(output)
+            .tag<WhatAComponent>(output);
+
+    loader.entities(input)
+            .component<WhatAComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
+            .tag<WhatAComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux);
+
+    ASSERT_FALSE(dst.valid(parent));
+    ASSERT_FALSE(dst.valid(child));
+
+    ASSERT_TRUE(dst.has<WhatAComponent>());
+    ASSERT_EQ(dst.attachee<WhatAComponent>(), loader.map(child));
+    ASSERT_EQ(dst.get<WhatAComponent>().bar, loader.map(parent));
+    ASSERT_EQ(dst.get<WhatAComponent>().quux[0], loader.map(parent));
+    ASSERT_TRUE(dst.has<WhatAComponent>(loader.map(child)));
+
+    const auto &component = dst.get<WhatAComponent>(loader.map(child));
+
+    ASSERT_EQ(component.bar, loader.map(child));
+    ASSERT_EQ(component.quux[0], loader.map(child));
+}

test/entt/entity/sparse_set.cpp

@@ -0,0 +1,901 @@
+#include <unordered_set>
+#include <gtest/gtest.h>
+#include <entt/entity/sparse_set.hpp>
+
+TEST(SparseSetNoType, Functionalities) {
+    entt::SparseSet<std::uint64_t> set;
+    const auto &cset = set;
+
+    set.reserve(42);
+
+    ASSERT_EQ(set.capacity(), 42);
+    ASSERT_TRUE(set.empty());
+    ASSERT_EQ(set.size(), 0u);
+    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(set.begin(), set.end());
+    ASSERT_FALSE(set.has(0));
+    ASSERT_FALSE(set.has(42));
+
+    set.construct(42);
+
+    ASSERT_EQ(set.get(42), 0u);
+
+    ASSERT_FALSE(set.empty());
+    ASSERT_EQ(set.size(), 1u);
+    ASSERT_NE(cset.begin(), cset.end());
+    ASSERT_NE(set.begin(), set.end());
+    ASSERT_FALSE(set.has(0));
+    ASSERT_TRUE(set.has(42));
+    ASSERT_TRUE(set.fast(42));
+    ASSERT_EQ(set.get(42), 0u);
+
+    set.destroy(42);
+
+    ASSERT_TRUE(set.empty());
+    ASSERT_EQ(set.size(), 0u);
+    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(set.begin(), set.end());
+    ASSERT_FALSE(set.has(0));
+    ASSERT_FALSE(set.has(42));
+
+    set.construct(42);
+
+    ASSERT_EQ(set.get(42), 0u);
+
+    set.reset();
+
+    ASSERT_TRUE(set.empty());
+    ASSERT_EQ(set.size(), 0u);
+    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(set.begin(), set.end());
+    ASSERT_FALSE(set.has(0));
+    ASSERT_FALSE(set.has(42));
+
+    (void)entt::SparseSet<std::uint64_t>{std::move(set)};
+    entt::SparseSet<std::uint64_t> other;
+    other = std::move(set);
+}
+
+TEST(SparseSetNoType, ElementAccess) {
+    entt::SparseSet<std::uint64_t> set;
+    const auto &cset = set;
+
+    set.construct(42);
+    set.construct(3);
+
+    for(typename entt::SparseSet<std::uint64_t>::size_type i{}; i < set.size(); ++i) {
+        ASSERT_EQ(set[i], i ? 42 : 3);
+        ASSERT_EQ(cset[i], i ? 42 : 3);
+    }
+}
+
+TEST(SparseSetNoType, Iterator) {
+    using iterator_type = typename entt::SparseSet<std::uint64_t>::iterator_type;
+
+    entt::SparseSet<std::uint64_t> set;
+    set.construct(3);
+
+    iterator_type end{set.begin()};
+    iterator_type begin{};
+    begin = set.end();
+    std::swap(begin, end);
+
+    ASSERT_EQ(begin, set.begin());
+    ASSERT_EQ(end, set.end());
+    ASSERT_NE(begin, end);
+
+    ASSERT_EQ(begin++, set.begin());
+    ASSERT_EQ(begin--, set.end());
+
+    ASSERT_EQ(begin+1, set.end());
+    ASSERT_EQ(end-1, set.begin());
+
+    ASSERT_EQ(++begin, set.end());
+    ASSERT_EQ(--begin, set.begin());
+
+    ASSERT_EQ(begin += 1, set.end());
+    ASSERT_EQ(begin -= 1, set.begin());
+
+    ASSERT_EQ(begin + (end - begin), set.end());
+    ASSERT_EQ(begin - (begin - end), set.end());
+
+    ASSERT_EQ(end - (end - begin), set.begin());
+    ASSERT_EQ(end + (begin - end), set.begin());
+
+    ASSERT_EQ(begin[0], *set.begin());
+
+    ASSERT_LT(begin, end);
+    ASSERT_LE(begin, set.begin());
+
+    ASSERT_GT(end, begin);
+    ASSERT_GE(end, set.end());
+
+    ASSERT_EQ(*begin, 3);
+    ASSERT_EQ(*begin.operator->(), 3);
+}
+
+TEST(SparseSetNoType, ConstIterator) {
+    using iterator_type = typename entt::SparseSet<std::uint64_t>::const_iterator_type;
+
+    entt::SparseSet<std::uint64_t> set;
+    set.construct(3);
+
+    iterator_type cend{set.cbegin()};
+    iterator_type cbegin{};
+    cbegin = set.cend();
+    std::swap(cbegin, cend);
+
+    ASSERT_EQ(cbegin, set.cbegin());
+    ASSERT_EQ(cend, set.cend());
+    ASSERT_NE(cbegin, cend);
+
+    ASSERT_EQ(cbegin++, set.cbegin());
+    ASSERT_EQ(cbegin--, set.cend());
+
+    ASSERT_EQ(cbegin+1, set.cend());
+    ASSERT_EQ(cend-1, set.cbegin());
+
+    ASSERT_EQ(++cbegin, set.cend());
+    ASSERT_EQ(--cbegin, set.cbegin());
+
+    ASSERT_EQ(cbegin += 1, set.cend());
+    ASSERT_EQ(cbegin -= 1, set.cbegin());
+
+    ASSERT_EQ(cbegin + (cend - cbegin), set.cend());
+    ASSERT_EQ(cbegin - (cbegin - cend), set.cend());
+
+    ASSERT_EQ(cend - (cend - cbegin), set.cbegin());
+    ASSERT_EQ(cend + (cbegin - cend), set.cbegin());
+
+    ASSERT_EQ(cbegin[0], *set.cbegin());
+
+    ASSERT_LT(cbegin, cend);
+    ASSERT_LE(cbegin, set.cbegin());
+
+    ASSERT_GT(cend, cbegin);
+    ASSERT_GE(cend, set.cend());
+
+    ASSERT_EQ(*cbegin, 3);
+    ASSERT_EQ(*cbegin.operator->(), 3);
+}
+
+TEST(SparseSetNoType, Data) {
+    entt::SparseSet<std::uint64_t> set;
+
+    set.construct(3);
+    set.construct(12);
+    set.construct(42);
+
+    ASSERT_EQ(set.get(3), 0u);
+    ASSERT_EQ(set.get(12), 1u);
+    ASSERT_EQ(set.get(42), 2u);
+
+    ASSERT_EQ(*(set.data() + 0u), 3u);
+    ASSERT_EQ(*(set.data() + 1u), 12u);
+    ASSERT_EQ(*(set.data() + 2u), 42u);
+}
+
+TEST(SparseSetNoType, RespectDisjoint) {
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
+    const auto &clhs = lhs;
+
+    lhs.construct(3);
+    lhs.construct(12);
+    lhs.construct(42);
+
+    ASSERT_EQ(lhs.get(3), 0u);
+    ASSERT_EQ(lhs.get(12), 1u);
+    ASSERT_EQ(lhs.get(42), 2u);
+
+    lhs.respect(rhs);
+
+    ASSERT_EQ(clhs.get(3), 0u);
+    ASSERT_EQ(clhs.get(12), 1u);
+    ASSERT_EQ(clhs.get(42), 2u);
+}
+
+TEST(SparseSetNoType, RespectOverlap) {
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
+    const auto &clhs = lhs;
+
+    lhs.construct(3);
+    lhs.construct(12);
+    lhs.construct(42);
+
+    rhs.construct(12);
+
+    ASSERT_EQ(lhs.get(3), 0u);
+    ASSERT_EQ(lhs.get(12), 1u);
+    ASSERT_EQ(lhs.get(42), 2u);
+
+    lhs.respect(rhs);
+
+    ASSERT_EQ(clhs.get(3), 0u);
+    ASSERT_EQ(clhs.get(12), 2u);
+    ASSERT_EQ(clhs.get(42), 1u);
+}
+
+TEST(SparseSetNoType, RespectOrdered) {
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
+
+    lhs.construct(1);
+    lhs.construct(2);
+    lhs.construct(3);
+    lhs.construct(4);
+    lhs.construct(5);
+
+    ASSERT_EQ(lhs.get(1), 0u);
+    ASSERT_EQ(lhs.get(2), 1u);
+    ASSERT_EQ(lhs.get(3), 2u);
+    ASSERT_EQ(lhs.get(4), 3u);
+    ASSERT_EQ(lhs.get(5), 4u);
+
+    rhs.construct(6);
+    rhs.construct(1);
+    rhs.construct(2);
+    rhs.construct(3);
+    rhs.construct(4);
+    rhs.construct(5);
+
+    ASSERT_EQ(rhs.get(6), 0u);
+    ASSERT_EQ(rhs.get(1), 1u);
+    ASSERT_EQ(rhs.get(2), 2u);
+    ASSERT_EQ(rhs.get(3), 3u);
+    ASSERT_EQ(rhs.get(4), 4u);
+    ASSERT_EQ(rhs.get(5), 5u);
+
+    rhs.respect(lhs);
+
+    ASSERT_EQ(rhs.get(6), 0u);
+    ASSERT_EQ(rhs.get(1), 1u);
+    ASSERT_EQ(rhs.get(2), 2u);
+    ASSERT_EQ(rhs.get(3), 3u);
+    ASSERT_EQ(rhs.get(4), 4u);
+    ASSERT_EQ(rhs.get(5), 5u);
+}
+
+TEST(SparseSetNoType, RespectReverse) {
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
+
+    lhs.construct(1);
+    lhs.construct(2);
+    lhs.construct(3);
+    lhs.construct(4);
+    lhs.construct(5);
+
+    ASSERT_EQ(lhs.get(1), 0u);
+    ASSERT_EQ(lhs.get(2), 1u);
+    ASSERT_EQ(lhs.get(3), 2u);
+    ASSERT_EQ(lhs.get(4), 3u);
+    ASSERT_EQ(lhs.get(5), 4u);
+
+    rhs.construct(5);
+    rhs.construct(4);
+    rhs.construct(3);
+    rhs.construct(2);
+    rhs.construct(1);
+    rhs.construct(6);
+
+    ASSERT_EQ(rhs.get(5), 0u);
+    ASSERT_EQ(rhs.get(4), 1u);
+    ASSERT_EQ(rhs.get(3), 2u);
+    ASSERT_EQ(rhs.get(2), 3u);
+    ASSERT_EQ(rhs.get(1), 4u);
+    ASSERT_EQ(rhs.get(6), 5u);
+
+    rhs.respect(lhs);
+
+    ASSERT_EQ(rhs.get(6), 0u);
+    ASSERT_EQ(rhs.get(1), 1u);
+    ASSERT_EQ(rhs.get(2), 2u);
+    ASSERT_EQ(rhs.get(3), 3u);
+    ASSERT_EQ(rhs.get(4), 4u);
+    ASSERT_EQ(rhs.get(5), 5u);
+}
+
+TEST(SparseSetNoType, RespectUnordered) {
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
+
+    lhs.construct(1);
+    lhs.construct(2);
+    lhs.construct(3);
+    lhs.construct(4);
+    lhs.construct(5);
+
+    ASSERT_EQ(lhs.get(1), 0u);
+    ASSERT_EQ(lhs.get(2), 1u);
+    ASSERT_EQ(lhs.get(3), 2u);
+    ASSERT_EQ(lhs.get(4), 3u);
+    ASSERT_EQ(lhs.get(5), 4u);
+
+    rhs.construct(3);
+    rhs.construct(2);
+    rhs.construct(6);
+    rhs.construct(1);
+    rhs.construct(4);
+    rhs.construct(5);
+
+    ASSERT_EQ(rhs.get(3), 0u);
+    ASSERT_EQ(rhs.get(2), 1u);
+    ASSERT_EQ(rhs.get(6), 2u);
+    ASSERT_EQ(rhs.get(1), 3u);
+    ASSERT_EQ(rhs.get(4), 4u);
+    ASSERT_EQ(rhs.get(5), 5u);
+
+    rhs.respect(lhs);
+
+    ASSERT_EQ(rhs.get(6), 0u);
+    ASSERT_EQ(rhs.get(1), 1u);
+    ASSERT_EQ(rhs.get(2), 2u);
+    ASSERT_EQ(rhs.get(3), 3u);
+    ASSERT_EQ(rhs.get(4), 4u);
+    ASSERT_EQ(rhs.get(5), 5u);
+}
+
+TEST(SparseSetNoType, CanModifyDuringIteration) {
+    entt::SparseSet<std::uint64_t> set;
+    set.construct(0);
+
+    ASSERT_EQ(set.capacity(), entt::SparseSet<std::uint64_t>::size_type{1});
+
+    const auto it = set.cbegin();
+    set.reserve(entt::SparseSet<std::uint64_t>::size_type{2});
+
+    ASSERT_EQ(set.capacity(), entt::SparseSet<std::uint64_t>::size_type{2});
+
+    // this should crash with asan enabled if we break the constraint
+    const auto entity = *it;
+    (void)entity;
+}
+
+TEST(SparseSetWithType, Functionalities) {
+    entt::SparseSet<std::uint64_t, int> set;
+    const auto &cset = set;
+
+    set.reserve(42);
+
+    ASSERT_EQ(set.capacity(), 42);
+    ASSERT_TRUE(set.empty());
+    ASSERT_EQ(set.size(), 0u);
+    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(set.begin(), set.end());
+    ASSERT_FALSE(set.has(0));
+    ASSERT_FALSE(set.has(42));
+
+    set.construct(42, 3);
+
+    ASSERT_FALSE(set.empty());
+    ASSERT_EQ(set.size(), 1u);
+    ASSERT_NE(cset.begin(), cset.end());
+    ASSERT_NE(set.begin(), set.end());
+    ASSERT_FALSE(set.has(0));
+    ASSERT_TRUE(set.has(42));
+    ASSERT_TRUE(set.fast(42));
+    ASSERT_EQ(set.get(42), 3);
+
+    set.destroy(42);
+
+    ASSERT_TRUE(set.empty());
+    ASSERT_EQ(set.size(), 0u);
+    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(set.begin(), set.end());
+    ASSERT_FALSE(set.has(0));
+    ASSERT_FALSE(set.has(42));
+
+    set.construct(42, 12);
+
+    ASSERT_EQ(set.get(42), 12);
+
+    set.reset();
+
+    ASSERT_TRUE(set.empty());
+    ASSERT_EQ(set.size(), 0u);
+    ASSERT_EQ(cset.begin(), cset.end());
+    ASSERT_EQ(set.begin(), set.end());
+    ASSERT_FALSE(set.has(0));
+    ASSERT_FALSE(set.has(42));
+
+    (void)entt::SparseSet<std::uint64_t, int>{std::move(set)};
+    entt::SparseSet<std::uint64_t, int> other;
+    other = std::move(set);
+}
+
+TEST(SparseSetWithType, ElementAccess) {
+    entt::SparseSet<std::uint64_t, int> set;
+    const auto &cset = set;
+
+    set.construct(42, 1);
+    set.construct(3, 0);
+
+    for(typename entt::SparseSet<std::uint64_t, int>::size_type i{}; i < set.size(); ++i) {
+        ASSERT_EQ(set[i], i);
+        ASSERT_EQ(cset[i], i);
+    }
+}
+
+TEST(SparseSetWithType, AggregatesMustWork) {
+    struct AggregateType { int value; };
+    // the goal of this test is to enforce the requirements for aggregate types
+    entt::SparseSet<std::uint64_t, AggregateType>{}.construct(0, 42);
+}
+
+TEST(SparseSetWithType, TypesFromStandardTemplateLibraryMustWork) {
+    // see #37 - this test shouldn't crash, that's all
+    entt::SparseSet<std::uint64_t, std::unordered_set<int>> set;
+    set.construct(0).insert(42);
+    set.destroy(0);
+}
+
+TEST(SparseSetWithType, Iterator) {
+    struct InternalType { int value; };
+
+    using iterator_type = typename entt::SparseSet<std::uint64_t, InternalType>::iterator_type;
+
+    entt::SparseSet<std::uint64_t, InternalType> set;
+    set.construct(3, 42);
+
+    iterator_type end{set.begin()};
+    iterator_type begin{};
+    begin = set.end();
+    std::swap(begin, end);
+
+    ASSERT_EQ(begin, set.begin());
+    ASSERT_EQ(end, set.end());
+    ASSERT_NE(begin, end);
+
+    ASSERT_EQ(begin++, set.begin());
+    ASSERT_EQ(begin--, set.end());
+
+    ASSERT_EQ(begin+1, set.end());
+    ASSERT_EQ(end-1, set.begin());
+
+    ASSERT_EQ(++begin, set.end());
+    ASSERT_EQ(--begin, set.begin());
+
+    ASSERT_EQ(begin += 1, set.end());
+    ASSERT_EQ(begin -= 1, set.begin());
+
+    ASSERT_EQ(begin + (end - begin), set.end());
+    ASSERT_EQ(begin - (begin - end), set.end());
+
+    ASSERT_EQ(end - (end - begin), set.begin());
+    ASSERT_EQ(end + (begin - end), set.begin());
+
+    ASSERT_EQ(begin[0].value, set.begin()->value);
+
+    ASSERT_LT(begin, end);
+    ASSERT_LE(begin, set.begin());
+
+    ASSERT_GT(end, begin);
+    ASSERT_GE(end, set.end());
+}
+
+TEST(SparseSetWithType, ConstIterator) {
+    struct InternalType { int value; };
+
+    using iterator_type = typename entt::SparseSet<std::uint64_t, InternalType>::const_iterator_type;
+
+    entt::SparseSet<std::uint64_t, InternalType> set;
+    set.construct(3, 42);
+
+    iterator_type cend{set.cbegin()};
+    iterator_type cbegin{};
+    cbegin = set.cend();
+    std::swap(cbegin, cend);
+
+    ASSERT_EQ(cbegin, set.cbegin());
+    ASSERT_EQ(cend, set.cend());
+    ASSERT_NE(cbegin, cend);
+
+    ASSERT_EQ(cbegin++, set.cbegin());
+    ASSERT_EQ(cbegin--, set.cend());
+
+    ASSERT_EQ(cbegin+1, set.cend());
+    ASSERT_EQ(cend-1, set.cbegin());
+
+    ASSERT_EQ(++cbegin, set.cend());
+    ASSERT_EQ(--cbegin, set.cbegin());
+
+    ASSERT_EQ(cbegin += 1, set.cend());
+    ASSERT_EQ(cbegin -= 1, set.cbegin());
+
+    ASSERT_EQ(cbegin + (cend - cbegin), set.cend());
+    ASSERT_EQ(cbegin - (cbegin - cend), set.cend());
+
+    ASSERT_EQ(cend - (cend - cbegin), set.cbegin());
+    ASSERT_EQ(cend + (cbegin - cend), set.cbegin());
+
+    ASSERT_EQ(cbegin[0].value, set.cbegin()->value);
+
+    ASSERT_LT(cbegin, cend);
+    ASSERT_LE(cbegin, set.cbegin());
+
+    ASSERT_GT(cend, cbegin);
+    ASSERT_GE(cend, set.cend());
+}
+
+TEST(SparseSetWithType, Raw) {
+    entt::SparseSet<std::uint64_t, int> set;
+
+    set.construct(3, 3);
+    set.construct(12, 6);
+    set.construct(42, 9);
+
+    ASSERT_EQ(set.get(3), 3);
+    ASSERT_EQ(set.get(12), 6);
+    ASSERT_EQ(set.get(42), 9);
+
+    ASSERT_EQ(*(set.raw() + 0u), 3);
+    ASSERT_EQ(*(set.raw() + 1u), 6);
+    ASSERT_EQ(*(set.raw() + 2u), 9);
+}
+
+TEST(SparseSetWithType, SortOrdered) {
+    entt::SparseSet<std::uint64_t, int> set;
+
+    set.construct(12, 12);
+    set.construct(42, 9);
+    set.construct(7, 6);
+    set.construct(3, 3);
+    set.construct(9, 1);
+
+    ASSERT_EQ(set.get(12), 12);
+    ASSERT_EQ(set.get(42), 9);
+    ASSERT_EQ(set.get(7), 6);
+    ASSERT_EQ(set.get(3), 3);
+    ASSERT_EQ(set.get(9), 1);
+
+    set.sort([](auto lhs, auto rhs) {
+        return lhs < rhs;
+    });
+
+    ASSERT_EQ(*(set.raw() + 0u), 12);
+    ASSERT_EQ(*(set.raw() + 1u), 9);
+    ASSERT_EQ(*(set.raw() + 2u), 6);
+    ASSERT_EQ(*(set.raw() + 3u), 3);
+    ASSERT_EQ(*(set.raw() + 4u), 1);
+
+    auto begin = set.begin();
+    auto end = set.end();
+
+    ASSERT_EQ(*(begin++), 1);
+    ASSERT_EQ(*(begin++), 3);
+    ASSERT_EQ(*(begin++), 6);
+    ASSERT_EQ(*(begin++), 9);
+    ASSERT_EQ(*(begin++), 12);
+    ASSERT_EQ(begin, end);
+}
+
+TEST(SparseSetWithType, SortReverse) {
+    entt::SparseSet<std::uint64_t, int> set;
+
+    set.construct(12, 1);
+    set.construct(42, 3);
+    set.construct(7, 6);
+    set.construct(3, 9);
+    set.construct(9, 12);
+
+    ASSERT_EQ(set.get(12), 1);
+    ASSERT_EQ(set.get(42), 3);
+    ASSERT_EQ(set.get(7), 6);
+    ASSERT_EQ(set.get(3), 9);
+    ASSERT_EQ(set.get(9), 12);
+
+    set.sort([](auto lhs, auto rhs) {
+        return lhs < rhs;
+    });
+
+    ASSERT_EQ(*(set.raw() + 0u), 12);
+    ASSERT_EQ(*(set.raw() + 1u), 9);
+    ASSERT_EQ(*(set.raw() + 2u), 6);
+    ASSERT_EQ(*(set.raw() + 3u), 3);
+    ASSERT_EQ(*(set.raw() + 4u), 1);
+
+    auto begin = set.begin();
+    auto end = set.end();
+
+    ASSERT_EQ(*(begin++), 1);
+    ASSERT_EQ(*(begin++), 3);
+    ASSERT_EQ(*(begin++), 6);
+    ASSERT_EQ(*(begin++), 9);
+    ASSERT_EQ(*(begin++), 12);
+    ASSERT_EQ(begin, end);
+}
+
+TEST(SparseSetWithType, SortUnordered) {
+    entt::SparseSet<std::uint64_t, int> set;
+
+    set.construct(12, 6);
+    set.construct(42, 3);
+    set.construct(7, 1);
+    set.construct(3, 9);
+    set.construct(9, 12);
+
+    ASSERT_EQ(set.get(12), 6);
+    ASSERT_EQ(set.get(42), 3);
+    ASSERT_EQ(set.get(7), 1);
+    ASSERT_EQ(set.get(3), 9);
+    ASSERT_EQ(set.get(9), 12);
+
+    set.sort([](auto lhs, auto rhs) {
+        return lhs < rhs;
+    });
+
+    ASSERT_EQ(*(set.raw() + 0u), 12);
+    ASSERT_EQ(*(set.raw() + 1u), 9);
+    ASSERT_EQ(*(set.raw() + 2u), 6);
+    ASSERT_EQ(*(set.raw() + 3u), 3);
+    ASSERT_EQ(*(set.raw() + 4u), 1);
+
+    auto begin = set.begin();
+    auto end = set.end();
+
+    ASSERT_EQ(*(begin++), 1);
+    ASSERT_EQ(*(begin++), 3);
+    ASSERT_EQ(*(begin++), 6);
+    ASSERT_EQ(*(begin++), 9);
+    ASSERT_EQ(*(begin++), 12);
+    ASSERT_EQ(begin, end);
+}
+
+TEST(SparseSetWithType, RespectDisjoint) {
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
+    const auto &clhs = lhs;
+
+    lhs.construct(3, 3);
+    lhs.construct(12, 6);
+    lhs.construct(42, 9);
+
+    ASSERT_EQ(clhs.get(3), 3);
+    ASSERT_EQ(clhs.get(12), 6);
+    ASSERT_EQ(clhs.get(42), 9);
+
+    lhs.respect(rhs);
+
+    ASSERT_EQ(*(clhs.raw() + 0u), 3);
+    ASSERT_EQ(*(clhs.raw() + 1u), 6);
+    ASSERT_EQ(*(clhs.raw() + 2u), 9);
+
+    auto begin = lhs.begin();
+    auto end = lhs.end();
+
+    ASSERT_EQ(*(begin++), 9);
+    ASSERT_EQ(*(begin++), 6);
+    ASSERT_EQ(*(begin++), 3);
+    ASSERT_EQ(begin, end);
+}
+
+TEST(SparseSetWithType, RespectOverlap) {
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
+    const auto &clhs = lhs;
+
+    lhs.construct(3, 3);
+    lhs.construct(12, 6);
+    lhs.construct(42, 9);
+    rhs.construct(12, 6);
+
+    ASSERT_EQ(clhs.get(3), 3);
+    ASSERT_EQ(clhs.get(12), 6);
+    ASSERT_EQ(clhs.get(42), 9);
+    ASSERT_EQ(rhs.get(12), 6);
+
+    lhs.respect(rhs);
+
+    ASSERT_EQ(*(clhs.raw() + 0u), 3);
+    ASSERT_EQ(*(clhs.raw() + 1u), 9);
+    ASSERT_EQ(*(clhs.raw() + 2u), 6);
+
+    auto begin = lhs.begin();
+    auto end = lhs.end();
+
+    ASSERT_EQ(*(begin++), 6);
+    ASSERT_EQ(*(begin++), 9);
+    ASSERT_EQ(*(begin++), 3);
+    ASSERT_EQ(begin, end);
+}
+
+TEST(SparseSetWithType, RespectOrdered) {
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
+
+    lhs.construct(1, 0);
+    lhs.construct(2, 0);
+    lhs.construct(3, 0);
+    lhs.construct(4, 0);
+    lhs.construct(5, 0);
+
+    ASSERT_EQ(lhs.get(1), 0);
+    ASSERT_EQ(lhs.get(2), 0);
+    ASSERT_EQ(lhs.get(3), 0);
+    ASSERT_EQ(lhs.get(4), 0);
+    ASSERT_EQ(lhs.get(5), 0);
+
+    rhs.construct(6, 0);
+    rhs.construct(1, 0);
+    rhs.construct(2, 0);
+    rhs.construct(3, 0);
+    rhs.construct(4, 0);
+    rhs.construct(5, 0);
+
+    ASSERT_EQ(rhs.get(6), 0);
+    ASSERT_EQ(rhs.get(1), 0);
+    ASSERT_EQ(rhs.get(2), 0);
+    ASSERT_EQ(rhs.get(3), 0);
+    ASSERT_EQ(rhs.get(4), 0);
+    ASSERT_EQ(rhs.get(5), 0);
+
+    rhs.respect(lhs);
+
+    ASSERT_EQ(*(lhs.data() + 0u), 1u);
+    ASSERT_EQ(*(lhs.data() + 1u), 2u);
+    ASSERT_EQ(*(lhs.data() + 2u), 3u);
+    ASSERT_EQ(*(lhs.data() + 3u), 4u);
+    ASSERT_EQ(*(lhs.data() + 4u), 5u);
+
+    ASSERT_EQ(*(rhs.data() + 0u), 6u);
+    ASSERT_EQ(*(rhs.data() + 1u), 1u);
+    ASSERT_EQ(*(rhs.data() + 2u), 2u);
+    ASSERT_EQ(*(rhs.data() + 3u), 3u);
+    ASSERT_EQ(*(rhs.data() + 4u), 4u);
+    ASSERT_EQ(*(rhs.data() + 5u), 5u);
+}
+
+TEST(SparseSetWithType, RespectReverse) {
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
+
+    lhs.construct(1, 0);
+    lhs.construct(2, 0);
+    lhs.construct(3, 0);
+    lhs.construct(4, 0);
+    lhs.construct(5, 0);
+
+    ASSERT_EQ(lhs.get(1), 0);
+    ASSERT_EQ(lhs.get(2), 0);
+    ASSERT_EQ(lhs.get(3), 0);
+    ASSERT_EQ(lhs.get(4), 0);
+    ASSERT_EQ(lhs.get(5), 0);
+
+    rhs.construct(5, 0);
+    rhs.construct(4, 0);
+    rhs.construct(3, 0);
+    rhs.construct(2, 0);
+    rhs.construct(1, 0);
+    rhs.construct(6, 0);
+
+    ASSERT_EQ(rhs.get(5), 0);
+    ASSERT_EQ(rhs.get(4), 0);
+    ASSERT_EQ(rhs.get(3), 0);
+    ASSERT_EQ(rhs.get(2), 0);
+    ASSERT_EQ(rhs.get(1), 0);
+    ASSERT_EQ(rhs.get(6), 0);
+
+    rhs.respect(lhs);
+
+    ASSERT_EQ(*(lhs.data() + 0u), 1u);
+    ASSERT_EQ(*(lhs.data() + 1u), 2u);
+    ASSERT_EQ(*(lhs.data() + 2u), 3u);
+    ASSERT_EQ(*(lhs.data() + 3u), 4u);
+    ASSERT_EQ(*(lhs.data() + 4u), 5u);
+
+    ASSERT_EQ(*(rhs.data() + 0u), 6u);
+    ASSERT_EQ(*(rhs.data() + 1u), 1u);
+    ASSERT_EQ(*(rhs.data() + 2u), 2u);
+    ASSERT_EQ(*(rhs.data() + 3u), 3u);
+    ASSERT_EQ(*(rhs.data() + 4u), 4u);
+    ASSERT_EQ(*(rhs.data() + 5u), 5u);
+}
+
+TEST(SparseSetWithType, RespectUnordered) {
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
+
+    lhs.construct(1, 0);
+    lhs.construct(2, 0);
+    lhs.construct(3, 0);
+    lhs.construct(4, 0);
+    lhs.construct(5, 0);
+
+    ASSERT_EQ(lhs.get(1), 0);
+    ASSERT_EQ(lhs.get(2), 0);
+    ASSERT_EQ(lhs.get(3), 0);
+    ASSERT_EQ(lhs.get(4), 0);
+    ASSERT_EQ(lhs.get(5), 0);
+
+    rhs.construct(3, 0);
+    rhs.construct(2, 0);
+    rhs.construct(6, 0);
+    rhs.construct(1, 0);
+    rhs.construct(4, 0);
+    rhs.construct(5, 0);
+
+    ASSERT_EQ(rhs.get(3), 0);
+    ASSERT_EQ(rhs.get(2), 0);
+    ASSERT_EQ(rhs.get(6), 0);
+    ASSERT_EQ(rhs.get(1), 0);
+    ASSERT_EQ(rhs.get(4), 0);
+    ASSERT_EQ(rhs.get(5), 0);
+
+    rhs.respect(lhs);
+
+    ASSERT_EQ(*(lhs.data() + 0u), 1u);
+    ASSERT_EQ(*(lhs.data() + 1u), 2u);
+    ASSERT_EQ(*(lhs.data() + 2u), 3u);
+    ASSERT_EQ(*(lhs.data() + 3u), 4u);
+    ASSERT_EQ(*(lhs.data() + 4u), 5u);
+
+    ASSERT_EQ(*(rhs.data() + 0u), 6u);
+    ASSERT_EQ(*(rhs.data() + 1u), 1u);
+    ASSERT_EQ(*(rhs.data() + 2u), 2u);
+    ASSERT_EQ(*(rhs.data() + 3u), 3u);
+    ASSERT_EQ(*(rhs.data() + 4u), 4u);
+    ASSERT_EQ(*(rhs.data() + 5u), 5u);
+}
+
+TEST(SparseSetWithType, CanModifyDuringIteration) {
+    entt::SparseSet<std::uint64_t, int> set;
+    set.construct(0, 42);
+
+    ASSERT_EQ(set.capacity(), entt::SparseSet<std::uint64_t>::size_type{1});
+
+    const auto it = set.cbegin();
+    set.reserve(entt::SparseSet<std::uint64_t>::size_type{2});
+
+    ASSERT_EQ(set.capacity(), entt::SparseSet<std::uint64_t>::size_type{2});
+
+    // this should crash with asan enabled if we break the constraint
+    const auto entity = *it;
+    (void)entity;
+}
+
+TEST(SparseSetWithType, ReferencesGuaranteed) {
+    struct InternalType { int value; };
+
+    entt::SparseSet<std::uint64_t, InternalType> set;
+
+    set.construct(0, 0);
+    set.construct(1, 1);
+
+    ASSERT_EQ(set.get(0).value, 0);
+    ASSERT_EQ(set.get(1).value, 1);
+
+    for(auto &&type: set) {
+        if(type.value) {
+            type.value = 42;
+        }
+    }
+
+    ASSERT_EQ(set.get(0).value, 0);
+    ASSERT_EQ(set.get(1).value, 42);
+
+    auto begin = set.begin();
+
+    while(begin != set.end()) {
+        (begin++)->value = 3;
+    }
+
+    ASSERT_EQ(set.get(0).value, 3);
+    ASSERT_EQ(set.get(1).value, 3);
+}
+
+TEST(SparseSetWithType, MoveOnlyComponent) {
+    struct MoveOnlyComponent {
+        MoveOnlyComponent() = default;
+        ~MoveOnlyComponent() = default;
+        MoveOnlyComponent(const MoveOnlyComponent &) = delete;
+        MoveOnlyComponent(MoveOnlyComponent &&) = default;
+        MoveOnlyComponent & operator=(const MoveOnlyComponent &) = delete;
+        MoveOnlyComponent & operator=(MoveOnlyComponent &&) = default;
+    };
+
+    // it's purpose is to ensure that move only components are always accepted
+    entt::SparseSet<std::uint64_t, MoveOnlyComponent> set;
+    (void)set;
+}

test/entt/entity/view.cpp

@@ -0,0 +1,862 @@
+#include <utility>
+#include <iterator>
+#include <gtest/gtest.h>
+#include <entt/entity/registry.hpp>
+#include <entt/entity/view.hpp>
+
+TEST(PersistentView, Prepare) {
+    entt::DefaultRegistry registry;
+    registry.prepare<int, char>();
+    auto view = registry.view<int, char>(entt::persistent_t{});
+    const auto &cview = view;
+
+    ASSERT_TRUE(view.empty());
+
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    ASSERT_FALSE(view.empty());
+    ASSERT_NO_THROW((registry.view<int, char>(entt::persistent_t{}).begin()++));
+    ASSERT_NO_THROW((++registry.view<int, char>(entt::persistent_t{}).begin()));
+
+    ASSERT_NE(view.begin(), view.end());
+    ASSERT_NE(cview.begin(), cview.end());
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{1});
+
+    registry.assign<int>(e0);
+
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{2});
+
+    registry.remove<int>(e0);
+
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{1});
+
+    registry.get<char>(e0) = '1';
+    registry.get<char>(e1) = '2';
+    registry.get<int>(e1) = 42;
+
+    for(auto entity: view) {
+        const auto &cview = static_cast<const decltype(view) &>(view);
+        ASSERT_EQ(std::get<0>(cview.get<int, char>(entity)), 42);
+        ASSERT_EQ(std::get<1>(view.get<int, char>(entity)), '2');
+        ASSERT_EQ(cview.get<char>(entity), '2');
+    }
+
+    ASSERT_EQ(*(view.data() + 0), e1);
+
+    registry.remove<char>(e0);
+    registry.remove<char>(e1);
+
+    ASSERT_EQ(view.begin(), view.end());
+    ASSERT_EQ(view.cbegin(), view.cend());
+    ASSERT_TRUE(view.empty());
+}
+
+TEST(PersistentView, NoPrepare) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int, char>(entt::persistent_t{});
+
+    ASSERT_TRUE(view.empty());
+
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    ASSERT_FALSE(view.empty());
+    ASSERT_NO_THROW((registry.view<int, char>(entt::persistent_t{}).begin()++));
+    ASSERT_NO_THROW((++registry.view<int, char>(entt::persistent_t{}).begin()));
+
+    ASSERT_NE(view.begin(), view.end());
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{1});
+
+    registry.assign<int>(e0);
+
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{2});
+
+    registry.remove<int>(e0);
+
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{1});
+
+    registry.get<char>(e0) = '1';
+    registry.get<char>(e1) = '2';
+    registry.get<int>(e1) = 42;
+
+    for(auto entity: view) {
+        const auto &cview = static_cast<const decltype(view) &>(view);
+        ASSERT_EQ(std::get<0>(cview.get<int, char>(entity)), 42);
+        ASSERT_EQ(std::get<1>(view.get<int, char>(entity)), '2');
+        ASSERT_EQ(cview.get<char>(entity), '2');
+    }
+
+    ASSERT_EQ(*(view.data() + 0), e1);
+
+    registry.remove<char>(e0);
+    registry.remove<char>(e1);
+
+    ASSERT_EQ(view.begin(), view.end());
+    ASSERT_EQ(view.cbegin(), view.cend());
+    ASSERT_TRUE(view.empty());
+}
+
+TEST(PersistentView, ElementAccess) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int, char>(entt::persistent_t{});
+    const auto &cview = view;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    for(typename decltype(view)::size_type i{}; i < view.size(); ++i) {
+        ASSERT_EQ(view[i], i ? e0 : e1);
+        ASSERT_EQ(cview[i], i ? e0 : e1);
+    }
+}
+
+TEST(PersistentView, Contains) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    registry.destroy(e0);
+
+    auto view = registry.view<int, char>(entt::persistent_t{});
+
+    ASSERT_FALSE(view.contains(e0));
+    ASSERT_TRUE(view.contains(e1));
+}
+
+TEST(PersistentView, Empty) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<double>(e0);
+    registry.assign<int>(e0);
+    registry.assign<float>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<char>(e1);
+    registry.assign<float>(e1);
+
+    for(auto entity: registry.view<char, int, float>(entt::persistent_t{})) {
+        (void)entity;
+        FAIL();
+    }
+
+    for(auto entity: registry.view<double, char, int, float>(entt::persistent_t{})) {
+        (void)entity;
+        FAIL();
+    }
+}
+
+TEST(PersistentView, Each) {
+    entt::DefaultRegistry registry;
+    registry.prepare<int, char>();
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    auto view = registry.view<int, char>(entt::persistent_t{});
+    const auto &cview = static_cast<const decltype(view) &>(view);
+    std::size_t cnt = 0;
+
+    view.each([&cnt](auto, int &, char &) { ++cnt; });
+
+    ASSERT_EQ(cnt, std::size_t{2});
+
+    cview.each([&cnt](auto, const int &, const char &) { --cnt; });
+
+    ASSERT_EQ(cnt, std::size_t{0});
+}
+
+TEST(PersistentView, Sort) {
+    entt::DefaultRegistry registry;
+    registry.prepare<int, unsigned int>();
+
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+    const auto e2 = registry.create();
+
+    auto uval = 0u;
+    auto ival = 0;
+
+    registry.assign<unsigned int>(e0, uval++);
+    registry.assign<unsigned int>(e1, uval++);
+    registry.assign<unsigned int>(e2, uval++);
+
+    registry.assign<int>(e0, ival++);
+    registry.assign<int>(e1, ival++);
+    registry.assign<int>(e2, ival++);
+
+    auto view = registry.view<int, unsigned int>(entt::persistent_t{});
+
+    for(auto entity: view) {
+        ASSERT_EQ(view.get<unsigned int>(entity), --uval);
+        ASSERT_EQ(view.get<int>(entity), --ival);
+    }
+
+    registry.sort<unsigned int>(std::less<unsigned int>{});
+    view.sort<unsigned int>();
+
+    for(auto entity: view) {
+        ASSERT_EQ(view.get<unsigned int>(entity), uval++);
+        ASSERT_EQ(view.get<int>(entity), ival++);
+    }
+}
+
+TEST(SingleComponentView, Functionalities) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<char>();
+    const auto &cview = view;
+
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+
+    ASSERT_TRUE(view.empty());
+
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    ASSERT_NO_THROW(registry.view<char>().begin()++);
+    ASSERT_NO_THROW(++registry.view<char>().begin());
+
+    ASSERT_NE(view.begin(), view.end());
+    ASSERT_NE(cview.begin(), cview.end());
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{1});
+    ASSERT_FALSE(view.empty());
+
+    registry.assign<char>(e0);
+
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{2});
+
+    view.get(e0) = '1';
+    view.get(e1) = '2';
+
+    for(auto entity: view) {
+        const auto &cview = static_cast<const decltype(view) &>(view);
+        ASSERT_TRUE(cview.get(entity) == '1' || cview.get(entity) == '2');
+    }
+
+    ASSERT_EQ(*(view.data() + 0), e1);
+    ASSERT_EQ(*(view.data() + 1), e0);
+
+    ASSERT_EQ(*(view.raw() + 0), '2');
+    ASSERT_EQ(*(static_cast<const decltype(view) &>(view).raw() + 1), '1');
+
+    registry.remove<char>(e0);
+    registry.remove<char>(e1);
+
+    ASSERT_EQ(view.begin(), view.end());
+    ASSERT_EQ(view.cbegin(), view.cend());
+    ASSERT_TRUE(view.empty());
+}
+
+TEST(SingleComponentView, ElementAccess) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int>();
+    const auto &cview = view;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+
+    for(typename decltype(view)::size_type i{}; i < view.size(); ++i) {
+        ASSERT_EQ(view[i], i ? e0 : e1);
+        ASSERT_EQ(cview[i], i ? e0 : e1);
+    }
+}
+
+TEST(SingleComponentView, Contains) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+
+    registry.destroy(e0);
+
+    auto view = registry.view<int>();
+
+    ASSERT_FALSE(view.contains(e0));
+    ASSERT_TRUE(view.contains(e1));
+}
+
+TEST(SingleComponentView, Empty) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+    registry.assign<double>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<char>(e1);
+
+    auto view = registry.view<int>();
+
+    ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{0});
+
+    for(auto entity: view) {
+        (void)entity;
+        FAIL();
+    }
+}
+
+TEST(SingleComponentView, Each) {
+    entt::DefaultRegistry registry;
+
+    registry.assign<int>(registry.create());
+    registry.assign<int>(registry.create());
+
+    auto view = registry.view<int>();
+    const auto &cview = static_cast<const decltype(view) &>(view);
+    std::size_t cnt = 0;
+
+    view.each([&cnt](auto, int &) { ++cnt; });
+
+    ASSERT_EQ(cnt, std::size_t{2});
+
+    cview.each([&cnt](auto, const int &) { --cnt; });
+
+    ASSERT_EQ(cnt, std::size_t{0});
+}
+
+TEST(MultipleComponentView, Functionalities) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int, char>();
+    const auto &cview = view;
+
+    ASSERT_TRUE(view.empty());
+
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+
+    ASSERT_FALSE(view.empty());
+
+    registry.assign<char>(e1);
+
+    auto it = registry.view<int, char>().begin();
+
+    ASSERT_EQ(*it, e1);
+    ASSERT_EQ(++it, (registry.view<int, char>().end()));
+
+    ASSERT_NO_THROW((registry.view<int, char>().begin()++));
+    ASSERT_NO_THROW((++registry.view<int, char>().begin()));
+
+    ASSERT_NE(view.begin(), view.end());
+    ASSERT_NE(cview.begin(), cview.end());
+    ASSERT_EQ(view.size(), decltype(view.size()){1});
+
+    registry.get<char>(e0) = '1';
+    registry.get<char>(e1) = '2';
+    registry.get<int>(e1) = 42;
+
+    for(auto entity: view) {
+        const auto &cview = static_cast<const decltype(view) &>(view);
+        ASSERT_EQ(std::get<0>(cview.get<int, char>(entity)), 42);
+        ASSERT_EQ(std::get<1>(view.get<int, char>(entity)), '2');
+        ASSERT_EQ(cview.get<char>(entity), '2');
+    }
+}
+
+TEST(MultipleComponentView, Iterator) {
+    entt::DefaultRegistry registry;
+    const auto entity = registry.create();
+    registry.assign<int>(entity);
+    registry.assign<char>(entity);
+
+    const auto view = registry.view<int, char>();
+    using iterator_type = typename decltype(view)::iterator_type;
+
+    iterator_type end{view.begin()};
+    iterator_type begin{};
+    begin = view.end();
+    std::swap(begin, end);
+
+    ASSERT_EQ(begin, view.begin());
+    ASSERT_EQ(end, view.end());
+    ASSERT_NE(begin, end);
+
+    ASSERT_EQ(view.begin()++, view.begin());
+    ASSERT_EQ(++view.begin(), view.end());
+}
+
+TEST(MultipleComponentView, ConstIterator) {
+    entt::DefaultRegistry registry;
+    const auto entity = registry.create();
+    registry.assign<int>(entity);
+    registry.assign<char>(entity);
+
+    const auto view = registry.view<int, char>();
+    using iterator_type = typename decltype(view)::iterator_type;
+
+    iterator_type cend{view.cbegin()};
+    iterator_type cbegin{};
+    cbegin = view.cend();
+    std::swap(cbegin, cend);
+
+    ASSERT_EQ(cbegin, view.cbegin());
+    ASSERT_EQ(cend, view.cend());
+    ASSERT_NE(cbegin, cend);
+
+    ASSERT_EQ(view.cbegin()++, view.cbegin());
+    ASSERT_EQ(++view.cbegin(), view.cend());
+}
+
+TEST(MultipleComponentView, Contains) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    registry.destroy(e0);
+
+    auto view = registry.view<int, char>();
+
+    ASSERT_FALSE(view.contains(e0));
+    ASSERT_TRUE(view.contains(e1));
+}
+
+TEST(MultipleComponentView, Empty) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<double>(e0);
+    registry.assign<int>(e0);
+    registry.assign<float>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<char>(e1);
+    registry.assign<float>(e1);
+
+    auto view = registry.view<char, int, float>();
+
+    for(auto entity: view) {
+        (void)entity;
+        FAIL();
+    }
+}
+
+TEST(MultipleComponentView, Each) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    auto view = registry.view<int, char>();
+    const auto &cview = static_cast<const decltype(view) &>(view);
+    std::size_t cnt = 0;
+
+    view.each([&cnt](auto, int &, char &) { ++cnt; });
+
+    ASSERT_EQ(cnt, std::size_t{2});
+
+    cview.each([&cnt](auto, const int &, const char &) { --cnt; });
+
+    ASSERT_EQ(cnt, std::size_t{0});
+}
+
+TEST(MultipleComponentView, EachWithHoles) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+    const auto e2 = registry.create();
+
+    registry.assign<char>(e0, '0');
+    registry.assign<char>(e1, '1');
+
+    registry.assign<int>(e0, 0);
+    registry.assign<int>(e2, 2);
+
+    auto view = registry.view<char, int>();
+
+    view.each([e0](auto entity, const char &c, const int &i) {
+        if(e0 == entity) {
+            ASSERT_EQ(c, '0');
+            ASSERT_EQ(i, 0);
+        } else {
+            FAIL();
+        }
+    });
+}
+
+TEST(RawView, Functionalities) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<char>(entt::raw_t{});
+    const auto &cview = view;
+
+    ASSERT_TRUE(view.empty());
+
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    ASSERT_FALSE(view.empty());
+    ASSERT_NO_THROW(registry.view<char>(entt::raw_t{}).begin()++);
+    ASSERT_NO_THROW(++registry.view<char>(entt::raw_t{}).begin());
+
+    ASSERT_NE(view.begin(), view.end());
+    ASSERT_NE(cview.begin(), cview.end());
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{1});
+
+    registry.assign<char>(e0);
+
+    ASSERT_EQ(view.size(), typename decltype(view)::size_type{2});
+
+    registry.get<char>(e0) = '1';
+    registry.get<char>(e1) = '2';
+
+    for(auto &&component: view) {
+        ASSERT_TRUE(component == '1' || component == '2');
+    }
+
+    ASSERT_EQ(*(view.data() + 0), e1);
+    ASSERT_EQ(*(view.data() + 1), e0);
+
+    ASSERT_EQ(*(view.raw() + 0), '2');
+    ASSERT_EQ(*(static_cast<const decltype(view) &>(view).raw() + 1), '1');
+
+    for(auto &&component: view) {
+        // verifies that iterators return references to components
+        component = '0';
+    }
+
+    for(auto &&component: view) {
+        ASSERT_TRUE(component == '0');
+    }
+
+    registry.remove<char>(e0);
+    registry.remove<char>(e1);
+
+    ASSERT_EQ(view.begin(), view.end());
+    ASSERT_EQ(view.cbegin(), view.cend());
+    ASSERT_TRUE(view.empty());
+}
+
+TEST(RawView, ElementAccess) {
+    entt::DefaultRegistry registry;
+    auto view = registry.view<int>(entt::raw_t{});
+    const auto &cview = view;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0, 42);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1, 3);
+
+    for(typename decltype(view)::size_type i{}; i < view.size(); ++i) {
+        ASSERT_EQ(view[i], i ? 42 : 3);
+        ASSERT_EQ(cview[i], i ? 42 : 3);
+    }
+}
+
+TEST(RawView, Empty) {
+    entt::DefaultRegistry registry;
+
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+    registry.assign<double>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<char>(e1);
+
+    auto view = registry.view<int>(entt::raw_t{});
+
+    ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{0});
+
+    for(auto &&component: view) {
+        (void)component;
+        FAIL();
+    }
+}
+
+TEST(RawView, Each) {
+    entt::DefaultRegistry registry;
+
+    registry.assign<int>(registry.create(), 1);
+    registry.assign<int>(registry.create(), 3);
+
+    auto view = registry.view<int>(entt::raw_t{});
+    const auto &cview = static_cast<const decltype(view) &>(view);
+    std::size_t cnt = 0;
+
+    view.each([&cnt](int &v) { cnt += (v % 2); });
+
+    ASSERT_EQ(cnt, std::size_t{2});
+
+    cview.each([&cnt](const int &v) { cnt -= (v % 2); });
+
+    ASSERT_EQ(cnt, std::size_t{0});
+}
+
+TEST(RuntimeView, Functionalities) {
+    entt::DefaultRegistry registry;
+    using component_type = typename decltype(registry)::component_type;
+
+    // forces the creation of the pools
+    registry.reserve<int>(0);
+    registry.reserve<char>(0);
+
+    component_type types[] = { registry.type<int>(), registry.type<char>() };
+    auto view = registry.view(std::begin(types), std::end(types));
+    const auto &cview = view;
+
+    ASSERT_TRUE(view.empty());
+
+    const auto e0 = registry.create();
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+
+    ASSERT_FALSE(view.empty());
+
+    registry.assign<char>(e1);
+
+    auto it = registry.view(std::begin(types), std::end(types)).begin();
+
+    ASSERT_EQ(*it, e1);
+    ASSERT_EQ(++it, (registry.view(std::begin(types), std::end(types)).end()));
+
+    ASSERT_NO_THROW((registry.view(std::begin(types), std::end(types)).begin()++));
+    ASSERT_NO_THROW((++registry.view(std::begin(types), std::end(types)).begin()));
+
+    ASSERT_NE(view.begin(), view.end());
+    ASSERT_NE(cview.begin(), cview.end());
+    ASSERT_EQ(view.size(), decltype(view.size()){1});
+
+    registry.get<char>(e0) = '1';
+    registry.get<char>(e1) = '2';
+    registry.get<int>(e1) = 42;
+
+    for(auto entity: view) {
+        ASSERT_EQ(registry.get<int>(entity), 42);
+        ASSERT_EQ(registry.get<char>(entity), '2');
+    }
+}
+
+TEST(RuntimeView, Iterator) {
+    entt::DefaultRegistry registry;
+    using component_type = typename decltype(registry)::component_type;
+
+    const auto entity = registry.create();
+    registry.assign<int>(entity);
+    registry.assign<char>(entity);
+
+    component_type types[] = { registry.type<int>(), registry.type<char>() };
+    auto view = registry.view(std::begin(types), std::end(types));
+    using iterator_type = typename decltype(view)::iterator_type;
+
+    iterator_type end{view.begin()};
+    iterator_type begin{};
+    begin = view.end();
+    std::swap(begin, end);
+
+    ASSERT_EQ(begin, view.begin());
+    ASSERT_EQ(end, view.end());
+    ASSERT_NE(begin, end);
+
+    ASSERT_EQ(view.begin()++, view.begin());
+    ASSERT_EQ(++view.begin(), view.end());
+}
+
+TEST(RuntimeView, ConstIterator) {
+    entt::DefaultRegistry registry;
+    using component_type = typename decltype(registry)::component_type;
+
+    const auto entity = registry.create();
+    registry.assign<int>(entity);
+    registry.assign<char>(entity);
+
+    component_type types[] = { registry.type<int>(), registry.type<char>() };
+    auto view = registry.view(std::begin(types), std::end(types));
+    using iterator_type = typename decltype(view)::iterator_type;
+
+    iterator_type cend{view.cbegin()};
+    iterator_type cbegin{};
+    cbegin = view.cend();
+    std::swap(cbegin, cend);
+
+    ASSERT_EQ(cbegin, view.cbegin());
+    ASSERT_EQ(cend, view.cend());
+    ASSERT_NE(cbegin, cend);
+
+    ASSERT_EQ(view.cbegin()++, view.cbegin());
+    ASSERT_EQ(++view.cbegin(), view.cend());
+}
+
+TEST(RuntimeView, Contains) {
+    entt::DefaultRegistry registry;
+    using component_type = typename decltype(registry)::component_type;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    registry.destroy(e0);
+
+    component_type types[] = { registry.type<int>(), registry.type<char>() };
+    auto view = registry.view(std::begin(types), std::end(types));
+
+    ASSERT_FALSE(view.contains(e0));
+    ASSERT_TRUE(view.contains(e1));
+}
+
+TEST(RuntimeView, Empty) {
+    entt::DefaultRegistry registry;
+    using component_type = typename decltype(registry)::component_type;
+
+    const auto e0 = registry.create();
+    registry.assign<double>(e0);
+    registry.assign<int>(e0);
+    registry.assign<float>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<char>(e1);
+    registry.assign<float>(e1);
+
+    component_type types[] = { registry.type<char>(), registry.type<int>(), registry.type<float>() };
+    auto view = registry.view(std::begin(types), std::end(types));
+
+    for(auto entity: view) {
+        (void)entity;
+        FAIL();
+    }
+}
+
+TEST(RuntimeView, Each) {
+    entt::DefaultRegistry registry;
+    using component_type = typename decltype(registry)::component_type;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    component_type types[] = { registry.type<int>(), registry.type<char>() };
+    auto view = registry.view(std::begin(types), std::end(types));
+    std::size_t cnt = 0;
+
+    view.each([&cnt](auto) { ++cnt; });
+
+    ASSERT_EQ(cnt, std::size_t{2});
+}
+
+TEST(RuntimeView, EachWithHoles) {
+    entt::DefaultRegistry registry;
+    using component_type = typename decltype(registry)::component_type;
+
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
+    const auto e2 = registry.create();
+
+    registry.assign<char>(e0, '0');
+    registry.assign<char>(e1, '1');
+
+    registry.assign<int>(e0, 0);
+    registry.assign<int>(e2, 2);
+
+    component_type types[] = { registry.type<int>(), registry.type<char>() };
+    auto view = registry.view(std::begin(types), std::end(types));
+
+    view.each([e0](auto entity) {
+        ASSERT_EQ(e0, entity);
+    });
+}
+
+TEST(RuntimeView, MissingPool) {
+    entt::DefaultRegistry registry;
+    using component_type = typename decltype(registry)::component_type;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+
+    component_type types[] = { registry.type<int>(), registry.type<char>() };
+    auto view = registry.view(std::begin(types), std::end(types));
+
+    ASSERT_TRUE(view.empty());
+    ASSERT_EQ(view.size(), decltype(view.size()){0});
+
+    registry.assign<char>(e0);
+
+    ASSERT_TRUE(view.empty());
+    ASSERT_EQ(view.size(), decltype(view.size()){0});
+    ASSERT_FALSE(view.contains(e0));
+
+    view.each([](auto) { FAIL(); });
+
+    for(auto entity: view) {
+        (void)entity;
+        FAIL();
+    }
+}
+
+TEST(RuntimeView, EmptyRange) {
+    entt::DefaultRegistry registry;
+    using component_type = typename decltype(registry)::component_type;
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+
+    const component_type *ptr = nullptr;
+    auto view = registry.view(ptr, ptr);
+
+    ASSERT_TRUE(view.empty());
+    ASSERT_EQ(view.size(), decltype(view.size()){0});
+    ASSERT_FALSE(view.contains(e0));
+
+    view.each([](auto) { FAIL(); });
+
+    for(auto entity: view) {
+        (void)entity;
+        FAIL();
+    }
+}

test/entt/locator/locator.cpp

@@ -0,0 +1,50 @@
+#include <gtest/gtest.h>
+#include <entt/locator/locator.hpp>
+
+struct AService {};
+
+struct AnotherService {
+    virtual ~AnotherService() = default;
+    virtual void f(bool) = 0;
+    bool check{false};
+};
+
+struct DerivedService: AnotherService {
+    DerivedService(int): AnotherService{} {}
+    void f(bool b) override { check = b; }
+};
+
+TEST(ServiceLocator, Functionalities) {
+    using entt::ServiceLocator;
+
+    ASSERT_TRUE(ServiceLocator<AService>::empty());
+    ASSERT_TRUE(ServiceLocator<AnotherService>::empty());
+
+    ServiceLocator<AService>::set();
+
+    ASSERT_FALSE(ServiceLocator<AService>::empty());
+    ASSERT_TRUE(ServiceLocator<AnotherService>::empty());
+
+    ServiceLocator<AService>::reset();
+
+    ASSERT_TRUE(ServiceLocator<AService>::empty());
+    ASSERT_TRUE(ServiceLocator<AnotherService>::empty());
+
+    ServiceLocator<AService>::set(std::make_shared<AService>());
+
+    ASSERT_FALSE(ServiceLocator<AService>::empty());
+    ASSERT_TRUE(ServiceLocator<AnotherService>::empty());
+
+    ServiceLocator<AnotherService>::set<DerivedService>(42);
+
+    ASSERT_FALSE(ServiceLocator<AService>::empty());
+    ASSERT_FALSE(ServiceLocator<AnotherService>::empty());
+
+    ServiceLocator<AnotherService>::get().lock()->f(!ServiceLocator<AnotherService>::get().lock()->check);
+
+    ASSERT_TRUE(ServiceLocator<AnotherService>::get().lock()->check);
+
+    ServiceLocator<AnotherService>::ref().f(!ServiceLocator<AnotherService>::get().lock()->check);
+
+    ASSERT_FALSE(ServiceLocator<AnotherService>::get().lock()->check);
+}

test/entt/process/process.cpp

@@ -0,0 +1,206 @@
+#include <gtest/gtest.h>
+#include <cstdint>
+#include <entt/process/process.hpp>
+
+struct FakeProcess: entt::Process<FakeProcess, int> {
+    using process_type = entt::Process<FakeProcess, int>;
+
+    void succeed() noexcept { process_type::succeed(); }
+    void fail() noexcept { process_type::fail(); }
+    void pause() noexcept { process_type::pause(); }
+    void unpause() noexcept { process_type::unpause(); }
+
+    void init(void *) { initInvoked = true; }
+    void succeeded() { succeededInvoked = true; }
+    void failed() { failedInvoked = true; }
+    void aborted() { abortedInvoked = true; }
+
+    void update(delta_type, void *data) {
+        if(data) {
+            (*static_cast<int *>(data))++;
+        }
+
+        updateInvoked = true;
+    }
+
+    bool initInvoked{false};
+    bool updateInvoked{false};
+    bool succeededInvoked{false};
+    bool failedInvoked{false};
+    bool abortedInvoked{false};
+};
+
+TEST(Process, Basics) {
+    FakeProcess process;
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.dead());
+    ASSERT_FALSE(process.paused());
+
+    process.succeed();
+    process.fail();
+    process.abort();
+    process.pause();
+    process.unpause();
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_FALSE(process.dead());
+    ASSERT_FALSE(process.paused());
+
+    process.tick(0);
+
+    ASSERT_TRUE(process.alive());
+    ASSERT_FALSE(process.dead());
+    ASSERT_FALSE(process.paused());
+
+    process.pause();
+
+    ASSERT_TRUE(process.alive());
+    ASSERT_FALSE(process.dead());
+    ASSERT_TRUE(process.paused());
+
+    process.unpause();
+
+    ASSERT_TRUE(process.alive());
+    ASSERT_FALSE(process.dead());
+    ASSERT_FALSE(process.paused());
+}
+
+TEST(Process, Succeeded) {
+    FakeProcess process;
+
+    process.tick(0);
+    process.succeed();
+    process.tick(0);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_TRUE(process.dead());
+    ASSERT_FALSE(process.paused());
+
+    ASSERT_TRUE(process.initInvoked);
+    ASSERT_TRUE(process.updateInvoked);
+    ASSERT_TRUE(process.succeededInvoked);
+    ASSERT_FALSE(process.failedInvoked);
+    ASSERT_FALSE(process.abortedInvoked);
+}
+
+TEST(Process, Fail) {
+    FakeProcess process;
+
+    process.tick(0);
+    process.fail();
+    process.tick(0);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_TRUE(process.dead());
+    ASSERT_FALSE(process.paused());
+
+    ASSERT_TRUE(process.initInvoked);
+    ASSERT_TRUE(process.updateInvoked);
+    ASSERT_FALSE(process.succeededInvoked);
+    ASSERT_TRUE(process.failedInvoked);
+    ASSERT_FALSE(process.abortedInvoked);
+}
+
+TEST(Process, Data) {
+    FakeProcess process;
+    int value = 0;
+
+    process.tick(0, &value);
+    process.succeed();
+    process.tick(0, &value);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_TRUE(process.dead());
+    ASSERT_FALSE(process.paused());
+
+    ASSERT_EQ(value, 1);
+    ASSERT_TRUE(process.initInvoked);
+    ASSERT_TRUE(process.updateInvoked);
+    ASSERT_TRUE(process.succeededInvoked);
+    ASSERT_FALSE(process.failedInvoked);
+    ASSERT_FALSE(process.abortedInvoked);
+}
+
+TEST(Process, AbortNextTick) {
+    FakeProcess process;
+
+    process.tick(0);
+    process.abort();
+    process.tick(0);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_TRUE(process.dead());
+    ASSERT_FALSE(process.paused());
+
+    ASSERT_TRUE(process.initInvoked);
+    ASSERT_TRUE(process.updateInvoked);
+    ASSERT_FALSE(process.succeededInvoked);
+    ASSERT_FALSE(process.failedInvoked);
+    ASSERT_TRUE(process.abortedInvoked);
+}
+
+TEST(Process, AbortImmediately) {
+    FakeProcess process;
+
+    process.tick(0);
+    process.abort(true);
+
+    ASSERT_FALSE(process.alive());
+    ASSERT_TRUE(process.dead());
+    ASSERT_FALSE(process.paused());
+
+    ASSERT_TRUE(process.initInvoked);
+    ASSERT_TRUE(process.updateInvoked);
+    ASSERT_FALSE(process.succeededInvoked);
+    ASSERT_FALSE(process.failedInvoked);
+    ASSERT_TRUE(process.abortedInvoked);
+}
+
+TEST(ProcessAdaptor, Resolved) {
+    bool updated = false;
+    auto lambda = [&updated](std::uint64_t, void *, auto resolve, auto) {
+        ASSERT_FALSE(updated);
+        updated = true;
+        resolve();
+    };
+
+    auto process = entt::ProcessAdaptor<decltype(lambda), std::uint64_t>{lambda};
+
+    process.tick(0);
+
+    ASSERT_TRUE(process.dead());
+    ASSERT_TRUE(updated);
+}
+
+TEST(ProcessAdaptor, Rejected) {
+    bool updated = false;
+    auto lambda = [&updated](std::uint64_t, void *, auto, auto rejected) {
+        ASSERT_FALSE(updated);
+        updated = true;
+        rejected();
+    };
+
+    auto process = entt::ProcessAdaptor<decltype(lambda), std::uint64_t>{lambda};
+
+    process.tick(0);
+
+    ASSERT_TRUE(process.rejected());
+    ASSERT_TRUE(updated);
+}
+
+TEST(ProcessAdaptor, Data) {
+    int value = 0;
+
+    auto lambda = [](std::uint64_t, void *data, auto resolve, auto) {
+        *static_cast<int *>(data) = 42;
+        resolve();
+    };
+
+    auto process = entt::ProcessAdaptor<decltype(lambda), std::uint64_t>{lambda};
+
+    process.tick(0, &value);
+
+    ASSERT_TRUE(process.dead());
+    ASSERT_EQ(value, 42);
+}

test/entt/process/scheduler.cpp

@@ -0,0 +1,113 @@
+#include <functional>
+#include <gtest/gtest.h>
+#include <entt/process/scheduler.hpp>
+#include <entt/process/process.hpp>
+
+struct FooProcess: entt::Process<FooProcess, int> {
+    FooProcess(std::function<void()> onUpdate, std::function<void()> onAborted)
+        : onUpdate{onUpdate}, onAborted{onAborted}
+    {}
+
+    void update(delta_type, void *) { onUpdate(); }
+    void aborted() { onAborted(); }
+
+    std::function<void()> onUpdate;
+    std::function<void()> onAborted;
+};
+
+struct SucceededProcess: entt::Process<SucceededProcess, int> {
+    void update(delta_type, void *) {
+        ASSERT_FALSE(updated);
+        updated = true;
+        ++invoked;
+        succeed();
+    }
+
+    static unsigned int invoked;
+    bool updated = false;
+};
+
+unsigned int SucceededProcess::invoked = 0;
+
+struct FailedProcess: entt::Process<FailedProcess, int> {
+    void update(delta_type, void *) {
+        ASSERT_FALSE(updated);
+        updated = true;
+        fail();
+    }
+
+    bool updated = false;
+};
+
+TEST(Scheduler, Functionalities) {
+    entt::Scheduler<int> scheduler{};
+
+    bool updated = false;
+    bool aborted = false;
+
+    ASSERT_EQ(scheduler.size(), entt::Scheduler<int>::size_type{});
+    ASSERT_TRUE(scheduler.empty());
+
+    scheduler.attach<FooProcess>(
+                [&updated](){ updated = true; },
+                [&aborted](){ aborted = true; }
+    );
+
+    ASSERT_NE(scheduler.size(), entt::Scheduler<int>::size_type{});
+    ASSERT_FALSE(scheduler.empty());
+
+    scheduler.update(0);
+    scheduler.abort(true);
+
+    ASSERT_TRUE(updated);
+    ASSERT_TRUE(aborted);
+
+    ASSERT_NE(scheduler.size(), entt::Scheduler<int>::size_type{});
+    ASSERT_FALSE(scheduler.empty());
+
+    scheduler.clear();
+
+    ASSERT_EQ(scheduler.size(), entt::Scheduler<int>::size_type{});
+    ASSERT_TRUE(scheduler.empty());
+}
+
+TEST(Scheduler, Then) {
+    entt::Scheduler<int> scheduler;
+
+    scheduler.attach<SucceededProcess>()
+            .then<SucceededProcess>()
+            .then<FailedProcess>()
+            .then<SucceededProcess>();
+
+    for(auto i = 0; i < 8; ++i) {
+        scheduler.update(0);
+    }
+
+    ASSERT_EQ(SucceededProcess::invoked, 2u);
+}
+
+TEST(Scheduler, Functor) {
+    entt::Scheduler<int> scheduler;
+
+    bool firstFunctor = false;
+    bool secondFunctor = false;
+
+    scheduler.attach([&firstFunctor](auto, void *, auto resolve, auto){
+        ASSERT_FALSE(firstFunctor);
+        firstFunctor = true;
+        resolve();
+    }).then([&secondFunctor](auto, void *, auto, auto reject){
+        ASSERT_FALSE(secondFunctor);
+        secondFunctor = true;
+        reject();
+    }).then([](auto...){
+        FAIL();
+    });
+
+    for(auto i = 0; i < 8; ++i) {
+        scheduler.update(0);
+    }
+
+    ASSERT_TRUE(firstFunctor);
+    ASSERT_TRUE(secondFunctor);
+}

test/entt/resource/resource.cpp

@@ -0,0 +1,85 @@
+#include <gtest/gtest.h>
+#include <entt/resource/cache.hpp>
+
+struct Resource { const int value; };
+
+struct Loader: entt::ResourceLoader<Loader, Resource> {
+    std::shared_ptr<Resource> load(int value) const {
+        return std::shared_ptr<Resource>(new Resource{ value });
+    }
+};
+
+struct BrokenLoader: entt::ResourceLoader<BrokenLoader, Resource> {
+    std::shared_ptr<Resource> load(int) const {
+        return nullptr;
+    }
+};
+
+TEST(ResourceCache, Functionalities) {
+    entt::ResourceCache<Resource> cache;
+
+    constexpr auto hs1 = entt::HashedString{"res1"};
+    constexpr auto hs2 = entt::HashedString{"res2"};
+
+    ASSERT_EQ(cache.size(), entt::ResourceCache<Resource>::size_type{});
+    ASSERT_TRUE(cache.empty());
+    ASSERT_FALSE(cache.contains(hs1));
+    ASSERT_FALSE(cache.contains(hs2));
+
+    ASSERT_FALSE(cache.load<BrokenLoader>(hs1, 42));
+    ASSERT_FALSE(cache.reload<BrokenLoader>(hs1, 42));
+
+    ASSERT_EQ(cache.size(), entt::ResourceCache<Resource>::size_type{});
+    ASSERT_TRUE(cache.empty());
+    ASSERT_FALSE(cache.contains(hs1));
+    ASSERT_FALSE(cache.contains(hs2));
+
+    ASSERT_TRUE(cache.load<Loader>(hs1, 42));
+    ASSERT_TRUE(cache.reload<Loader>(hs1, 42));
+
+    ASSERT_NE(cache.size(), entt::ResourceCache<Resource>::size_type{});
+    ASSERT_FALSE(cache.empty());
+    ASSERT_TRUE(cache.contains(hs1));
+    ASSERT_FALSE(cache.contains(hs2));
+    ASSERT_EQ((*cache.handle(hs1)).value, 42);
+
+    ASSERT_TRUE(cache.load<Loader>(hs2, 42));
+
+    ASSERT_NE(cache.size(), entt::ResourceCache<Resource>::size_type{});
+    ASSERT_FALSE(cache.empty());
+    ASSERT_TRUE(cache.contains(hs1));
+    ASSERT_TRUE(cache.contains(hs2));
+    ASSERT_EQ((*cache.handle(hs1)).value, 42);
+    ASSERT_EQ(cache.handle(hs2)->value, 42);
+
+    ASSERT_NO_THROW(cache.discard(hs1));
+
+    ASSERT_FALSE(cache.contains(hs1));
+    ASSERT_TRUE(cache.contains(hs2));
+    ASSERT_EQ(cache.handle(hs2)->value, 42);
+
+    ASSERT_TRUE(cache.load<Loader>(hs1, 42));
+    ASSERT_NO_THROW(cache.clear());
+
+    ASSERT_EQ(cache.size(), entt::ResourceCache<Resource>::size_type{});
+    ASSERT_TRUE(cache.empty());
+    ASSERT_FALSE(cache.contains(hs1));
+    ASSERT_FALSE(cache.contains(hs2));
+
+    ASSERT_TRUE(cache.load<Loader>(hs1, 42));
+
+    ASSERT_NE(cache.size(), entt::ResourceCache<Resource>::size_type{});
+    ASSERT_FALSE(cache.empty());
+    ASSERT_TRUE(cache.handle(hs1));
+    ASSERT_FALSE(cache.handle(hs2));
+
+    ASSERT_TRUE(cache.handle(hs1));
+    ASSERT_EQ(&cache.handle(hs1).get(), &static_cast<const Resource &>(cache.handle(hs1)));
+    ASSERT_NO_THROW(cache.clear());
+
+    ASSERT_EQ(cache.size(), entt::ResourceCache<Resource>::size_type{});
+    ASSERT_TRUE(cache.empty());
+
+    ASSERT_TRUE(cache.temp<Loader>(42));
+    ASSERT_TRUE(cache.empty());
+}

test/entt/signal/delegate.cpp

@@ -0,0 +1,75 @@
+#include <gtest/gtest.h>
+#include <entt/signal/delegate.hpp>
+
+int delegateFunction(int i) {
+    return i*i;
+}
+
+struct DelegateFunctor {
+    int operator()(int i) {
+        return i+i;
+    }
+};
+
+struct ConstNonConstNoExcept {
+    void f() { ++cnt; }
+    void g() noexcept { ++cnt; }
+    void h() const { ++cnt; }
+    void i() const noexcept { ++cnt; }
+    mutable int cnt{0};
+};
+
+TEST(Delegate, Functionalities) {
+    entt::Delegate<int(int)> ffdel;
+    entt::Delegate<int(int)> mfdel;
+    DelegateFunctor functor;
+
+    ASSERT_TRUE(ffdel.empty());
+    ASSERT_TRUE(mfdel.empty());
+
+    ffdel.connect<&delegateFunction>();
+    mfdel.connect<DelegateFunctor, &DelegateFunctor::operator()>(&functor);
+
+    ASSERT_FALSE(ffdel.empty());
+    ASSERT_FALSE(mfdel.empty());
+
+    ASSERT_EQ(ffdel(3), 9);
+    ASSERT_EQ(mfdel(3), 6);
+
+    ffdel.reset();
+    mfdel.reset();
+
+    ASSERT_TRUE(ffdel.empty());
+    ASSERT_TRUE(mfdel.empty());
+}
+
+TEST(Delegate, Comparison) {
+    entt::Delegate<int(int)> delegate;
+    entt::Delegate<int(int)> def;
+    delegate.connect<&delegateFunction>();
+
+    ASSERT_EQ(def, entt::Delegate<int(int)>{});
+    ASSERT_NE(def, delegate);
+
+    ASSERT_TRUE(def == entt::Delegate<int(int)>{});
+    ASSERT_TRUE (def != delegate);
+}
+
+TEST(Delegate, ConstNonConstNoExcept) {
+    entt::Delegate<void()> delegate;
+    ConstNonConstNoExcept functor;
+
+    delegate.connect<ConstNonConstNoExcept, &ConstNonConstNoExcept::f>(&functor);
+    delegate();
+
+    delegate.connect<ConstNonConstNoExcept, &ConstNonConstNoExcept::g>(&functor);
+    delegate();
+
+    delegate.connect<ConstNonConstNoExcept, &ConstNonConstNoExcept::h>(&functor);
+    delegate();
+
+    delegate.connect<ConstNonConstNoExcept, &ConstNonConstNoExcept::i>(&functor);
+    delegate();
+
+    ASSERT_EQ(functor.cnt, 4);
+}

test/entt/signal/dispatcher.cpp

@@ -0,0 +1,40 @@
+#include <memory>
+#include <gtest/gtest.h>
+#include <entt/signal/dispatcher.hpp>
+
+struct AnEvent {};
+struct AnotherEvent {};
+
+struct Receiver {
+    void receive(const AnEvent &) { ++cnt; }
+    void reset() { cnt = 0; }
+    int cnt{0};
+};
+
+TEST(Dispatcher, Functionalities) {
+    entt::Dispatcher dispatcher;
+    Receiver receiver;
+
+    dispatcher.template sink<AnEvent>().connect(&receiver);
+    dispatcher.template trigger<AnEvent>();
+    dispatcher.template enqueue<AnEvent>();
+    dispatcher.template enqueue<AnotherEvent>();
+    dispatcher.update<AnotherEvent>();
+
+    ASSERT_EQ(receiver.cnt, 1);
+
+    dispatcher.update<AnEvent>();
+    dispatcher.template trigger<AnEvent>();
+
+    ASSERT_EQ(receiver.cnt, 3);
+
+    receiver.reset();
+
+    dispatcher.template sink<AnEvent>().disconnect(&receiver);
+    dispatcher.template trigger<AnEvent>();
+    dispatcher.template enqueue<AnEvent>();
+    dispatcher.update();
+    dispatcher.template trigger<AnEvent>();
+
+    ASSERT_EQ(receiver.cnt, 0);
+}

test/entt/signal/emitter.cpp

@@ -0,0 +1,117 @@
+#include <gtest/gtest.h>
+#include <entt/signal/emitter.hpp>
+
+struct TestEmitter: entt::Emitter<TestEmitter> {};
+
+struct FooEvent { int i; char c; };
+struct BarEvent {};
+
+TEST(Emitter, Clear) {
+    TestEmitter emitter;
+
+    ASSERT_TRUE(emitter.empty());
+
+    emitter.on<FooEvent>([](const auto &, const auto &){});
+
+    ASSERT_FALSE(emitter.empty());
+    ASSERT_FALSE(emitter.empty<FooEvent>());
+    ASSERT_TRUE(emitter.empty<BarEvent>());
+
+    emitter.clear<BarEvent>();
+
+    ASSERT_FALSE(emitter.empty());
+    ASSERT_FALSE(emitter.empty<FooEvent>());
+    ASSERT_TRUE(emitter.empty<BarEvent>());
+
+    emitter.clear<FooEvent>();
+
+    ASSERT_TRUE(emitter.empty());
+    ASSERT_TRUE(emitter.empty<FooEvent>());
+    ASSERT_TRUE(emitter.empty<BarEvent>());
+
+    emitter.on<FooEvent>([](const auto &, const auto &){});
+    emitter.on<BarEvent>([](const auto &, const auto &){});
+
+    ASSERT_FALSE(emitter.empty());
+    ASSERT_FALSE(emitter.empty<FooEvent>());
+    ASSERT_FALSE(emitter.empty<BarEvent>());
+
+    emitter.clear();
+
+    ASSERT_TRUE(emitter.empty());
+    ASSERT_TRUE(emitter.empty<FooEvent>());
+    ASSERT_TRUE(emitter.empty<BarEvent>());
+}
+
+TEST(Emitter, ClearPublishing) {
+    TestEmitter emitter;
+    bool invoked = false;
+
+    ASSERT_TRUE(emitter.empty());
+
+    emitter.on<BarEvent>([&invoked](const auto &, auto &em){
+        invoked = true;
+        em.clear();
+    });
+
+    emitter.publish<BarEvent>();
+
+    ASSERT_TRUE(emitter.empty());
+    ASSERT_TRUE(invoked);
+}
+
+TEST(Emitter, On) {
+    TestEmitter emitter;
+
+    emitter.on<FooEvent>([](const auto &, const auto &){});
+
+    ASSERT_FALSE(emitter.empty());
+    ASSERT_FALSE(emitter.empty<FooEvent>());
+
+    emitter.publish<FooEvent>(0, 'c');
+
+    ASSERT_FALSE(emitter.empty());
+    ASSERT_FALSE(emitter.empty<FooEvent>());
+}
+
+TEST(Emitter, Once) {
+    TestEmitter emitter;
+
+    emitter.once<BarEvent>([](const auto &, const auto &){});
+
+    ASSERT_FALSE(emitter.empty());
+    ASSERT_FALSE(emitter.empty<BarEvent>());
+
+    emitter.publish<BarEvent>();
+
+    ASSERT_TRUE(emitter.empty());
+    ASSERT_TRUE(emitter.empty<BarEvent>());
+}
+
+TEST(Emitter, OnceAndErase) {
+    TestEmitter emitter;
+
+    auto conn = emitter.once<FooEvent>([](const auto &, const auto &){});
+
+    ASSERT_FALSE(emitter.empty());
+    ASSERT_FALSE(emitter.empty<FooEvent>());
+
+    emitter.erase(conn);
+
+    ASSERT_TRUE(emitter.empty());
+    ASSERT_TRUE(emitter.empty<FooEvent>());
+}
+
+TEST(Emitter, OnAndErase) {
+    TestEmitter emitter;
+
+    auto conn = emitter.on<BarEvent>([](const auto &, const auto &){});
+
+    ASSERT_FALSE(emitter.empty());
+    ASSERT_FALSE(emitter.empty<BarEvent>());
+
+    emitter.erase(conn);
+
+    ASSERT_TRUE(emitter.empty());
+    ASSERT_TRUE(emitter.empty<BarEvent>());
+}

test/entt/signal/sigh.cpp

@@ -0,0 +1,251 @@
+#include <utility>
+#include <vector>
+#include <gtest/gtest.h>
+#include <entt/signal/sigh.hpp>
+
+struct SigHListener {
+    static void f(int &v) { v = 42; }
+
+    bool g(int) { k = !k; return true; }
+    bool h(int) { return k; }
+
+    void i() {}
+    void l() {}
+
+    bool k{false};
+};
+
+template<typename Ret>
+struct TestCollectAll {
+    std::vector<Ret> vec{};
+    static int f() { return 42; }
+    static int g() { return 42; }
+    bool operator()(Ret r) noexcept {
+        vec.push_back(r);
+        return true;
+    }
+};
+
+template<>
+struct TestCollectAll<void> {
+    std::vector<int> vec{};
+    static void h() {}
+    bool operator()() noexcept {
+        return true;
+    }
+};
+
+template<typename Ret>
+struct TestCollectFirst {
+    std::vector<Ret> vec{};
+    static int f() { return 42; }
+    bool operator()(Ret r) noexcept {
+        vec.push_back(r);
+        return false;
+    }
+};
+
+struct ConstNonConstNoExcept {
+    void f() { ++cnt; }
+    void g() noexcept { ++cnt; }
+    void h() const { ++cnt; }
+    void i() const noexcept { ++cnt; }
+    mutable int cnt{0};
+};
+
+TEST(SigH, Lifetime) {
+    using signal = entt::SigH<void(void)>;
+
+    ASSERT_NO_THROW(signal{});
+
+    signal src{}, other{};
+
+    ASSERT_NO_THROW(signal{src});
+    ASSERT_NO_THROW(signal{std::move(other)});
+    ASSERT_NO_THROW(src = other);
+    ASSERT_NO_THROW(src = std::move(other));
+
+    ASSERT_NO_THROW(delete new signal{});
+}
+
+TEST(SigH, Comparison) {
+    entt::SigH<void()> sig1;
+    entt::SigH<void()> sig2;
+
+    SigHListener s1;
+    SigHListener s2;
+
+    sig1.sink().connect<SigHListener, &SigHListener::i>(&s1);
+    sig2.sink().connect<SigHListener, &SigHListener::i>(&s2);
+
+    ASSERT_FALSE(sig1 == sig2);
+    ASSERT_TRUE(sig1 != sig2);
+
+    sig1.sink().disconnect<SigHListener, &SigHListener::i>(&s1);
+    sig2.sink().disconnect<SigHListener, &SigHListener::i>(&s2);
+
+    sig1.sink().connect<SigHListener, &SigHListener::i>(&s1);
+    sig2.sink().connect<SigHListener, &SigHListener::l>(&s1);
+
+    ASSERT_FALSE(sig1 == sig2);
+    ASSERT_TRUE(sig1 != sig2);
+
+    sig1.sink().disconnect<SigHListener, &SigHListener::i>(&s1);
+    sig2.sink().disconnect<SigHListener, &SigHListener::l>(&s1);
+
+    ASSERT_TRUE(sig1 == sig2);
+    ASSERT_FALSE(sig1 != sig2);
+
+    sig1.sink().connect<SigHListener, &SigHListener::i>(&s1);
+    sig1.sink().connect<SigHListener, &SigHListener::l>(&s1);
+    sig2.sink().connect<SigHListener, &SigHListener::i>(&s1);
+    sig2.sink().connect<SigHListener, &SigHListener::l>(&s1);
+
+    ASSERT_TRUE(sig1 == sig2);
+
+    sig1.sink().disconnect<SigHListener, &SigHListener::i>(&s1);
+    sig1.sink().disconnect<SigHListener, &SigHListener::l>(&s1);
+    sig2.sink().disconnect<SigHListener, &SigHListener::i>(&s1);
+    sig2.sink().disconnect<SigHListener, &SigHListener::l>(&s1);
+
+    sig1.sink().connect<SigHListener, &SigHListener::i>(&s1);
+    sig1.sink().connect<SigHListener, &SigHListener::l>(&s1);
+    sig2.sink().connect<SigHListener, &SigHListener::l>(&s1);
+    sig2.sink().connect<SigHListener, &SigHListener::i>(&s1);
+
+    ASSERT_FALSE(sig1 == sig2);
+}
+
+TEST(SigH, Clear) {
+    entt::SigH<void(int &)> sigh;
+    sigh.sink().connect<&SigHListener::f>();
+
+    ASSERT_FALSE(sigh.empty());
+
+    sigh.sink().disconnect();
+
+    ASSERT_TRUE(sigh.empty());
+}
+
+TEST(SigH, Swap) {
+    entt::SigH<void(int &)> sigh1;
+    entt::SigH<void(int &)> sigh2;
+
+    sigh1.sink().connect<&SigHListener::f>();
+
+    ASSERT_FALSE(sigh1.empty());
+    ASSERT_TRUE(sigh2.empty());
+
+    std::swap(sigh1, sigh2);
+
+    ASSERT_TRUE(sigh1.empty());
+    ASSERT_FALSE(sigh2.empty());
+}
+
+TEST(SigH, Functions) {
+    entt::SigH<void(int &)> sigh;
+    int v = 0;
+
+    sigh.sink().connect<&SigHListener::f>();
+    sigh.publish(v);
+
+    ASSERT_FALSE(sigh.empty());
+    ASSERT_EQ(static_cast<entt::SigH<bool(int)>::size_type>(1), sigh.size());
+    ASSERT_EQ(42, v);
+
+    v = 0;
+    sigh.sink().disconnect<&SigHListener::f>();
+    sigh.publish(v);
+
+    ASSERT_TRUE(sigh.empty());
+    ASSERT_EQ(static_cast<entt::SigH<bool(int)>::size_type>(0), sigh.size());
+    ASSERT_EQ(0, v);
+
+    sigh.sink().connect<&SigHListener::f>();
+}
+
+TEST(SigH, Members) {
+    SigHListener s;
+    SigHListener *ptr = &s;
+    entt::SigH<bool(int)> sigh;
+
+    sigh.sink().connect<SigHListener, &SigHListener::g>(ptr);
+    sigh.publish(42);
+
+    ASSERT_TRUE(s.k);
+    ASSERT_FALSE(sigh.empty());
+    ASSERT_EQ(static_cast<entt::SigH<bool(int)>::size_type>(1), sigh.size());
+
+    sigh.sink().disconnect<SigHListener, &SigHListener::g>(ptr);
+    sigh.publish(42);
+
+    ASSERT_TRUE(s.k);
+    ASSERT_TRUE(sigh.empty());
+    ASSERT_EQ(static_cast<entt::SigH<bool(int)>::size_type>(0), sigh.size());
+
+    sigh.sink().connect<SigHListener, &SigHListener::g>(ptr);
+    sigh.sink().connect<SigHListener, &SigHListener::h>(ptr);
+
+    ASSERT_FALSE(sigh.empty());
+    ASSERT_EQ(static_cast<entt::SigH<bool(int)>::size_type>(2), sigh.size());
+
+    sigh.sink().disconnect(ptr);
+
+    ASSERT_TRUE(sigh.empty());
+    ASSERT_EQ(static_cast<entt::SigH<bool(int)>::size_type>(0), sigh.size());
+}
+
+TEST(SigH, Collector) {
+    entt::SigH<void(), TestCollectAll<void>> sigh_void;
+
+    sigh_void.sink().connect<&TestCollectAll<void>::h>();
+    auto collector_void = sigh_void.collect();
+
+    ASSERT_FALSE(sigh_void.empty());
+    ASSERT_TRUE(collector_void.vec.empty());
+
+    entt::SigH<int(), TestCollectAll<int>> sigh_all;
+
+    sigh_all.sink().connect<&TestCollectAll<int>::f>();
+    sigh_all.sink().connect<&TestCollectAll<int>::f>();
+    sigh_all.sink().connect<&TestCollectAll<int>::g>();
+    auto collector_all = sigh_all.collect();
+
+    ASSERT_FALSE(sigh_all.empty());
+    ASSERT_FALSE(collector_all.vec.empty());
+    ASSERT_EQ(static_cast<std::vector<int>::size_type>(2), collector_all.vec.size());
+    ASSERT_EQ(42, collector_all.vec[0]);
+    ASSERT_EQ(42, collector_all.vec[1]);
+
+    entt::SigH<int(), TestCollectFirst<int>> sigh_first;
+
+    sigh_first.sink().connect<&TestCollectFirst<int>::f>();
+    sigh_first.sink().connect<&TestCollectFirst<int>::f>();
+    auto collector_first = sigh_first.collect();
+
+    ASSERT_FALSE(sigh_first.empty());
+    ASSERT_FALSE(collector_first.vec.empty());
+    ASSERT_EQ(static_cast<std::vector<int>::size_type>(1), collector_first.vec.size());
+    ASSERT_EQ(42, collector_first.vec[0]);
+}
+
+TEST(SigH, ConstNonConstNoExcept) {
+    entt::SigH<void()> sigh;
+    ConstNonConstNoExcept functor;
+
+    sigh.sink().connect<ConstNonConstNoExcept, &ConstNonConstNoExcept::f>(&functor);
+    sigh.sink().connect<ConstNonConstNoExcept, &ConstNonConstNoExcept::g>(&functor);
+    sigh.sink().connect<ConstNonConstNoExcept, &ConstNonConstNoExcept::h>(&functor);
+    sigh.sink().connect<ConstNonConstNoExcept, &ConstNonConstNoExcept::i>(&functor);
+    sigh.publish();
+
+    ASSERT_EQ(functor.cnt, 4);
+
+    sigh.sink().disconnect<ConstNonConstNoExcept, &ConstNonConstNoExcept::f>(&functor);
+    sigh.sink().disconnect<ConstNonConstNoExcept, &ConstNonConstNoExcept::g>(&functor);
+    sigh.sink().disconnect<ConstNonConstNoExcept, &ConstNonConstNoExcept::h>(&functor);
+    sigh.sink().disconnect<ConstNonConstNoExcept, &ConstNonConstNoExcept::i>(&functor);
+    sigh.publish();
+
+    ASSERT_EQ(functor.cnt, 4);
+}

test/ident.cpp

@@ -1,26 +0,0 @@
-#include <gtest/gtest.h>
-#include <ident.hpp>
-
-struct A {};
-struct B {};
-
-TEST(Identifier, Uniqueness) {
-    constexpr auto ID = entt::ident<A, B>;
-    constexpr A a;
-    constexpr B b;
-
-    ASSERT_NE(ID.get<A>(), ID.get<B>());
-    ASSERT_EQ(ID.get<A>(), ID.get<decltype(a)>());
-    ASSERT_NE(ID.get<A>(), ID.get<decltype(b)>());
-    ASSERT_EQ(ID.get<A>(), ID.get<A>());
-    ASSERT_EQ(ID.get<B>(), ID.get<B>());
-
-    // test uses in constant expressions
-    switch(ID.get<B>()) {
-    case ID.get<A>():
-        FAIL();
-        break;
-    case ID.get<B>():
-        SUCCEED();
-    }
-}

test/mod/mod.cpp

@@ -0,0 +1,436 @@
+#include <gtest/gtest.h>
+#include <cassert>
+#include <map>
+#include <string>
+#include <duktape.h>
+#include <entt/entity/registry.hpp>
+
+template<typename Type>
+struct tag { using type = Type; };
+
+struct Position {
+    double x;
+    double y;
+};
+
+struct Renderable {};
+
+struct DuktapeRuntime {
+    std::map<duk_uint_t, std::string> components;
+};
+
+template<typename Comp>
+duk_ret_t set(duk_context *ctx, entt::DefaultRegistry &registry) {
+    const auto entity = duk_require_uint(ctx, 0);
+    registry.accommodate<Comp>(entity);
+    return 0;
+}
+
+template<>
+duk_ret_t set<Position>(duk_context *ctx, entt::DefaultRegistry &registry) {
+    const auto entity = duk_require_uint(ctx, 0);
+    const auto x = duk_require_number(ctx, 2);
+    const auto y = duk_require_number(ctx, 3);
+    registry.accommodate<Position>(entity, x, y);
+    return 0;
+}
+
+template<>
+duk_ret_t set<DuktapeRuntime>(duk_context *ctx, entt::DefaultRegistry &registry) {
+    const auto entity = duk_require_uint(ctx, 0);
+    const auto type = duk_require_uint(ctx, 1);
+
+    duk_dup(ctx, 2);
+
+    if(!registry.has<DuktapeRuntime>(entity)) {
+        registry.assign<DuktapeRuntime>(entity).components[type] = duk_json_encode(ctx, -1);
+    } else {
+        registry.get<DuktapeRuntime>(entity).components[type] = duk_json_encode(ctx, -1);
+    }
+
+    duk_pop(ctx);
+
+    return 0;
+}
+
+template<typename Comp>
+duk_ret_t unset(duk_context *ctx, entt::DefaultRegistry &registry) {
+    const auto entity = duk_require_uint(ctx, 0);
+    registry.remove<Comp>(entity);
+    return 0;
+}
+
+template<>
+duk_ret_t unset<DuktapeRuntime>(duk_context *ctx, entt::DefaultRegistry &registry) {
+    const auto entity = duk_require_uint(ctx, 0);
+    const auto type = duk_require_uint(ctx, 1);
+
+    auto &components = registry.get<DuktapeRuntime>(entity).components;
+    assert(components.find(type) != components.cend());
+    components.erase(type);
+
+    if(components.empty()) {
+        registry.remove<DuktapeRuntime>(entity);
+    }
+
+    return 0;
+}
+
+template<typename Comp>
+duk_ret_t has(duk_context *ctx, entt::DefaultRegistry &registry) {
+    const auto entity = duk_require_uint(ctx, 0);
+    duk_push_boolean(ctx, registry.has<Comp>(entity));
+    return 1;
+}
+
+template<>
+duk_ret_t has<DuktapeRuntime>(duk_context *ctx, entt::DefaultRegistry &registry) {
+    const auto entity = duk_require_uint(ctx, 0);
+    duk_push_boolean(ctx, registry.has<DuktapeRuntime>(entity));
+
+    if(registry.has<DuktapeRuntime>(entity)) {
+        const auto type = duk_require_uint(ctx, 1);
+        const auto &components = registry.get<DuktapeRuntime>(entity).components;
+        duk_push_boolean(ctx, components.find(type) != components.cend());
+    } else {
+        duk_push_false(ctx);
+    }
+
+    return 1;
+}
+
+template<typename Comp>
+duk_ret_t get(duk_context *ctx, entt::DefaultRegistry &registry) {
+    assert(registry.has<Comp>(duk_require_uint(ctx, 0)));
+    duk_push_object(ctx);
+    return 1;
+}
+
+template<>
+duk_ret_t get<Position>(duk_context *ctx, entt::DefaultRegistry &registry) {
+    const auto entity = duk_require_uint(ctx, 0);
+    const auto &position = registry.get<Position>(entity);
+
+    const auto idx = duk_push_object(ctx);
+
+    duk_push_string(ctx, "x");
+    duk_push_number(ctx, position.x);
+    duk_def_prop(ctx, idx, DUK_DEFPROP_HAVE_VALUE);
+
+    duk_push_string(ctx, "y");
+    duk_push_number(ctx, position.y);
+    duk_def_prop(ctx, idx, DUK_DEFPROP_HAVE_VALUE);
+
+    return 1;
+}
+
+template<>
+duk_ret_t get<DuktapeRuntime>(duk_context *ctx, entt::DefaultRegistry &registry) {
+    const auto entity = duk_require_uint(ctx, 0);
+    const auto type = duk_require_uint(ctx, 1);
+
+    auto &runtime = registry.get<DuktapeRuntime>(entity);
+    assert(runtime.components.find(type) != runtime.components.cend());
+
+    duk_push_string(ctx, runtime.components[type].c_str());
+    duk_json_decode(ctx, -1);
+
+    return 1;
+}
+
+class DuktapeRegistry {
+    // I'm pretty sure I won't have more than 99 components in the example
+    static constexpr entt::DefaultRegistry::component_type udef = 100;
+
+    struct Func {
+        using func_type = duk_ret_t(*)(duk_context *, entt::DefaultRegistry &);
+        using test_type = bool(entt::DefaultRegistry:: *)(entt::DefaultRegistry::entity_type) const;
+
+        func_type set;
+        func_type unset;
+        func_type has;
+        func_type get;
+        test_type test;
+    };
+
+    template<typename... Comp>
+    void reg() {
+        using accumulator_type = int[];
+        accumulator_type acc = { (func[registry.type<Comp>()] = {
+                                     &::set<Comp>,
+                                     &::unset<Comp>,
+                                     &::has<Comp>,
+                                     &::get<Comp>,
+                                     &entt::DefaultRegistry::has<Comp>
+                                 }, 0)... };
+        (void)acc;
+    }
+
+    static DuktapeRegistry & instance(duk_context *ctx) {
+        duk_push_this(ctx);
+
+        duk_push_string(ctx, DUK_HIDDEN_SYMBOL("dreg"));
+        duk_get_prop(ctx, -2);
+        auto &dreg = *static_cast<DuktapeRegistry *>(duk_require_pointer(ctx, -1));
+        duk_pop_2(ctx);
+
+        return dreg;
+    }
+
+    template<Func::func_type Func::*Op>
+    static duk_ret_t invoke(duk_context *ctx) {
+        auto &dreg = instance(ctx);
+        auto &func = dreg.func;
+        auto &registry = dreg.registry;
+        auto type = duk_require_uint(ctx, 1);
+
+        if(type >= udef) {
+            type = registry.type<DuktapeRuntime>();
+        }
+
+        assert(func.find(type) != func.cend());
+
+        return (func[type].*Op)(ctx, registry);
+    }
+
+public:
+    DuktapeRegistry(entt::DefaultRegistry &registry)
+        : registry{registry}
+    {
+        reg<Position, Renderable, DuktapeRuntime>();
+    }
+
+    static duk_ret_t identifier(duk_context *ctx) {
+        static auto next = udef;
+        duk_push_uint(ctx, next++);
+        return 1;
+    }
+
+    static duk_ret_t create(duk_context *ctx) {
+        auto &dreg = instance(ctx);
+        duk_push_uint(ctx, dreg.registry.create());
+        return 1;
+    }
+
+    static duk_ret_t set(duk_context *ctx) {
+        return invoke<&Func::set>(ctx);
+    }
+
+    static duk_ret_t unset(duk_context *ctx) {
+        return invoke<&Func::unset>(ctx);
+    }
+
+    static duk_ret_t has(duk_context *ctx) {
+        return invoke<&Func::has>(ctx);
+    }
+
+    static duk_ret_t get(duk_context *ctx) {
+        return invoke<&Func::get>(ctx);
+    }
+
+    static duk_ret_t entities(duk_context *ctx) {
+        const duk_idx_t nargs = duk_get_top(ctx);
+        auto &dreg = instance(ctx);
+        duk_uarridx_t pos = 0;
+
+        duk_push_array(ctx);
+
+        std::vector<typename entt::DefaultRegistry::component_type> components;
+        std::vector<typename entt::DefaultRegistry::component_type> runtime;
+
+        for(duk_idx_t arg = 0; arg < nargs; arg++) {
+            auto type = duk_require_uint(ctx, arg);
+
+            if(type < udef) {
+                components.push_back(type);
+            } else {
+                if(runtime.empty()) {
+                    components.push_back(dreg.registry.type<DuktapeRuntime>());
+                }
+
+                runtime.push_back(type);
+            }
+        }
+
+        auto view = dreg.registry.view(components.cbegin(), components.cend());
+
+        for(const auto entity: view) {
+            if(runtime.empty()) {
+                duk_push_uint(ctx, entity);
+                duk_put_prop_index(ctx, -2, pos++);
+            } else {
+                const auto &components = dreg.registry.get<DuktapeRuntime>(entity).components;
+                const auto match = std::all_of(runtime.cbegin(), runtime.cend(), [&components](const auto type) {
+                    return components.find(type) != components.cend();
+                });
+
+                if(match) {
+                    duk_push_uint(ctx, entity);
+                    duk_put_prop_index(ctx, -2, pos++);
+                }
+            }
+        }
+
+        return 1;
+    }
+
+private:
+    std::map<duk_uint_t, Func> func;
+    entt::DefaultRegistry &registry;
+};
+
+const duk_function_list_entry js_DuktapeRegistry_methods[] = {
+    { "identifier", &DuktapeRegistry::identifier, 0 },
+    { "create", &DuktapeRegistry::create, 0 },
+    { "set", &DuktapeRegistry::set, DUK_VARARGS },
+    { "unset", &DuktapeRegistry::unset, 2 },
+    { "has", &DuktapeRegistry::has, 2 },
+    { "get", &DuktapeRegistry::get, 2 },
+    { "entities", &DuktapeRegistry::entities, DUK_VARARGS },
+    { nullptr, nullptr, 0 }
+};
+
+void exportTypes(duk_context *ctx, entt::DefaultRegistry &registry) {
+    auto exportType = [](auto *ctx, auto &registry, auto idx, auto type, const auto *name) {
+        duk_push_string(ctx, name);
+        duk_push_uint(ctx, registry.template type<typename decltype(type)::type>());
+        duk_def_prop(ctx, idx, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_CLEAR_WRITABLE);
+    };
+
+    auto idx = duk_push_object(ctx);
+
+    exportType(ctx, registry, idx, tag<Position>{}, "POSITION");
+    exportType(ctx, registry, idx, tag<Renderable>{}, "RENDERABLE");
+
+    duk_put_global_string(ctx, "Types");
+}
+
+void exportDuktapeRegistry(duk_context *ctx, DuktapeRegistry &dreg) {
+    auto idx = duk_push_object(ctx);
+
+    duk_push_string(ctx, DUK_HIDDEN_SYMBOL("dreg"));
+    duk_push_pointer(ctx, &dreg);
+    duk_put_prop(ctx, idx);
+
+    duk_put_function_list(ctx, idx, js_DuktapeRegistry_methods);
+    duk_put_global_string(ctx, "Registry");
+}
+
+TEST(Mod, Duktape) {
+    entt::DefaultRegistry registry;
+    DuktapeRegistry dreg{registry};
+    duk_context *ctx = duk_create_heap_default();
+
+    if(!ctx) {
+        FAIL();
+    }
+
+    exportTypes(ctx, registry);
+    exportDuktapeRegistry(ctx, dreg);
+
+    const char *s0 = ""
+            "Types[\"PLAYING_CHARACTER\"] = Registry.identifier();"
+            "Types[\"VELOCITY\"] = Registry.identifier();"
+            "";
+
+    if(duk_peval_string(ctx, s0)) {
+        FAIL();
+    }
+
+    const auto e0 = registry.create();
+    registry.assign<Position>(e0, 0., 0.);
+    registry.assign<Renderable>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<Position>(e1, 0., 0.);
+
+    const char *s1 = ""
+            "Registry.entities(Types.POSITION, Types.RENDERABLE).forEach(function(entity) {"
+                "Registry.set(entity, Types.POSITION, 100., 100.);"
+            "});"
+            "var entity = Registry.create();"
+            "Registry.set(entity, Types.POSITION, 100., 100.);"
+            "Registry.set(entity, Types.RENDERABLE);"
+            "";
+
+    if(duk_peval_string(ctx, s1)) {
+        FAIL();
+    }
+
+    ASSERT_EQ(registry.view<DuktapeRuntime>().size(), 0u);
+    ASSERT_EQ(registry.view<Position>().size(), 3u);
+    ASSERT_EQ(registry.view<Renderable>().size(), 2u);
+
+    registry.view<Position>().each([&registry](auto entity, const auto &position) {
+        ASSERT_FALSE(registry.has<DuktapeRuntime>(entity));
+
+        if(registry.has<Renderable>(entity)) {
+            ASSERT_EQ(position.x, 100.);
+            ASSERT_EQ(position.y, 100.);
+        } else {
+            ASSERT_EQ(position.x, 0.);
+            ASSERT_EQ(position.y, 0.);
+        }
+    });
+
+    const char *s2 = ""
+            "Registry.entities(Types.POSITION).forEach(function(entity) {"
+                "if(!Registry.has(entity, Types.RENDERABLE)) {"
+                    "Registry.set(entity, Types.VELOCITY, { \"dx\": -100., \"dy\": -100. });"
+                    "Registry.set(entity, Types.PLAYING_CHARACTER, {});"
+                "}"
+            "});"
+            "";
+
+    if(duk_peval_string(ctx, s2)) {
+        FAIL();
+    }
+
+    ASSERT_EQ(registry.view<DuktapeRuntime>().size(), 1u);
+    ASSERT_EQ(registry.view<Position>().size(), 3u);
+    ASSERT_EQ(registry.view<Renderable>().size(), 2u);
+
+    registry.view<DuktapeRuntime>().each([](auto, const DuktapeRuntime &runtime) {
+        ASSERT_EQ(runtime.components.size(), 2u);
+    });
+
+    const char *s3 = ""
+            "Registry.entities(Types.POSITION, Types.RENDERABLE, Types.VELOCITY, Types.PLAYING_CHARACTER).forEach(function(entity) {"
+                "var velocity = Registry.get(entity, Types.VELOCITY);"
+                "Registry.set(entity, Types.POSITION, velocity.dx, velocity.dy)"
+            "});"
+            "";
+
+    if(duk_peval_string(ctx, s3)) {
+        FAIL();
+    }
+
+    ASSERT_EQ(registry.view<DuktapeRuntime>().size(), 1u);
+    ASSERT_EQ(registry.view<Position>().size(), 3u);
+    ASSERT_EQ(registry.view<Renderable>().size(), 2u);
+
+    registry.view<Position, Renderable, DuktapeRuntime>().each([](auto, const Position &position, const auto &...) {
+        ASSERT_EQ(position.x, -100.);
+        ASSERT_EQ(position.y, -100.);
+    });
+
+    const char *s4 = ""
+            "Registry.entities(Types.VELOCITY, Types.PLAYING_CHARACTER).forEach(function(entity) {"
+                "Registry.unset(entity, Types.VELOCITY);"
+                "Registry.unset(entity, Types.PLAYING_CHARACTER);"
+            "});"
+            "Registry.entities(Types.POSITION).forEach(function(entity) {"
+                "Registry.unset(entity, Types.POSITION);"
+            "});"
+            "";
+
+    if(duk_peval_string(ctx, s4)) {
+        FAIL();
+    }
+
+    ASSERT_EQ(registry.view<DuktapeRuntime>().size(), 0u);
+    ASSERT_EQ(registry.view<Position>().size(), 0u);
+    ASSERT_EQ(registry.view<Renderable>().size(), 2u);
+
+    duk_destroy_heap(ctx);
+}

test/odr.cpp

@@ -0,0 +1 @@
+#include <entt/entt.hpp>

test/registry.cpp

@@ -1,357 +0,0 @@
-#include <gtest/gtest.h>
-#include <registry.hpp>
-#include <functional>
-
-TEST(DefaultRegistry, Functionalities) {
-    using registry_type = entt::DefaultRegistry<int, char>;
-
-    registry_type registry;
-
-    ASSERT_EQ(registry.size(), registry_type::size_type{0});
-    ASSERT_EQ(registry.capacity(), registry_type::size_type{0});
-    ASSERT_TRUE(registry.empty());
-
-    ASSERT_EQ(registry.size<int>(), registry_type::size_type{0});
-    ASSERT_EQ(registry.size<char>(), registry_type::size_type{0});
-    ASSERT_EQ(registry.capacity<int>(), registry_type::size_type{0});
-    ASSERT_EQ(registry.capacity<char>(), registry_type::size_type{0});
-    ASSERT_TRUE(registry.empty<int>());
-    ASSERT_TRUE(registry.empty<char>());
-
-    registry_type::entity_type e1 = registry.create();
-    registry_type::entity_type e2 = registry.create<int, char>();
-
-    ASSERT_EQ(registry.size<int>(), registry_type::size_type{1});
-    ASSERT_EQ(registry.size<char>(), registry_type::size_type{1});
-    ASSERT_GE(registry.capacity<int>(), registry_type::size_type{1});
-    ASSERT_GE(registry.capacity<char>(), registry_type::size_type{1});
-    ASSERT_FALSE(registry.empty<int>());
-    ASSERT_FALSE(registry.empty<char>());
-
-    ASSERT_NE(e1, e2);
-
-    ASSERT_FALSE(registry.has<int>(e1));
-    ASSERT_TRUE(registry.has<int>(e2));
-    ASSERT_FALSE(registry.has<char>(e1));
-    ASSERT_TRUE(registry.has<char>(e2));
-    ASSERT_TRUE((registry.has<int, char>(e2)));
-    ASSERT_FALSE((registry.has<int, char>(e1)));
-
-    ASSERT_EQ(registry.assign<int>(e1, 42), 42);
-    ASSERT_EQ(registry.assign<char>(e1, 'c'), 'c');
-    ASSERT_NO_THROW(registry.remove<int>(e2));
-    ASSERT_NO_THROW(registry.remove<char>(e2));
-
-    ASSERT_TRUE(registry.has<int>(e1));
-    ASSERT_FALSE(registry.has<int>(e2));
-    ASSERT_TRUE(registry.has<char>(e1));
-    ASSERT_FALSE(registry.has<char>(e2));
-    ASSERT_TRUE((registry.has<int, char>(e1)));
-    ASSERT_FALSE((registry.has<int, char>(e2)));
-
-    registry_type::entity_type e3 = registry.clone(e1);
-
-    ASSERT_TRUE(registry.has<int>(e3));
-    ASSERT_TRUE(registry.has<char>(e3));
-    ASSERT_EQ(registry.get<int>(e1), 42);
-    ASSERT_EQ(registry.get<char>(e1), 'c');
-    ASSERT_EQ(registry.get<int>(e1), registry.get<int>(e3));
-    ASSERT_EQ(registry.get<char>(e1), registry.get<char>(e3));
-    ASSERT_NE(&registry.get<int>(e1), &registry.get<int>(e3));
-    ASSERT_NE(&registry.get<char>(e1), &registry.get<char>(e3));
-
-    ASSERT_NO_THROW(registry.copy(e2, e1));
-    ASSERT_TRUE(registry.has<int>(e2));
-    ASSERT_TRUE(registry.has<char>(e2));
-    ASSERT_EQ(registry.get<int>(e1), 42);
-    ASSERT_EQ(registry.get<char>(e1), 'c');
-    ASSERT_EQ(registry.get<int>(e1), registry.get<int>(e2));
-    ASSERT_EQ(registry.get<char>(e1), registry.get<char>(e2));
-    ASSERT_NE(&registry.get<int>(e1), &registry.get<int>(e2));
-    ASSERT_NE(&registry.get<char>(e1), &registry.get<char>(e2));
-
-    ASSERT_NO_THROW(registry.replace<int>(e1, 0));
-    ASSERT_EQ(registry.get<int>(e1), 0);
-    ASSERT_NO_THROW(registry.copy<int>(e2, e1));
-    ASSERT_EQ(registry.get<int>(e2), 0);
-    ASSERT_NE(&registry.get<int>(e1), &registry.get<int>(e2));
-
-    ASSERT_NO_THROW(registry.remove<int>(e2));
-    ASSERT_NO_THROW(registry.accomodate<int>(e1, 1));
-    ASSERT_NO_THROW(registry.accomodate<int>(e2, 1));
-    ASSERT_EQ(static_cast<const registry_type &>(registry).get<int>(e1), 1);
-    ASSERT_EQ(static_cast<const registry_type &>(registry).get<int>(e2), 1);
-
-    ASSERT_EQ(registry.size(), registry_type::size_type{3});
-    ASSERT_EQ(registry.capacity(), registry_type::size_type{3});
-    ASSERT_FALSE(registry.empty());
-
-    ASSERT_NO_THROW(registry.destroy(e3));
-
-    ASSERT_TRUE(registry.valid(e1));
-    ASSERT_TRUE(registry.valid(e2));
-    ASSERT_FALSE(registry.valid(e3));
-
-    ASSERT_EQ(registry.size(), registry_type::size_type{2});
-    ASSERT_EQ(registry.capacity(), registry_type::size_type{3});
-    ASSERT_FALSE(registry.empty());
-
-    ASSERT_NO_THROW(registry.reset());
-
-    ASSERT_EQ(registry.size(), registry_type::size_type{0});
-    ASSERT_EQ(registry.capacity(), registry_type::size_type{0});
-    ASSERT_TRUE(registry.empty());
-
-    registry.create<int, char>();
-
-    ASSERT_EQ(registry.size<int>(), registry_type::size_type{1});
-    ASSERT_EQ(registry.size<char>(), registry_type::size_type{1});
-    ASSERT_GE(registry.capacity<int>(), registry_type::size_type{1});
-    ASSERT_GE(registry.capacity<char>(), registry_type::size_type{1});
-    ASSERT_FALSE(registry.empty<int>());
-    ASSERT_FALSE(registry.empty<char>());
-
-    ASSERT_NO_THROW(registry.reset<int>());
-
-    ASSERT_EQ(registry.size<int>(), registry_type::size_type{0});
-    ASSERT_EQ(registry.size<char>(), registry_type::size_type{1});
-    ASSERT_GE(registry.capacity<int>(), registry_type::size_type{0});
-    ASSERT_GE(registry.capacity<char>(), registry_type::size_type{1});
-    ASSERT_TRUE(registry.empty<int>());
-    ASSERT_FALSE(registry.empty<char>());
-
-    ASSERT_NO_THROW(registry.reset());
-
-    ASSERT_EQ(registry.size<int>(), registry_type::size_type{0});
-    ASSERT_EQ(registry.size<char>(), registry_type::size_type{0});
-    ASSERT_GE(registry.capacity<int>(), registry_type::size_type{0});
-    ASSERT_GE(registry.capacity<char>(), registry_type::size_type{1});
-    ASSERT_TRUE(registry.empty<int>());
-    ASSERT_TRUE(registry.empty<char>());
-
-    e1 = registry.create<int>();
-    e2 = registry.create();
-
-    ASSERT_NO_THROW(registry.reset<int>(e1));
-    ASSERT_NO_THROW(registry.reset<int>(e2));
-
-    ASSERT_EQ(registry.size<int>(), registry_type::size_type{0});
-    ASSERT_EQ(registry.size<char>(), registry_type::size_type{0});
-    ASSERT_GE(registry.capacity<int>(), registry_type::size_type{0});
-    ASSERT_GE(registry.capacity<char>(), registry_type::size_type{0});
-    ASSERT_TRUE(registry.empty<int>());
-}
-
-TEST(DefaultRegistry, Copy) {
-    using registry_type = entt::DefaultRegistry<int, char, double>;
-
-    registry_type registry;
-
-    registry_type::entity_type e1 = registry.create<int, char>();
-    registry_type::entity_type e2 = registry.create<int, double>();
-
-    ASSERT_TRUE(registry.has<int>(e1));
-    ASSERT_TRUE(registry.has<char>(e1));
-    ASSERT_FALSE(registry.has<double>(e1));
-
-    ASSERT_TRUE(registry.has<int>(e2));
-    ASSERT_FALSE(registry.has<char>(e2));
-    ASSERT_TRUE(registry.has<double>(e2));
-
-    ASSERT_NO_THROW(registry.copy(e2, e1));
-
-    ASSERT_TRUE(registry.has<int>(e1));
-    ASSERT_TRUE(registry.has<char>(e1));
-    ASSERT_FALSE(registry.has<double>(e1));
-
-    ASSERT_TRUE(registry.has<int>(e2));
-    ASSERT_TRUE(registry.has<char>(e2));
-    ASSERT_FALSE(registry.has<double>(e2));
-
-    ASSERT_FALSE(registry.empty<int>());
-    ASSERT_FALSE(registry.empty<char>());
-    ASSERT_TRUE(registry.empty<double>());
-
-    registry.reset();
-}
-
-TEST(DefaultRegistry, Swap) {
-    using registry_type = entt::DefaultRegistry<int, char>;
-
-    registry_type registry;
-
-    registry_type::entity_type e1 = registry.create<int, char>();
-    registry_type::entity_type e2 = registry.create<int, char>();
-
-    registry.get<int>(e1) = 0;
-    registry.get<char>(e1) = 'a';
-    registry.get<int>(e2) = 1;
-    registry.get<char>(e2) = 'b';
-
-    registry.swap<int>(e1, e2);
-
-    ASSERT_EQ(registry.get<int>(e1), 1);
-    ASSERT_EQ(registry.get<char>(e1), 'a');
-    ASSERT_EQ(registry.get<int>(e2), 0);
-    ASSERT_EQ(registry.get<char>(e2), 'b');
-
-    registry.reset();
-}
-
-TEST(DefaultRegistry, SortSingle) {
-    using registry_type = entt::DefaultRegistry<int>;
-
-    registry_type registry;
-
-    registry_type::entity_type e1 = registry.create();
-    registry_type::entity_type e2 = registry.create();
-    registry_type::entity_type e3 = registry.create();
-
-    auto val = 0;
-
-    registry.assign<int>(e1, val++);
-    registry.assign<int>(e2, val++);
-    registry.assign<int>(e3, val++);
-
-    for(auto entity: registry.view<int>()) {
-        ASSERT_EQ(registry.get<int>(entity), --val);
-    }
-
-    registry.sort<int>(std::less<int>{});
-
-    for(auto entity: registry.view<int>()) {
-        ASSERT_EQ(registry.get<int>(entity), val++);
-    }
-
-    registry.reset();
-}
-
-TEST(DefaultRegistry, SortMulti) {
-    using registry_type = entt::DefaultRegistry<int, unsigned int>;
-
-    registry_type registry;
-
-    registry_type::entity_type e1 = registry.create();
-    registry_type::entity_type e2 = registry.create();
-    registry_type::entity_type e3 = registry.create();
-
-    auto uval = 0u;
-    auto ival = 0;
-
-    registry.assign<unsigned int>(e1, uval++);
-    registry.assign<unsigned int>(e2, uval++);
-    registry.assign<unsigned int>(e3, uval++);
-
-    registry.assign<int>(e1, ival++);
-    registry.assign<int>(e2, ival++);
-    registry.assign<int>(e3, ival++);
-
-    for(auto entity: registry.view<unsigned int>()) {
-        ASSERT_EQ(registry.get<unsigned int>(entity), --uval);
-    }
-
-    for(auto entity: registry.view<int>()) {
-        ASSERT_EQ(registry.get<int>(entity), --ival);
-    }
-
-    registry.sort<unsigned int>(std::less<unsigned int>{});
-    registry.sort<int, unsigned int>();
-
-    for(auto entity: registry.view<unsigned int>()) {
-        ASSERT_EQ(registry.get<unsigned int>(entity), uval++);
-    }
-
-    for(auto entity: registry.view<int>()) {
-        ASSERT_EQ(registry.get<int>(entity), ival++);
-    }
-
-    registry.reset();
-}
-
-TEST(DefaultRegistry, ViewSingleComponent) {
-    using registry_type = entt::DefaultRegistry<int, char>;
-
-    registry_type registry;
-
-    registry_type::entity_type e1 = registry.create();
-    registry_type::entity_type e2 = registry.create<int, char>();
-
-    ASSERT_NO_THROW(registry.view<char>().begin()++);
-    ASSERT_NO_THROW(++registry.view<char>().begin());
-
-    auto view = registry.view<char>();
-
-    ASSERT_NE(view.begin(), view.end());
-    ASSERT_EQ(view.size(), typename decltype(view)::size_type{1});
-
-    registry.assign<char>(e1);
-
-    ASSERT_EQ(view.size(), typename decltype(view)::size_type{2});
-
-    registry.remove<char>(e1);
-    registry.remove<char>(e2);
-
-    ASSERT_EQ(view.begin(), view.end());
-    ASSERT_NO_THROW(registry.reset());
-}
-
-TEST(DefaultRegistry, ViewMultipleComponent) {
-    using registry_type = entt::DefaultRegistry<int, char>;
-
-    registry_type registry;
-
-    registry_type::entity_type e1 = registry.create<char>();
-    registry_type::entity_type e2 = registry.create<int, char>();
-
-    ASSERT_NO_THROW((registry.view<int, char>().begin()++));
-    ASSERT_NO_THROW((++registry.view<int, char>().begin()));
-
-    auto view = registry.view<int, char>();
-
-    ASSERT_NE(view.begin(), view.end());
-
-    registry.remove<char>(e1);
-    registry.remove<char>(e2);
-    view.reset();
-
-    ASSERT_EQ(view.begin(), view.end());
-    ASSERT_NO_THROW(registry.reset());
-}
-
-TEST(DefaultRegistry, ViewSingleComponentEmpty) {
-    using registry_type = entt::DefaultRegistry<char, int, double>;
-
-    registry_type registry;
-
-    registry.create<char, double>();
-    registry.create<char>();
-
-    auto view = registry.view<int>();
-
-    ASSERT_EQ(view.size(), registry_type::size_type{0});
-
-    for(auto entity: view) {
-        (void)entity;
-        FAIL();
-    }
-
-    registry.reset();
-}
-
-TEST(DefaultRegistry, ViewMultipleComponentEmpty) {
-    using registry_type = entt::DefaultRegistry<char, int, float, double>;
-
-    registry_type registry;
-
-    registry.create<double, int, float>();
-    registry.create<char, float>();
-
-    auto view = registry.view<char, int, float>();
-
-    for(auto entity: view) {
-        (void)entity;
-        FAIL();
-    }
-
-    registry.reset();
-}

test/snapshot/snapshot.cpp

@@ -0,0 +1,181 @@
+#include <gtest/gtest.h>
+#include <sstream>
+#include <vector>
+#include <cereal/archives/json.hpp>
+#include <entt/entity/registry.hpp>
+
+struct Position {
+    float x;
+    float y;
+};
+
+struct Timer {
+    int duration;
+    int elapsed{0};
+};
+
+struct Relationship {
+    entt::DefaultRegistry::entity_type parent;
+};
+
+template<typename Archive>
+void serialize(Archive &archive, Position &position) {
+  archive(position.x, position.y);
+}
+
+template<typename Archive>
+void serialize(Archive &archive, Timer &timer) {
+  archive(timer.duration);
+}
+
+template<typename Archive>
+void serialize(Archive &archive, Relationship &relationship) {
+  archive(relationship.parent);
+}
+
+TEST(Snapshot, Full) {
+    std::stringstream storage;
+
+    entt::DefaultRegistry source;
+    entt::DefaultRegistry destination;
+
+    auto e0 = source.create();
+    source.assign<Position>(e0, 16.f, 16.f);
+
+    source.destroy(source.create());
+
+    auto e1 = source.create();
+    source.assign<Position>(e1, .8f, .0f);
+    source.assign<Relationship>(e1, e0);
+
+    auto e2 = source.create();
+
+    auto e3 = source.create();
+    source.assign<Timer>(e3, 1000, 100);
+
+    source.destroy(e2);
+    auto v2 = source.current(e2);
+
+    {
+        // output finishes flushing its contents when it goes out of scope
+        cereal::JSONOutputArchive output{storage};
+        source.snapshot().entities(output).destroyed(output)
+                .component<Position, Timer, Relationship>(output);
+    }
+
+    cereal::JSONInputArchive input{storage};
+    destination.restore().entities(input).destroyed(input)
+            .component<Position, Timer, Relationship>(input);
+
+    ASSERT_TRUE(destination.valid(e0));
+    ASSERT_TRUE(destination.has<Position>(e0));
+    ASSERT_EQ(destination.get<Position>(e0).x, 16.f);
+    ASSERT_EQ(destination.get<Position>(e0).y, 16.f);
+
+    ASSERT_TRUE(destination.valid(e1));
+    ASSERT_TRUE(destination.has<Position>(e1));
+    ASSERT_EQ(destination.get<Position>(e1).x, .8f);
+    ASSERT_EQ(destination.get<Position>(e1).y, .0f);
+    ASSERT_TRUE(destination.has<Relationship>(e1));
+    ASSERT_EQ(destination.get<Relationship>(e1).parent, e0);
+
+    ASSERT_FALSE(destination.valid(e2));
+    ASSERT_EQ(destination.current(e2), v2);
+
+    ASSERT_TRUE(destination.valid(e3));
+    ASSERT_TRUE(destination.has<Timer>(e3));
+    ASSERT_EQ(destination.get<Timer>(e3).duration, 1000);
+    ASSERT_EQ(destination.get<Timer>(e3).elapsed, 0);
+}
+
+TEST(Snapshot, Continuous) {
+    std::stringstream storage;
+
+    entt::DefaultRegistry source;
+    entt::DefaultRegistry destination;
+
+    std::vector<entt::DefaultRegistry::entity_type> entities;
+    for(auto i = 0; i < 10; ++i) {
+        entities.push_back(source.create());
+    }
+
+    for(auto entity: entities) {
+        source.destroy(entity);
+    }
+
+    auto e0 = source.create();
+    source.assign<Position>(e0, 0.f, 0.f);
+    source.assign<Relationship>(e0, e0);
+
+    auto e1 = source.create();
+    source.assign<Position>(e1, 1.f, 1.f);
+    source.assign<Relationship>(e1, e0);
+
+    auto e2 = source.create();
+    source.assign<Position>(e2, .2f, .2f);
+    source.assign<Relationship>(e2, e0);
+
+    auto e3 = source.create();
+    source.assign<Timer>(e3, 1000, 1000);
+    source.assign<Relationship>(e3, e2);
+
+    {
+        // output finishes flushing its contents when it goes out of scope
+        cereal::JSONOutputArchive output{storage};
+        source.snapshot().entities(output).component<Position, Relationship, Timer>(output);
+    }
+
+    cereal::JSONInputArchive input{storage};
+    entt::ContinuousLoader<entt::DefaultRegistry::entity_type> loader{destination};
+    loader.entities(input)
+            .component<Position, Relationship>(input, &Relationship::parent)
+            .component<Timer>(input);
+
+    ASSERT_FALSE(destination.valid(e0));
+    ASSERT_TRUE(loader.has(e0));
+
+    auto l0 = loader.map(e0);
+
+    ASSERT_TRUE(destination.valid(l0));
+    ASSERT_TRUE(destination.has<Position>(l0));
+    ASSERT_EQ(destination.get<Position>(l0).x, 0.f);
+    ASSERT_EQ(destination.get<Position>(l0).y, 0.f);
+    ASSERT_TRUE(destination.has<Relationship>(l0));
+    ASSERT_EQ(destination.get<Relationship>(l0).parent, l0);
+
+    ASSERT_FALSE(destination.valid(e1));
+    ASSERT_TRUE(loader.has(e1));
+
+    auto l1 = loader.map(e1);
+
+    ASSERT_TRUE(destination.valid(l1));
+    ASSERT_TRUE(destination.has<Position>(l1));
+    ASSERT_EQ(destination.get<Position>(l1).x, 1.f);
+    ASSERT_EQ(destination.get<Position>(l1).y, 1.f);
+    ASSERT_TRUE(destination.has<Relationship>(l1));
+    ASSERT_EQ(destination.get<Relationship>(l1).parent, l0);
+
+    ASSERT_FALSE(destination.valid(e2));
+    ASSERT_TRUE(loader.has(e2));
+
+    auto l2 = loader.map(e2);
+
+    ASSERT_TRUE(destination.valid(l2));
+    ASSERT_TRUE(destination.has<Position>(l2));
+    ASSERT_EQ(destination.get<Position>(l2).x, .2f);
+    ASSERT_EQ(destination.get<Position>(l2).y, .2f);
+    ASSERT_TRUE(destination.has<Relationship>(l2));
+    ASSERT_EQ(destination.get<Relationship>(l2).parent, l0);
+
+    ASSERT_FALSE(destination.valid(e3));
+    ASSERT_TRUE(loader.has(e3));
+
+    auto l3 = loader.map(e3);
+
+    ASSERT_TRUE(destination.valid(l3));
+    ASSERT_TRUE(destination.has<Timer>(l3));
+    ASSERT_EQ(destination.get<Timer>(l3).duration, 1000);
+    ASSERT_EQ(destination.get<Timer>(l3).elapsed, 0);
+    ASSERT_TRUE(destination.has<Relationship>(l3));
+    ASSERT_EQ(destination.get<Relationship>(l3).parent, l2);
+}

test/sparse_set.cpp

@@ -1,390 +0,0 @@
-#include <gtest/gtest.h>
-#include <sparse_set.hpp>
-
-TEST(SparseSetNoType, Functionalities) {
-    using SparseSet = entt::SparseSet<unsigned int>;
-
-    SparseSet set;
-
-    ASSERT_TRUE(set.empty());
-    ASSERT_EQ(set.size(), 0u);
-    ASSERT_EQ(set.capacity(), 0u);
-    ASSERT_EQ(set.begin(), set.end());
-    ASSERT_FALSE(set.has(0));
-    ASSERT_FALSE(set.has(42));
-
-    ASSERT_EQ(set.construct(42), 0u);
-
-    ASSERT_FALSE(set.empty());
-    ASSERT_EQ(set.size(), 1u);
-    ASSERT_GE(set.capacity(), 1u);
-    ASSERT_NE(set.begin(), set.end());
-    ASSERT_FALSE(set.has(0));
-    ASSERT_TRUE(set.has(42));
-    ASSERT_EQ(set.get(42), 0u);
-
-    ASSERT_EQ(set.destroy(42), 0u);
-
-    ASSERT_TRUE(set.empty());
-    ASSERT_EQ(set.size(), 0u);
-    ASSERT_GE(set.capacity(), 1u);
-    ASSERT_EQ(set.begin(), set.end());
-    ASSERT_FALSE(set.has(0));
-    ASSERT_FALSE(set.has(42));
-
-    ASSERT_EQ(set.construct(42), 0u);
-
-    set.reset();
-
-    ASSERT_TRUE(set.empty());
-    ASSERT_EQ(set.size(), 0u);
-    ASSERT_GE(set.capacity(), 0u);
-    ASSERT_EQ(set.begin(), set.end());
-    ASSERT_FALSE(set.has(0));
-    ASSERT_FALSE(set.has(42));
-}
-
-TEST(SparseSetNoType, DataBeginEnd) {
-    using SparseSet = entt::SparseSet<unsigned int>;
-
-    SparseSet set;
-
-    ASSERT_EQ(set.construct(3), 0u);
-    ASSERT_EQ(set.construct(12), 1u);
-    ASSERT_EQ(set.construct(42), 2u);
-
-    ASSERT_EQ(*(set.data() + 0u), 3u);
-    ASSERT_EQ(*(set.data() + 1u), 12u);
-    ASSERT_EQ(*(set.data() + 2u), 42u);
-
-    auto begin = set.begin();
-    auto end = set.end();
-
-    ASSERT_EQ(*(begin++), 42u);
-    ASSERT_EQ(*(begin++), 12u);
-    ASSERT_EQ(*(begin++), 3u);
-    ASSERT_EQ(begin, end);
-
-    set.reset();
-}
-
-TEST(SparseSetNoType, Swap) {
-    using SparseSet = entt::SparseSet<unsigned int>;
-
-    SparseSet set;
-
-    ASSERT_EQ(set.construct(3), 0u);
-    ASSERT_EQ(set.construct(12), 1u);
-
-    ASSERT_EQ(*(set.data() + 0u), 3u);
-    ASSERT_EQ(*(set.data() + 1u), 12u);
-
-    set.swap(3, 12);
-
-    ASSERT_EQ(*(set.data() + 0u), 12u);
-    ASSERT_EQ(*(set.data() + 1u), 3u);
-
-    set.reset();
-}
-
-TEST(SparseSetWithType, Functionalities) {
-    using SparseSet = entt::SparseSet<unsigned int, int>;
-
-    SparseSet set;
-
-    ASSERT_TRUE(set.empty());
-    ASSERT_EQ(set.size(), 0u);
-    ASSERT_EQ(set.capacity(), 0u);
-    ASSERT_EQ(set.begin(), set.end());
-    ASSERT_FALSE(set.has(0));
-    ASSERT_FALSE(set.has(42));
-
-    ASSERT_EQ(set.construct(42, 3), 3);
-
-    ASSERT_FALSE(set.empty());
-    ASSERT_EQ(set.size(), 1u);
-    ASSERT_GE(set.capacity(), 1u);
-    ASSERT_NE(set.begin(), set.end());
-    ASSERT_FALSE(set.has(0));
-    ASSERT_TRUE(set.has(42));
-    ASSERT_EQ(set.get(42), 3);
-
-    set.destroy(42);
-
-    ASSERT_TRUE(set.empty());
-    ASSERT_EQ(set.size(), 0u);
-    ASSERT_GE(set.capacity(), 1u);
-    ASSERT_EQ(set.begin(), set.end());
-    ASSERT_FALSE(set.has(0));
-    ASSERT_FALSE(set.has(42));
-
-    ASSERT_EQ(set.construct(42, 12), 12);
-
-    set.reset();
-
-    ASSERT_TRUE(set.empty());
-    ASSERT_EQ(set.size(), 0u);
-    ASSERT_GE(set.capacity(), 0u);
-    ASSERT_EQ(set.begin(), set.end());
-    ASSERT_FALSE(set.has(0));
-    ASSERT_FALSE(set.has(42));
-}
-
-TEST(SparseSetWithType, RawBeginEnd) {
-    using SparseSet = entt::SparseSet<unsigned int, int>;
-
-    SparseSet set;
-
-    ASSERT_EQ(set.construct(3, 3), 3);
-    ASSERT_EQ(set.construct(12, 6), 6);
-    ASSERT_EQ(set.construct(42, 9), 9);
-
-    ASSERT_EQ(*(set.raw() + 0u), 3);
-    ASSERT_EQ(*(set.raw() + 1u), 6);
-    ASSERT_EQ(*(set.raw() + 2u), 9);
-
-    auto begin = set.begin();
-    auto end = set.end();
-
-    ASSERT_EQ(set.get(*(begin++)), 9);
-    ASSERT_EQ(set.get(*(begin++)), 6);
-    ASSERT_EQ(set.get(*(begin++)), 3);
-    ASSERT_EQ(begin, end);
-
-    set.reset();
-}
-
-TEST(SparseSetWithType, Swap) {
-    using SparseSet = entt::SparseSet<unsigned int, int>;
-
-    SparseSet set;
-
-    ASSERT_EQ(set.construct(3, 3), 3);
-    ASSERT_EQ(set.construct(12, 6), 6);
-
-    ASSERT_EQ(*(set.raw() + 0u), 3);
-    ASSERT_EQ(*(set.raw() + 1u), 6);
-
-    set.swap(3, 12);
-
-    ASSERT_EQ(*(set.raw() + 0u), 6);
-    ASSERT_EQ(*(set.raw() + 1u), 3);
-
-    set.reset();
-}
-
-TEST(SparseSetWithType, SortOrdered) {
-    using SparseSet = entt::SparseSet<unsigned int, int>;
-
-    SparseSet set;
-
-    ASSERT_EQ(set.construct(12, 12), 12);
-    ASSERT_EQ(set.construct(42, 9), 9);
-    ASSERT_EQ(set.construct(7, 6), 6);
-    ASSERT_EQ(set.construct(3, 3), 3);
-    ASSERT_EQ(set.construct(9, 1), 1);
-
-    set.sort([](auto lhs, auto rhs) {
-        return lhs < rhs;
-    });
-
-    ASSERT_EQ(*(set.raw() + 0u), 12);
-    ASSERT_EQ(*(set.raw() + 1u), 9);
-    ASSERT_EQ(*(set.raw() + 2u), 6);
-    ASSERT_EQ(*(set.raw() + 3u), 3);
-    ASSERT_EQ(*(set.raw() + 4u), 1);
-
-    auto begin = set.begin();
-    auto end = set.end();
-
-    ASSERT_EQ(set.get(*(begin++)), 1);
-    ASSERT_EQ(set.get(*(begin++)), 3);
-    ASSERT_EQ(set.get(*(begin++)), 6);
-    ASSERT_EQ(set.get(*(begin++)), 9);
-    ASSERT_EQ(set.get(*(begin++)), 12);
-    ASSERT_EQ(begin, end);
-
-    set.reset();
-}
-
-TEST(SparseSetWithType, SortReverse) {
-    using SparseSet = entt::SparseSet<unsigned int, int>;
-
-    SparseSet set;
-
-    ASSERT_EQ(set.construct(12, 1), 1);
-    ASSERT_EQ(set.construct(42, 3), 3);
-    ASSERT_EQ(set.construct(7, 6), 6);
-    ASSERT_EQ(set.construct(3, 9), 9);
-    ASSERT_EQ(set.construct(9, 12), 12);
-
-    set.sort([](auto lhs, auto rhs) {
-        return lhs < rhs;
-    });
-
-    ASSERT_EQ(*(set.raw() + 0u), 12);
-    ASSERT_EQ(*(set.raw() + 1u), 9);
-    ASSERT_EQ(*(set.raw() + 2u), 6);
-    ASSERT_EQ(*(set.raw() + 3u), 3);
-    ASSERT_EQ(*(set.raw() + 4u), 1);
-
-    auto begin = set.begin();
-    auto end = set.end();
-
-    ASSERT_EQ(set.get(*(begin++)), 1);
-    ASSERT_EQ(set.get(*(begin++)), 3);
-    ASSERT_EQ(set.get(*(begin++)), 6);
-    ASSERT_EQ(set.get(*(begin++)), 9);
-    ASSERT_EQ(set.get(*(begin++)), 12);
-    ASSERT_EQ(begin, end);
-
-    set.reset();
-}
-
-TEST(SparseSetWithType, SortUnordered) {
-    using SparseSet = entt::SparseSet<unsigned int, int>;
-
-    SparseSet set;
-
-    ASSERT_EQ(set.construct(12, 6), 6);
-    ASSERT_EQ(set.construct(42, 3), 3);
-    ASSERT_EQ(set.construct(7, 1), 1);
-    ASSERT_EQ(set.construct(3, 9), 9);
-    ASSERT_EQ(set.construct(9, 12), 12);
-
-    set.sort([](auto lhs, auto rhs) {
-        return lhs < rhs;
-    });
-
-    ASSERT_EQ(*(set.raw() + 0u), 12);
-    ASSERT_EQ(*(set.raw() + 1u), 9);
-    ASSERT_EQ(*(set.raw() + 2u), 6);
-    ASSERT_EQ(*(set.raw() + 3u), 3);
-    ASSERT_EQ(*(set.raw() + 4u), 1);
-
-    auto begin = set.begin();
-    auto end = set.end();
-
-    ASSERT_EQ(set.get(*(begin++)), 1);
-    ASSERT_EQ(set.get(*(begin++)), 3);
-    ASSERT_EQ(set.get(*(begin++)), 6);
-    ASSERT_EQ(set.get(*(begin++)), 9);
-    ASSERT_EQ(set.get(*(begin++)), 12);
-    ASSERT_EQ(begin, end);
-
-    set.reset();
-}
-
-TEST(SparseSetWithType, RespectOrdered) {
-    using SparseSet = entt::SparseSet<unsigned int, int>;
-
-    SparseSet lhs;
-    SparseSet rhs;
-
-    ASSERT_EQ(lhs.construct(1, 0), 0);
-    ASSERT_EQ(lhs.construct(2, 0), 0);
-    ASSERT_EQ(lhs.construct(3, 0), 0);
-    ASSERT_EQ(lhs.construct(4, 0), 0);
-    ASSERT_EQ(lhs.construct(5, 0), 0);
-
-    ASSERT_EQ(rhs.construct(6, 0), 0);
-    ASSERT_EQ(rhs.construct(1, 0), 0);
-    ASSERT_EQ(rhs.construct(2, 0), 0);
-    ASSERT_EQ(rhs.construct(3, 0), 0);
-    ASSERT_EQ(rhs.construct(4, 0), 0);
-    ASSERT_EQ(rhs.construct(5, 0), 0);
-
-    rhs.respect(lhs);
-
-    ASSERT_EQ(*(lhs.data() + 0u), 1u);
-    ASSERT_EQ(*(lhs.data() + 1u), 2u);
-    ASSERT_EQ(*(lhs.data() + 2u), 3u);
-    ASSERT_EQ(*(lhs.data() + 3u), 4u);
-    ASSERT_EQ(*(lhs.data() + 4u), 5u);
-
-    ASSERT_EQ(*(rhs.data() + 0u), 6u);
-    ASSERT_EQ(*(rhs.data() + 1u), 1u);
-    ASSERT_EQ(*(rhs.data() + 2u), 2u);
-    ASSERT_EQ(*(rhs.data() + 3u), 3u);
-    ASSERT_EQ(*(rhs.data() + 4u), 4u);
-    ASSERT_EQ(*(rhs.data() + 5u), 5u);
-
-    lhs.reset();
-    rhs.reset();
-}
-
-TEST(SparseSetWithType, RespectReverse) {
-    using SparseSet = entt::SparseSet<unsigned int, int>;
-
-    SparseSet lhs;
-    SparseSet rhs;
-
-    ASSERT_EQ(lhs.construct(1, 0), 0);
-    ASSERT_EQ(lhs.construct(2, 0), 0);
-    ASSERT_EQ(lhs.construct(3, 0), 0);
-    ASSERT_EQ(lhs.construct(4, 0), 0);
-    ASSERT_EQ(lhs.construct(5, 0), 0);
-
-    ASSERT_EQ(rhs.construct(5, 0), 0);
-    ASSERT_EQ(rhs.construct(4, 0), 0);
-    ASSERT_EQ(rhs.construct(3, 0), 0);
-    ASSERT_EQ(rhs.construct(2, 0), 0);
-    ASSERT_EQ(rhs.construct(1, 0), 0);
-    ASSERT_EQ(rhs.construct(6, 0), 0);
-
-    rhs.respect(lhs);
-
-    ASSERT_EQ(*(lhs.data() + 0u), 1u);
-    ASSERT_EQ(*(lhs.data() + 1u), 2u);
-    ASSERT_EQ(*(lhs.data() + 2u), 3u);
-    ASSERT_EQ(*(lhs.data() + 3u), 4u);
-    ASSERT_EQ(*(lhs.data() + 4u), 5u);
-
-    ASSERT_EQ(*(rhs.data() + 0u), 6u);
-    ASSERT_EQ(*(rhs.data() + 1u), 1u);
-    ASSERT_EQ(*(rhs.data() + 2u), 2u);
-    ASSERT_EQ(*(rhs.data() + 3u), 3u);
-    ASSERT_EQ(*(rhs.data() + 4u), 4u);
-    ASSERT_EQ(*(rhs.data() + 5u), 5u);
-
-    lhs.reset();
-    rhs.reset();
-}
-
-TEST(SparseSetWithType, RespectUnordered) {
-    using SparseSet = entt::SparseSet<unsigned int, int>;
-
-    SparseSet lhs;
-    SparseSet rhs;
-
-    ASSERT_EQ(lhs.construct(1, 0), 0);
-    ASSERT_EQ(lhs.construct(2, 0), 0);
-    ASSERT_EQ(lhs.construct(3, 0), 0);
-    ASSERT_EQ(lhs.construct(4, 0), 0);
-    ASSERT_EQ(lhs.construct(5, 0), 0);
-
-    ASSERT_EQ(rhs.construct(3, 0), 0);
-    ASSERT_EQ(rhs.construct(2, 0), 0);
-    ASSERT_EQ(rhs.construct(6, 0), 0);
-    ASSERT_EQ(rhs.construct(1, 0), 0);
-    ASSERT_EQ(rhs.construct(4, 0), 0);
-    ASSERT_EQ(rhs.construct(5, 0), 0);
-
-    rhs.respect(lhs);
-
-    ASSERT_EQ(*(lhs.data() + 0u), 1u);
-    ASSERT_EQ(*(lhs.data() + 1u), 2u);
-    ASSERT_EQ(*(lhs.data() + 2u), 3u);
-    ASSERT_EQ(*(lhs.data() + 3u), 4u);
-    ASSERT_EQ(*(lhs.data() + 4u), 5u);
-
-    ASSERT_EQ(*(rhs.data() + 0u), 6u);
-    ASSERT_EQ(*(rhs.data() + 1u), 1u);
-    ASSERT_EQ(*(rhs.data() + 2u), 2u);
-    ASSERT_EQ(*(rhs.data() + 3u), 3u);
-    ASSERT_EQ(*(rhs.data() + 4u), 4u);
-    ASSERT_EQ(*(rhs.data() + 5u), 5u);
-
-    lhs.reset();
-    rhs.reset();
-}