runtime view

* 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

AUTHORS

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

CMakeLists.txt

@@ -16,7 +16,9 @@ endif()
 # Project configuration
 #
 
-project(entt VERSION 2.5.0)
+project(entt VERSION 2.6.1)
+
+include(GNUInstallDirs)
 
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Debug)
@@ -32,19 +34,20 @@ message("* ${PROJECT_NAME} v${PROJECT_VERSION} (${CMAKE_BUILD_TYPE})")
 message("* Copyright (c) 2018 ${PROJECT_AUTHOR} <${PROJECT_AUTHOR_EMAIL}>")
 message("*")
 
+option(ENTT_COMPILE_OPTIONS "Use compile options from EnTT." ON)
+option(USE_LIBCPP "Use libc++ by adding -stdlib=libc++ flag if availbale." ON)
+
 #
 # Compiler stuff
 #
 
-set(CMAKE_CXX_STANDARD 14)
-set(CMAKE_CXX_EXTENSIONS OFF)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
-
-if(NOT MSVC)
+if(NOT MSVC AND USE_LIBCPP)
     include(CheckCXXSourceCompiles)
+    include(CMakePushCheckState)
 
-    set(OLD_CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS})
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++")
+    cmake_push_check_state()
+
+    set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -stdlib=libc++")
 
     check_cxx_source_compiles("
         #include<type_traits>
@@ -52,28 +55,102 @@ if(NOT MSVC)
     " HAS_LIBCPP)
 
     if(NOT HAS_LIBCPP)
-        set(CMAKE_CXX_FLAGS "${OLD_CMAKE_CXX_FLAGS}")
+        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()
 
-    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wall")
-    set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DRELEASE")
-    set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0 -g -DDEBUG")
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
-
-    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")
-    endif()
+    cmake_pop_check_state()
 endif()
 
 #
-# Include EnTT
+# Add EnTT target
 #
 
-include_directories(${entt_SOURCE_DIR}/src)
+add_library(EnTT INTERFACE)
+
+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(ENTT_COMPILE_OPTIONS)
+    target_compile_options(
+        EnTT
+        INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-O0 -g>
+        # it seems that -O3 ruins 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(USE_LIBCPP AND HAS_LIBCPP)
+    target_compile_options(EnTT BEFORE INTERFACE -stdlib=libc++)
+endif()
+
+target_compile_features(EnTT INTERFACE cxx_std_14)
+
+#
+# Install EnTT
+#
+
+if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+    set(ENTT_INSTALL_CONFIGDIR cmake)
+else()
+    set(ENTT_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 ${ENTT_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
+    ${ENTT_INSTALL_CONFIGDIR}/EnTTConfig.cmake
+    INSTALL_DESTINATION ${ENTT_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}/${ENTT_INSTALL_CONFIGDIR}/EnTTConfig.cmake
+        ${entt_BINARY_DIR}/EnTTConfigVersion.cmake
+    DESTINATION ${ENTT_INSTALL_CONFIGDIR}
+)
+
+export(PACKAGE EnTT)
 
 #
 # Tests
@@ -105,10 +182,14 @@ endif()
 # Documentation
 #
 
-find_package(Doxygen 1.8)
+option(BUILD_DOCS "Enable building with documentation." OFF)
 
-if(DOXYGEN_FOUND)
-    add_subdirectory(docs)
+if(BUILD_DOCS)
+    find_package(Doxygen 1.8)
+
+    if(DOXYGEN_FOUND)
+        add_subdirectory(docs)
+    endif()
 endif()
 
 #
@@ -120,6 +201,7 @@ add_custom_target(
     SOURCES
         appveyor.yml
         AUTHORS
+        CONTRIBUTING
         LICENSE
         README.md
         TODO

CONTRIBUTING

@@ -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.

TODO

@@ -1,9 +1,12 @@
 * custom allocators and EnTT allocator-aware in general (long term feature, I don't actually need it at the moment) - see #22
-* to analyze, long term feature: systems organizer based on dependency graphs for implicit parallelism (I don't want to think anymore in future :-))
 * scene management (I prefer the concept of spaces, that is a kind of scene anyway)
-* blueprint registry - kind of factory to create entitites template for initialization (get rid of the extra versions of Registry::create)
 * review doc: separate it in multiple md/dox files, reduce the readme to a minimum and provide users with links to the online documentation on gh-pages
 * debugging tools (#60): the issue online already contains interesting tips on this, look at it
-* signals on component creation/destruction: crtp + internal detection, probably it works - test it!!
-* define a macro for the noexcept policy, so as to provide users with an easy way to disable exception handling
+* 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)
+* create dedicated flat map based on types implementation (sort of "type map") for types to use within the registry and so on...
+* ease the assignment of tags as string (type-less assign member function + user defined literal for hashed strings)
+* family -> std::uint32_t (or some other fixed and known size type)
+* work stealing job system (see #100)
+* C++17. That's all.
 * AOB

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/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

@@ -2,8 +2,6 @@
 # Doxygen configuration (documentation)
 #
 
-set(TARGET_DOCS docs)
-
 set(DOXY_SOURCE_DIRECTORY ${entt_SOURCE_DIR}/src)
 set(DOXY_DOCS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 set(DOXY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
@@ -11,7 +9,7 @@ set(DOXY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 configure_file(doxy.in doxy.cfg @ONLY)
 
 add_custom_target(
-    ${TARGET_DOCS}
+    docs ALL
     COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doxy.cfg
     WORKING_DIRECTORY ${entt_SOURCE_DIR}
     VERBATIM

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,78 @@
+#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 {
+    /**
+     * @brief Sorts the element in a range.
+     *
+     * Sorts the element 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 {
+    /**
+     * @brief Sorts the element in a range.
+     *
+     * Sorts the element 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;
+        }
+    }
+};
+
+
+}
+
+
+#endif // ENTT_CORE_ALGORITHM_HPP

src/entt/core/family.hpp

@@ -2,9 +2,10 @@
 #define ENTT_CORE_FAMILY_HPP
 
 
-#include<type_traits>
-#include<cstddef>
-#include<atomic>
+#include <type_traits>
+#include <cstddef>
+#include <atomic>
+#include "../config/config.h"
 
 
 namespace entt {
@@ -22,7 +23,7 @@ class Family {
     static std::atomic<std::size_t> identifier;
 
     template<typename...>
-    static std::size_t family() noexcept {
+    static std::size_t family() ENTT_NOEXCEPT {
         static const std::size_t value = identifier.fetch_add(1);
         return value;
     }
@@ -36,7 +37,7 @@ public:
      * @return Statically generated unique identifier for the given type.
      */
     template<typename... Type>
-    inline static family_type type() noexcept {
+    inline static family_type type() ENTT_NOEXCEPT {
         return family<std::decay_t<Type>...>();
     }
 };

src/entt/core/hashed_string.hpp

@@ -4,6 +4,7 @@
 
 #include <cstddef>
 #include <cstdint>
+#include "../config/config.h"
 
 
 namespace entt {
@@ -21,7 +22,7 @@ namespace entt {
 class HashedString final {
     struct ConstCharWrapper final {
         // non-explicit constructor on purpose
-        constexpr ConstCharWrapper(const char *str) noexcept: str{str} {}
+        constexpr ConstCharWrapper(const char *str) ENTT_NOEXCEPT: str{str} {}
         const char *str;
     };
 
@@ -29,7 +30,7 @@ class HashedString final {
     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) noexcept {
+    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);
     }
 
@@ -52,7 +53,7 @@ public:
      * @param str Human-readable identifer.
      */
     template <std::size_t N>
-    constexpr HashedString(const char (&str)[N]) noexcept
+    constexpr HashedString(const char (&str)[N]) ENTT_NOEXCEPT
         : hash{helper(offset, str)}, str{str}
     {}
 
@@ -62,7 +63,7 @@ public:
      *
      * @param wrapper Helps achieving the purpose by relying on overloading.
      */
-    explicit constexpr HashedString(ConstCharWrapper wrapper) noexcept
+    explicit constexpr HashedString(ConstCharWrapper wrapper) ENTT_NOEXCEPT
         : hash{helper(offset, wrapper.str)}, str{wrapper.str}
     {}
 
@@ -70,20 +71,20 @@ public:
      * @brief Returns the human-readable representation of a hashed string.
      * @return The string used to initialize the instance.
      */
-    constexpr operator const char *() const noexcept { return str; }
+    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 noexcept { return hash; }
+    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 noexcept {
+    constexpr bool operator==(const HashedString &other) const ENTT_NOEXCEPT {
         return hash == other.hash;
     }
 
@@ -99,7 +100,7 @@ private:
  * @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) noexcept {
+constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) ENTT_NOEXCEPT {
     return !(lhs == rhs);
 }
 
@@ -107,4 +108,9 @@ constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noex
 }
 
 
+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

@@ -2,72 +2,62 @@
 #define ENTT_CORE_IDENT_HPP
 
 
-#include<type_traits>
-#include<cstddef>
-#include<utility>
+#include <type_traits>
+#include <cstddef>
+#include <utility>
+#include <tuple>
+#include "../config/config.h"
 
 
 namespace entt {
 
 
-namespace {
+namespace internal {
 
 
-template<typename... Types>
-struct Identifier final: Identifier<Types>... {
-    using identifier_type = std::size_t;
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
 
-    template<std::size_t... Indexes>
-    constexpr Identifier(std::index_sequence<Indexes...>)
-        : Identifier<Types>{std::index_sequence<Indexes>{}}...
-    {}
 
-    template<typename Type>
-    constexpr std::size_t get() const {
-        return Identifier<std::decay_t<Type>>::get();
-    }
-};
+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 Identifier<Type> {
-    using identifier_type = std::size_t;
+struct IsPartOf<Type>: std::false_type {};
 
-    template<std::size_t Index>
-    constexpr Identifier(std::index_sequence<Index>)
-        : index{Index}
-    {}
 
-    constexpr std::size_t get() const {
-        return index;
-    }
-
-private:
-    const std::size_t index;
-};
+/**
+ * Internal details not to be documented.
+ * @endcond TURN_OFF_DOXYGEN
+ */
 
 
 }
 
 
 /**
- * @brief Types identifers.
+ * @brief Types identifiers.
  *
  * Variable template used to generate identifiers at compile-time for the given
- * types. Use the `constexpr` `get` member function to know what's the
- * identifier associated to the specific type.
+ * 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}
- * constexpr auto identifiers = entt::ident<AType, AnotherType>;
+ * using ID = entt::Identifier<AType, AnotherType>;
  *
  * switch(aTypeIdentifier) {
- * case identifers.get<AType>():
+ * case ID::get<AType>():
  *     // ...
  *     break;
- * case identifers.get<AnotherType>():
+ * case ID::get<AnotherType>():
  *     // ...
  *     break;
  * default:
@@ -75,19 +65,37 @@ private:
  * }
  * @endcode
  *
- * @note
- * In case of single type list, `get` isn't a member function template:
- * @code{.cpp}
- * func(std::integral_constant<
- *     entt::ident<AType>::identifier_type,
- *     entt::ident<AType>::get()
- * >{});
- * @endcode
- *
  * @tparam Types List of types for which to generate identifiers.
  */
 template<typename... Types>
-constexpr auto ident = Identifier<std::decay_t<Types>...>{std::make_index_sequence<sizeof...(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)>{});
+    }
+};
 
 
 }

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

@@ -2,7 +2,9 @@
 #define ENTT_ENTITY_ACTOR_HPP
 
 
+#include <cassert>
 #include <utility>
+#include "../config/config.h"
 #include "registry.hpp"
 
 
@@ -16,28 +18,25 @@ namespace entt {
  * with entity-component systems and prefer to iterate objects directly.
  *
  * @tparam Entity A valid entity type (see entt_traits for more details).
- * @tparam Delta Type to use to provide elapsed time.
  */
-template<typename Entity, typename Delta>
+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 Type used to provide elapsed time. */
-    using delta_type = Delta;
 
     /**
      * @brief Constructs an actor by using the given registry.
      * @param reg An entity-component system properly initialized.
      */
     Actor(Registry<Entity> &reg)
-        : reg{reg}, entity{reg.create()}
+        : reg{reg}, entt{reg.create()}
     {}
 
     /*! @brief Default destructor. */
     virtual ~Actor() {
-        reg.destroy(entity);
+        reg.destroy(entt);
     }
 
     /*! @brief Default copy constructor. */
@@ -50,6 +49,24 @@ struct Actor {
     /*! @brief Default move assignment operator. @return This actor. */
     Actor & operator=(Actor &&) = default;
 
+    /**
+     * @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.
      *
@@ -65,8 +82,18 @@ struct Actor {
      * @return A reference to the newly created component.
      */
     template<typename Component, typename... Args>
-    Component & set(Args &&... args) {
-        return reg.template accommodate<Component>(entity, std::forward<Args>(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>();
     }
 
     /**
@@ -74,8 +101,18 @@ struct Actor {
      * @tparam Component Type of the component to remove.
      */
     template<typename Component>
-    void unset() {
-        reg.template remove<Component>(entity);
+    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));
     }
 
     /**
@@ -84,55 +121,78 @@ struct Actor {
      * @return True if the actor has the component, false otherwise.
      */
     template<typename Component>
-    bool has() const noexcept {
-        return reg.template has<Component>(entity);
+    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 entity.
+     * @return A reference to the instance of the component owned by the actor.
      */
     template<typename Component>
-    const Component & get() const noexcept {
-        return reg.template get<Component>(entity);
+    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 entity.
+     * @return A reference to the instance of the component owned by the actor.
      */
     template<typename Component>
-    Component & get() noexcept {
+    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
+     * @return A reference to the underlying registry.
      */
-    const registry_type & registry() const noexcept {
+    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
+     * @return A reference to the underlying registry.
      */
-    registry_type & registry() noexcept {
+    inline registry_type & registry() ENTT_NOEXCEPT {
         return const_cast<registry_type &>(const_cast<const Actor *>(this)->registry());
     }
 
     /**
-     * @brief Updates an actor, whatever it means to update it.
-     * @param delta Elapsed time.
+     * @brief Returns the entity associated with an actor.
+     * @return The entity associated with the actor.
      */
-    virtual void update(delta_type delta) = 0;
+    inline entity_type entity() const ENTT_NOEXCEPT {
+        return entt;
+    }
 
 private:
     registry_type &reg;
-    Entity entity;
+    Entity entt;
 };
 
 
@@ -141,11 +201,8 @@ private:
  *
  * The default actor is the best choice for almost all the applications.<br/>
  * Users should have a really good reason to choose something different.
- *
- * @tparam Delta Type to use to provide elapsed time.
  */
-template<typename Delta>
-using DefaultActor = Actor<DefaultRegistry::entity_type, Delta>;
+using DefaultActor = Actor<DefaultRegistry::entity_type>;
 
 
 }

src/entt/entity/entity.hpp

@@ -0,0 +1,87 @@
+#ifndef ENTT_ENTITY_ENTITY_HPP
+#define ENTT_ENTITY_ENTITY_HPP
+
+
+#include "../config/config.h"
+#include "entt_traits.hpp"
+
+
+namespace entt {
+
+
+namespace internal {
+
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+
+template<typename Entity>
+static constexpr auto null = ~typename entt_traits<Entity>::entity_type{};
+
+
+struct Null {
+    explicit constexpr Null() = default;
+
+    template<typename Entity>
+    constexpr operator Entity() const ENTT_NOEXCEPT {
+        return null<Entity>;
+    }
+
+    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 == null<Entity>;
+    }
+
+    template<typename Entity>
+    constexpr bool operator!=(const Entity entity) const ENTT_NOEXCEPT {
+        return entity != null<Entity>;
+    }
+};
+
+
+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

@@ -32,6 +32,8 @@ struct entt_traits<std::uint16_t> {
     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 auto entity_mask = 0xFFF;
@@ -47,8 +49,8 @@ struct entt_traits<std::uint16_t> {
  *
  * A 32 bits entity identifier guarantees:
  *
- * * 24 bits for the entity number (suitable for almost all the games).
- * * 8 bit for the version (resets in [0-255]).
+ * * 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> {
@@ -56,6 +58,8 @@ struct entt_traits<std::uint32_t> {
     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 auto entity_mask = 0xFFFFF;
@@ -71,8 +75,8 @@ struct entt_traits<std::uint32_t> {
  *
  * A 64 bits entity identifier guarantees:
  *
- * * 40 bits for the entity number (an indecently large number).
- * * 24 bit for the version (an indecently large number).
+ * * 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> {
@@ -80,13 +84,15 @@ struct entt_traits<std::uint64_t> {
     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 auto entity_mask = 0xFFFFFFFFFF;
+    static constexpr auto entity_mask = 0xFFFFFFFF;
     /*! @brief Mask to use to get the version out of an identifier. */
-    static constexpr auto version_mask = 0xFFFFFF;
+    static constexpr auto version_mask = 0xFFFFFFFF;
     /*! @brief Extent of the entity number within an identifier. */
-    static constexpr auto entity_shift = 40;
+    static constexpr auto entity_shift = 32;
 };
 
 

src/entt/entity/helper.hpp

@@ -0,0 +1,84 @@
+#ifndef ENTT_ENTITY_HELPER_HPP
+#define ENTT_ENTITY_HELPER_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::dependency<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>
+void dependency(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::dependency<AType, AnotherType>(entt::break_t{}, 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>
+void dependency(break_t, Sink<void(Registry<Entity> &, const Entity)> sink) {
+    sink.template disconnect<dependency<Entity, Dependency...>>();
+}
+
+
+}
+
+
+#endif // ENTT_ENTITY_HELPER_HPP

src/entt/entity/prototype.hpp

@@ -0,0 +1,496 @@
+#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"
+
+
+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 = ~entity_type{};
+    }
+
+    /*! @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 accommodate<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

@@ -2,14 +2,16 @@
 #define ENTT_ENTITY_SNAPSHOT_HPP
 
 
-#include <unordered_map>
-#include <algorithm>
+#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 {
@@ -37,52 +39,55 @@ class Snapshot final {
     /*! @brief A registry is allowed to create snapshots. */
     friend class Registry<Entity>;
 
-    using follow_fn_type = Entity(*)(const Registry<Entity> &, Entity);
-    using raw_fn_type = const Entity *(*)(const Registry<Entity> &, typename Registry<Entity>::component_type);
+    using follow_fn_type = Entity(const Registry<Entity> &, const Entity);
 
-    Snapshot(const Registry<Entity> &registry, Entity seed, std::size_t size, follow_fn_type follow, raw_fn_type raw) noexcept
+    Snapshot(const Registry<Entity> &registry, Entity seed, follow_fn_type *follow) ENTT_NOEXCEPT
         : registry{registry},
           seed{seed},
-          size{size},
-          follow{follow},
-          raw{raw}
+          follow{follow}
     {}
 
-    Snapshot(const Snapshot &) = default;
-    Snapshot(Snapshot &&) = default;
-
-    Snapshot & operator=(const Snapshot &) = default;
-    Snapshot & operator=(Snapshot &&) = default;
-
-    template<typename Component, typename Archive>
-    void get(Archive &archive, const Registry<Entity> &registry) {
-        const auto component = registry.template component<Component>();
-        const auto sz = registry.template size<Component>();
-        const auto *entities = raw(registry, component);
-
+    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));
 
-        for(std::remove_const_t<decltype(sz)> i{}; i < sz; ++i) {
-            const auto entity = entities[i];
-            archive(entity);
-            archive(registry.template get<Component>(entity));
-        };
-    }
+        while(first != last) {
+            const auto entity = *(first++);
 
-    template<typename Tag, typename Archive>
-    void get(Archive &archive) {
-        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>());
-            archive(registry.template get<Tag>());
+            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.
      *
@@ -94,9 +99,9 @@ public:
      * @return An object of this type to continue creating the snapshot.
      */
     template<typename Archive>
-    Snapshot entities(Archive &archive) && {
+    const Snapshot & entities(Archive &archive) const {
         archive(static_cast<Entity>(registry.size()));
-        registry.each([&archive, this](auto entity) { archive(entity); });
+        registry.each([&archive](const auto entity) { archive(entity); });
         return *this;
     }
 
@@ -111,27 +116,50 @@ public:
      * @return An object of this type to continue creating the snapshot.
      */
     template<typename Archive>
-    Snapshot destroyed(Archive &archive) && {
+    const Snapshot & destroyed(Archive &archive) const {
+        auto size = registry.capacity() - registry.size();
         archive(static_cast<Entity>(size));
+        auto curr = seed;
 
-        if(size) {
-            auto curr = seed;
+        for(; size; --size) {
             archive(curr);
-
-            for(auto i = size - 1; i; --i) {
-                curr = follow(registry, curr);
-                archive(curr);
-            }
+            curr = follow(registry, 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 component is serialized together with the entity to which it
-     * belongs. Entities are serialized along with their versions.
+     * 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.
@@ -139,17 +167,63 @@ public:
      * @return An object of this type to continue creating the snapshot.
      */
     template<typename... Component, typename Archive>
-    Snapshot component(Archive &archive) && {
+    std::enable_if_t<(sizeof...(Component) > 1), const Snapshot &>
+    component(Archive &archive) const {
         using accumulator_type = int[];
-        accumulator_type accumulator = { 0, (get<Component>(archive, registry), 0)... };
+        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 tag is serialized together with the entity to which it belongs.
+     * 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.
@@ -158,9 +232,10 @@ public:
      * @return An object of this type to continue creating the snapshot.
      */
     template<typename... Tag, typename Archive>
-    Snapshot tag(Archive &archive) && {
+    std::enable_if_t<(sizeof...(Tag) > 1), const Snapshot &>
+    tag(Archive &archive) const {
         using accumulator_type = int[];
-        accumulator_type accumulator = { 0, (get<Tag>(archive), 0)... };
+        accumulator_type accumulator = { 0, (tag<Tag>(archive), 0)... };
         (void)accumulator;
         return *this;
     }
@@ -168,9 +243,7 @@ public:
 private:
     const Registry<Entity> &registry;
     const Entity seed;
-    const std::size_t size;
-    follow_fn_type follow;
-    raw_fn_type raw;
+    follow_fn_type *follow;
 };
 
 
@@ -189,9 +262,9 @@ class SnapshotLoader final {
     /*! @brief A registry is allowed to create snapshot loaders. */
     friend class Registry<Entity>;
 
-    using assure_fn_type = void(*)(Registry<Entity> &, Entity, bool);
+    using assure_fn_type = void(Registry<Entity> &, const Entity, const bool);
 
-    SnapshotLoader(Registry<Entity> &registry, assure_fn_type assure_fn) noexcept
+    SnapshotLoader(Registry<Entity> &registry, assure_fn_type *assure_fn) ENTT_NOEXCEPT
         : registry{registry},
           assure_fn{assure_fn}
     {
@@ -199,44 +272,44 @@ class SnapshotLoader final {
         assert(!registry.capacity());
     }
 
-    SnapshotLoader(const SnapshotLoader &) = default;
-    SnapshotLoader(SnapshotLoader &&) = default;
-
-    SnapshotLoader & operator=(const SnapshotLoader &) = default;
-    SnapshotLoader & operator=(SnapshotLoader &&) = default;
-
-    template<typename Archive, typename Func>
-    void each(Archive &archive, Func func) {
+    template<typename Archive>
+    void assure(Archive &archive, bool destroyed) const {
         Entity length{};
         archive(length);
 
-        while(length) {
+        while(length--) {
             Entity entity{};
             archive(entity);
-            func(entity);
-            --length;
+            assure_fn(registry, entity, destroyed);
         }
     }
 
-    template<typename Component, typename Archive>
-    void assign(Archive &archive) {
-        each(archive, [&archive, this](auto entity) {
-            static constexpr auto destroyed = false;
-            assure_fn(registry, entity, destroyed);
-            archive(registry.template assign<Component>(entity));
-        });
-    }
+    template<typename Type, typename Archive, typename... Args>
+    void assign(Archive &archive, Args... args) const {
+        Entity length{};
+        archive(length);
 
-    template<typename Tag, typename Archive>
-    void attach(Archive &archive) {
-        each(archive, [&archive, this](auto entity) {
+        while(length--) {
+            Entity entity{};
+            Type instance{};
+            archive(entity, instance);
             static constexpr auto destroyed = false;
             assure_fn(registry, entity, destroyed);
-            archive(registry.template attach<Tag>(entity));
-        });
+            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.
      *
@@ -248,12 +321,9 @@ public:
      * @return A valid loader to continue restoring data.
      */
     template<typename Archive>
-    SnapshotLoader entities(Archive &archive) && {
-        each(archive, [this](auto entity) {
-            static constexpr auto destroyed = false;
-            assure_fn(registry, entity, destroyed);
-        });
-
+    const SnapshotLoader & entities(Archive &archive) const {
+        static constexpr auto destroyed = false;
+        assure(archive, destroyed);
         return *this;
     }
 
@@ -268,12 +338,9 @@ public:
      * @return A valid loader to continue restoring data.
      */
     template<typename Archive>
-    SnapshotLoader destroyed(Archive &archive) && {
-        each(archive, [this](auto entity) {
-            static constexpr auto destroyed = true;
-            assure_fn(registry, entity, destroyed);
-        });
-
+    const SnapshotLoader & destroyed(Archive &archive) const {
+        static constexpr auto destroyed = true;
+        assure(archive, destroyed);
         return *this;
     }
 
@@ -291,7 +358,7 @@ public:
      * @return A valid loader to continue restoring data.
      */
     template<typename... Component, typename Archive>
-    SnapshotLoader component(Archive &archive) && {
+    const SnapshotLoader & component(Archive &archive) const {
         using accumulator_type = int[];
         accumulator_type accumulator = { 0, (assign<Component>(archive), 0)... };
         (void)accumulator;
@@ -312,14 +379,13 @@ public:
      * @return A valid loader to continue restoring data.
      */
     template<typename... Tag, typename Archive>
-    SnapshotLoader tag(Archive &archive) && {
+    const SnapshotLoader & tag(Archive &archive) const {
         using accumulator_type = int[];
-        accumulator_type accumulator = { 0, (attach<Tag>(archive), 0)... };
+        accumulator_type accumulator = { 0, (assign<Tag>(archive, tag_t{}), 0)... };
         (void)accumulator;
         return *this;
     }
 
-
     /**
      * @brief Destroys those entities that have neither components nor tags.
      *
@@ -330,8 +396,8 @@ public:
      *
      * @return A valid loader to continue restoring data.
      */
-    SnapshotLoader orphans() && {
-        registry.orphans([this](auto entity) {
+    const SnapshotLoader & orphans() const {
+        registry.orphans([this](const auto entity) {
             registry.destroy(entity);
         });
 
@@ -340,7 +406,7 @@ public:
 
 private:
     Registry<Entity> &registry;
-    assure_fn_type assure_fn;
+    assure_fn_type *assure_fn;
 };
 
 
@@ -364,7 +430,7 @@ template<typename Entity>
 class ContinuousLoader final {
     using traits_type = entt_traits<Entity>;
 
-    Entity destroy(Entity entity) {
+    void destroy(Entity entity) {
         const auto it = remloc.find(entity);
 
         if(it == remloc.cend()) {
@@ -372,11 +438,9 @@ class ContinuousLoader final {
             remloc.emplace(entity, std::make_pair(local, true));
             registry.destroy(local);
         }
-
-        return remloc[entity].first;
     }
 
-    Entity restore(Entity entity) {
+    void restore(Entity entity) {
         const auto it = remloc.find(entity);
 
         if(it == remloc.cend()) {
@@ -391,34 +455,35 @@ class ContinuousLoader final {
             // set the dirty flag
             remloc[entity].second = true;
         }
-
-        return remloc[entity].first;
     }
 
-    template<typename Instance, typename Type>
-    std::enable_if_t<std::is_same<Type, Entity>::value>
-    update(Instance &instance, Type Instance::*member) {
+    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 Instance, typename Type>
-    std::enable_if_t<std::is_same<typename std::iterator_traits<typename Type::iterator>::value_type, Entity>::value>
-    update(Instance &instance, Type Instance::*member) {
-        for(auto &entity: (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 Archive, typename Func>
-    void each(Archive &archive, Func func) {
+    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) {
+        while(length--) {
             Entity entity{};
             archive(entity);
-            func(entity);
-            --length;
+            (this->*member)(entity);
         }
     }
 
@@ -433,54 +498,24 @@ class ContinuousLoader final {
         }
     }
 
-    template<typename Component, typename Archive>
-    void assign(Archive &archive) {
-        reset<Component>();
+    template<typename Other, typename Archive, typename Func, typename... Type, typename... Member>
+    void assign(Archive &archive, Func func, Member Type:: *... member) {
+        Entity length{};
+        archive(length);
 
-        each(archive, [&archive, this](auto entity) {
-            entity = restore(entity);
-            archive(registry.template accommodate<Component>(entity));
-        });
-    }
+        while(length--) {
+            Entity entity{};
+            Other instance{};
 
-    template<typename Component, typename Archive, typename... Type>
-    void assign(Archive &archive, Type Component::*... member) {
-        reset<Component>();
-
-        each(archive, [&archive, member..., this](auto entity) {
-            entity = restore(entity);
-            auto &component = registry.template accommodate<Component>(entity);
-            archive(component);
+            archive(entity, instance);
+            restore(entity);
 
             using accumulator_type = int[];
-            accumulator_type accumulator = { 0, (update(component, member), 0)... };
+            accumulator_type accumulator = { 0, (update(instance, member), 0)... };
             (void)accumulator;
-        });
-    }
 
-    template<typename Tag, typename Archive>
-    void attach(Archive &archive) {
-        registry.template remove<Tag>();
-
-        each(archive, [&archive, this](auto entity) {
-            entity = restore(entity);
-            archive(registry.template attach<Tag>(entity));
-        });
-    }
-
-    template<typename Tag, typename Archive, typename... Type>
-    void attach(Archive &archive, Type Tag::*... member) {
-        registry.template remove<Tag>();
-
-        each(archive, [&archive, member..., this](auto entity) {
-            entity = restore(entity);
-            auto &tag = registry.template attach<Tag>(entity);
-            archive(tag);
-
-            using accumulator_type = int[];
-            accumulator_type accumulator = { 0, (update(tag, member), 0)... };
-            (void)accumulator;
-        });
+            func(map(entity), instance);
+        }
     }
 
 public:
@@ -491,17 +526,17 @@ public:
      * @brief Constructs a loader that is bound to a given registry.
      * @param registry A valid reference to a registry.
      */
-    ContinuousLoader(Registry<entity_type> &registry) noexcept
+    ContinuousLoader(Registry<entity_type> &registry) ENTT_NOEXCEPT
         : registry{registry}
     {}
 
-    /*! @brief Default copy constructor. */
-    ContinuousLoader(const ContinuousLoader &) = default;
+    /*! @brief Copying a snapshot loader isn't allowed. */
+    ContinuousLoader(const ContinuousLoader &) = delete;
     /*! @brief Default move constructor. */
     ContinuousLoader(ContinuousLoader &&) = default;
 
-    /*! @brief Default copy assignment operator. @return This loader. */
-    ContinuousLoader & operator=(const 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;
 
@@ -517,7 +552,7 @@ public:
      */
     template<typename Archive>
     ContinuousLoader & entities(Archive &archive) {
-        each(archive, [this](auto entity) { restore(entity); });
+        assure(archive, &ContinuousLoader::restore);
         return *this;
     }
 
@@ -533,28 +568,7 @@ public:
      */
     template<typename Archive>
     ContinuousLoader & destroyed(Archive &archive) {
-        each(archive, [this](auto entity) { destroy(entity); });
-        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.
-     *
-     * @tparam Component Types of components to restore.
-     * @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... Component, typename Archive>
-    ContinuousLoader & component(Archive &archive) {
-        using accumulator_type = int[];
-        accumulator_type accumulator = { 0, (assign<Component>(archive), 0)... };
-        (void)accumulator;
+        assure(archive, &ContinuousLoader::destroy);
         return *this;
     }
 
@@ -571,34 +585,20 @@ public:
      *
      * @tparam Component Type of component to restore.
      * @tparam Archive Type of input archive.
-     * @tparam Type Types of members to update with their local counterparts.
+     * @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>
-    ContinuousLoader & component(Archive &archive, Type Component::*... member) {
-        assign(archive, member...);
-        return *this;
-    }
+    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);
+        };
 
-    /**
-     * @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.
-     *
-     * @tparam Tag Types of tags to restore.
-     * @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... Tag, typename Archive>
-    ContinuousLoader & tag(Archive &archive) {
         using accumulator_type = int[];
-        accumulator_type accumulator = { 0, (attach<Tag>(archive), 0)... };
+        accumulator_type accumulator = { 0, (reset<Component>(), assign<Component>(archive, apply, member...), 0)... };
         (void)accumulator;
         return *this;
     }
@@ -616,14 +616,21 @@ public:
      *
      * @tparam Tag Type of tag to restore.
      * @tparam Archive Type of input archive.
-     * @tparam Type Types of members to update with their local counterparts.
+     * @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>
-    ContinuousLoader & tag(Archive &archive, Type Tag::*... member) {
-        attach<Tag>(archive, member...);
+    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;
     }
 
@@ -668,7 +675,7 @@ public:
      * @return A non-const reference to this loader.
      */
     ContinuousLoader & orphans() {
-        registry.orphans([this](auto entity) {
+        registry.orphans([this](const auto entity) {
             registry.destroy(entity);
         });
 
@@ -680,8 +687,8 @@ public:
      * @param entity An entity identifier.
      * @return True if `entity` is managed by the loader, false otherwise.
      */
-    bool has(entity_type entity) {
-        return !(remloc.find(entity) == remloc.cend());
+    bool has(entity_type entity) const ENTT_NOEXCEPT {
+        return (remloc.find(entity) != remloc.cend());
     }
 
     /**
@@ -696,9 +703,9 @@ public:
      * @param entity An entity identifier.
      * @return The identifier to which `entity` refers in the target registry.
      */
-    entity_type map(entity_type entity) {
+    entity_type map(entity_type entity) const ENTT_NOEXCEPT {
         assert(has(entity));
-        return remloc[entity].first;
+        return remloc.find(entity)->second.first;
     }
 
 private:

src/entt/entity/sparse_set.hpp

@@ -10,7 +10,10 @@
 #include <cstddef>
 #include <cassert>
 #include <type_traits>
+#include "../config/config.h"
+#include "../core/algorithm.hpp"
 #include "entt_traits.hpp"
+#include "entity.hpp"
 
 
 namespace entt {
@@ -57,69 +60,123 @@ template<typename Entity>
 class SparseSet<Entity> {
     using traits_type = entt_traits<Entity>;
 
-    struct Iterator final {
-        using difference_type = std::size_t;
-        using value_type = Entity;
-        using pointer = value_type *;
-        using reference = value_type;
-        using iterator_category = std::input_iterator_tag;
+    class Iterator final {
+        friend class SparseSet<Entity>;
 
-        Iterator(const std::vector<value_type> &direct, std::size_t pos)
-            : direct{direct}, pos{pos}
+        using entity_type = Entity;
+        using index_type = typename traits_type::difference_type;
+
+        Iterator(const entity_type *direct, index_type index) ENTT_NOEXCEPT
+            : direct{direct}, index{index}
         {}
 
-        Iterator & operator++() noexcept {
-            return --pos, *this;
+    public:
+        using difference_type = index_type;
+        using value_type = const entity_type;
+        using pointer = value_type *;
+        using reference = value_type &;
+        using iterator_category = std::random_access_iterator_tag;
+
+        Iterator() ENTT_NOEXCEPT = default;
+
+        Iterator(const Iterator &) ENTT_NOEXCEPT = default;
+        Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
+
+        Iterator & operator++() ENTT_NOEXCEPT {
+            return --index, *this;
         }
 
-        Iterator operator++(int) noexcept {
+        Iterator operator++(int) ENTT_NOEXCEPT {
             Iterator orig = *this;
             return ++(*this), orig;
         }
 
-        Iterator & operator+=(difference_type value) noexcept {
-            pos -= value;
+        Iterator & operator--() ENTT_NOEXCEPT {
+            return ++index, *this;
+        }
+
+        Iterator operator--(int) ENTT_NOEXCEPT {
+            Iterator orig = *this;
+            return --(*this), orig;
+        }
+
+        Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
+            index -= value;
             return *this;
         }
 
-        Iterator operator+(difference_type value) noexcept {
-            return Iterator{direct, pos-value};
+        Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
+            return Iterator{direct, index-value};
         }
 
-        bool operator==(const Iterator &other) const noexcept {
-            return other.pos == pos;
+        inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
+            return (*this += -value);
         }
 
-        bool operator!=(const Iterator &other) const noexcept {
+        inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
+            return (*this + -value);
+        }
+
+        difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
+            return other.index - index;
+        }
+
+        reference operator[](const difference_type value) const ENTT_NOEXCEPT {
+            return direct[index-value-1];
+        }
+
+        bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
+            return other.index == index;
+        }
+
+        inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
             return !(*this == other);
         }
 
-        reference operator*() const noexcept {
-            return direct[pos-1];
+        bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
+            return index > other.index;
+        }
+
+        bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
+            return index < other.index;
+        }
+
+        inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
+            return !(*this > other);
+        }
+
+        inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
+            return !(*this < other);
+        }
+
+        pointer operator->() const ENTT_NOEXCEPT {
+            return (direct+index-1);
+        }
+
+        inline reference operator*() const ENTT_NOEXCEPT {
+            return *operator->();
         }
 
     private:
-        const std::vector<value_type> &direct;
-        std::size_t pos;
+        pointer direct;
+        index_type index;
     };
 
-    static constexpr Entity in_use = (Entity{1} << traits_type::entity_shift);
-
 public:
     /*! @brief Underlying entity identifier. */
     using entity_type = Entity;
-    /*! @brief Entity dependent position type. */
-    using pos_type = entity_type;
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Input iterator type. */
     using iterator_type = Iterator;
+    /*! @brief Constant input iterator type. */
+    using const_iterator_type = Iterator;
 
     /*! @brief Default constructor. */
-    SparseSet() noexcept = default;
+    SparseSet() ENTT_NOEXCEPT = default;
 
     /*! @brief Default destructor. */
-    virtual ~SparseSet() noexcept = default;
+    virtual ~SparseSet() ENTT_NOEXCEPT = default;
 
     /*! @brief Copying a sparse set isn't allowed. */
     SparseSet(const SparseSet &) = delete;
@@ -139,10 +196,19 @@ public:
      *
      * @param cap Desired capacity.
      */
-    void reserve(size_type cap) {
+    void reserve(const size_type cap) {
         direct.reserve(cap);
     }
 
+    /**
+     * @brief Returns the number of elements that a sparse set has currently
+     * allocated space for.
+     * @return Capacity of the sparse set.
+     */
+    size_type capacity() const ENTT_NOEXCEPT {
+        return direct.capacity();
+    }
+
     /**
      * @brief Returns the extent of a sparse set.
      *
@@ -153,7 +219,7 @@ public:
      *
      * @return Extent of the sparse set.
      */
-    size_type extent() const noexcept {
+    size_type extent() const ENTT_NOEXCEPT {
         return reverse.size();
     }
 
@@ -167,7 +233,7 @@ public:
      *
      * @return Number of elements.
      */
-    size_type size() const noexcept {
+    size_type size() const ENTT_NOEXCEPT {
         return direct.size();
     }
 
@@ -175,7 +241,7 @@ public:
      * @brief Checks whether a sparse set is empty.
      * @return True if the sparse set is empty, false otherwise.
      */
-    bool empty() const noexcept {
+    bool empty() const ENTT_NOEXCEPT {
         return direct.empty();
     }
 
@@ -194,7 +260,7 @@ public:
      *
      * @return A pointer to the internal packed array.
      */
-    const entity_type * data() const noexcept {
+    const entity_type * data() const ENTT_NOEXCEPT {
         return direct.data();
     }
 
@@ -210,8 +276,41 @@ public:
      *
      * @return An iterator to the first entity of the internal packed array.
      */
-    iterator_type begin() const noexcept {
-        return Iterator{direct, direct.size()};
+    const_iterator_type cbegin() const ENTT_NOEXCEPT {
+        const typename traits_type::difference_type pos = direct.size();
+        return const_iterator_type{direct.data(), pos};
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning.
+     *
+     * The returned iterator points to the first entity of the internal packed
+     * array. If the sparse set is empty, the returned iterator will be equal to
+     * `end()`.
+     *
+     * @note
+     * Input iterators stay true to the order imposed by a call to `respect`.
+     *
+     * @return An iterator to the first entity of the internal packed array.
+     */
+    inline const_iterator_type begin() const ENTT_NOEXCEPT {
+        return cbegin();
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning.
+     *
+     * The returned iterator points to the first entity of the internal packed
+     * array. If the sparse set is empty, the returned iterator will be equal to
+     * `end()`.
+     *
+     * @note
+     * Input iterators stay true to the order imposed by a call to `respect`.
+     *
+     * @return An iterator to the first entity of the internal packed array.
+     */
+    inline iterator_type begin() ENTT_NOEXCEPT {
+        return cbegin();
     }
 
     /**
@@ -227,8 +326,51 @@ public:
      * @return An iterator to the element following the last entity of the
      * internal packed array.
      */
-    iterator_type end() const noexcept {
-        return Iterator{direct, 0};
+    const_iterator_type cend() const ENTT_NOEXCEPT {
+        return const_iterator_type{direct.data(), {}};
+    }
+
+    /**
+     * @brief Returns an iterator to the end.
+     *
+     * The returned iterator points to the element following the last entity in
+     * the internal packed array. Attempting to dereference the returned
+     * iterator results in undefined behavior.
+     *
+     * @note
+     * Input iterators stay true to the order imposed by a call to `respect`.
+     *
+     * @return An iterator to the element following the last entity of the
+     * internal packed array.
+     */
+    inline const_iterator_type end() const ENTT_NOEXCEPT {
+        return cend();
+    }
+
+    /**
+     * @brief Returns an iterator to the end.
+     *
+     * The returned iterator points to the element following the last entity in
+     * the internal packed array. Attempting to dereference the returned
+     * iterator results in undefined behavior.
+     *
+     * @note
+     * Input iterators stay true to the order imposed by a call to `respect`.
+     *
+     * @return An iterator to the element following the last entity of the
+     * internal packed array.
+     */
+    inline iterator_type end() ENTT_NOEXCEPT {
+        return cend();
+    }
+
+    /**
+     * @brief Returns a reference to the element at the given position.
+     * @param pos Position of the element to return.
+     * @return A reference to the requested element.
+     */
+    inline const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
+        return cbegin()[pos];
     }
 
     /**
@@ -236,10 +378,10 @@ public:
      * @param entity A valid entity identifier.
      * @return True if the sparse set contains the entity, false otherwise.
      */
-    bool has(entity_type entity) const noexcept {
+    bool has(const entity_type entity) const ENTT_NOEXCEPT {
         const auto pos = size_type(entity & traits_type::entity_mask);
-        // the in-use control bit permits to avoid accessing the direct vector
-        return (pos < reverse.size()) && (reverse[pos] & in_use);
+        // testing against null permits to avoid accessing the direct vector
+        return (pos < reverse.size()) && (reverse[pos] != null);
     }
 
     /**
@@ -259,11 +401,11 @@ public:
      * @param entity A valid entity identifier.
      * @return True if the sparse set contains the entity, false otherwise.
      */
-    bool fast(entity_type entity) const noexcept {
+    bool fast(const entity_type entity) const ENTT_NOEXCEPT {
         const auto pos = size_type(entity & traits_type::entity_mask);
         assert(pos < reverse.size());
-        // the in-use control bit permits to avoid accessing the direct vector
-        return (reverse[pos] & in_use);
+        // testing against null permits to avoid accessing the direct vector
+        return (reverse[pos] != null);
     }
 
     /**
@@ -278,11 +420,9 @@ public:
      * @param entity A valid entity identifier.
      * @return The position of the entity in the sparse set.
      */
-    pos_type get(entity_type entity) const noexcept {
+    size_type get(const entity_type entity) const ENTT_NOEXCEPT {
         assert(has(entity));
-        const auto entt = entity & traits_type::entity_mask;
-        // we must get rid of the in-use bit for it's not part of the position
-        return reverse[entt] & traits_type::entity_mask;
+        return reverse[entity & traits_type::entity_mask];
     }
 
     /**
@@ -296,18 +436,17 @@ public:
      *
      * @param entity A valid entity identifier.
      */
-    void construct(entity_type entity) {
+    void construct(const entity_type entity) {
         assert(!has(entity));
         const auto pos = size_type(entity & traits_type::entity_mask);
 
         if(!(pos < reverse.size())) {
-            reverse.resize(pos+1, pos_type{});
+            // null is safe in all cases for our purposes
+            reverse.resize(pos+1, null);
         }
 
-        // we exploit the fact that pos_type is equal to entity_type and pos has
-        // traits_type::version_mask bits unused we can use to mark it as in-use
-        reverse[pos] = pos_type(direct.size()) | in_use;
-        direct.emplace_back(entity);
+        reverse[pos] = entity_type(direct.size());
+        direct.push_back(entity);
     }
 
     /**
@@ -321,16 +460,14 @@ public:
      *
      * @param entity A valid entity identifier.
      */
-    virtual void destroy(entity_type entity) {
+    virtual void destroy(const entity_type entity) {
         assert(has(entity));
-        const auto entt = entity & traits_type::entity_mask;
-        const auto back = direct.back() & traits_type::entity_mask;
-        // we must get rid of the in-use bit for it's not part of the position
-        const auto pos = reverse[entt] & traits_type::entity_mask;
-        reverse[back] = reverse[entt];
-        reverse[entt] = pos;
+        const auto back = direct.back();
+        auto &candidate = reverse[entity & traits_type::entity_mask];
         // swapping isn't required here, we are getting rid of the last element
-        direct[pos] = direct.back();
+        reverse[back & traits_type::entity_mask] = candidate;
+        direct[candidate] = back;
+        candidate = null;
         direct.pop_back();
     }
 
@@ -349,13 +486,13 @@ public:
      * @param lhs A valid position within the sparse set.
      * @param rhs A valid position within the sparse set.
      */
-    void swap(pos_type lhs, pos_type rhs) noexcept {
+    void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT {
         assert(lhs < direct.size());
         assert(rhs < direct.size());
-        const auto src = direct[lhs] & traits_type::entity_mask;
-        const auto dst = direct[rhs] & traits_type::entity_mask;
-        std::swap(reverse[src], reverse[dst]);
-        std::swap(direct[lhs], direct[rhs]);
+        auto &src = direct[lhs];
+        auto &dst = direct[rhs];
+        std::swap(reverse[src & traits_type::entity_mask], reverse[dst & traits_type::entity_mask]);
+        std::swap(src, dst);
     }
 
     /**
@@ -377,11 +514,11 @@ public:
      *
      * @param other The sparse sets that imposes the order of the entities.
      */
-    void respect(const SparseSet<Entity> &other) noexcept {
-        auto from = other.begin();
-        auto to = other.end();
+    void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
+        auto from = other.cbegin();
+        auto to = other.cend();
 
-        pos_type pos = direct.size() - 1;
+        size_type pos = direct.size() - 1;
 
         while(pos && from != to) {
             if(has(*from)) {
@@ -405,7 +542,7 @@ public:
     }
 
 private:
-    std::vector<pos_type> reverse;
+    std::vector<entity_type> reverse;
     std::vector<entity_type> direct;
 };
 
@@ -435,55 +572,109 @@ private:
 template<typename Entity, typename Type>
 class SparseSet<Entity, Type>: public SparseSet<Entity> {
     using underlying_type = SparseSet<Entity>;
+    using traits_type = entt_traits<Entity>;
 
-    struct Iterator final {
-        using difference_type = std::size_t;
-        using value_type = Type;
-        using pointer = value_type *;
-        using reference = value_type &;
-        using iterator_category = std::input_iterator_tag;
+    template<bool Const>
+    class Iterator final {
+        friend class SparseSet<Entity, Type>;
 
-        Iterator(std::vector<value_type> &instances, std::size_t pos)
-            : instances{instances}, pos{pos}
+        using instance_type = std::conditional_t<Const, const Type, Type>;
+        using index_type = typename traits_type::difference_type;
+
+        Iterator(instance_type *instances, index_type index) ENTT_NOEXCEPT
+            : instances{instances}, index{index}
         {}
 
-        Iterator & operator++() noexcept {
-            return --pos, *this;
+    public:
+        using difference_type = index_type;
+        using value_type = instance_type;
+        using pointer = value_type *;
+        using reference = value_type &;
+        using iterator_category = std::random_access_iterator_tag;
+
+        Iterator() ENTT_NOEXCEPT = default;
+
+        Iterator(const Iterator &) ENTT_NOEXCEPT = default;
+        Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;
+
+        Iterator & operator++() ENTT_NOEXCEPT {
+            return --index, *this;
         }
 
-        Iterator operator++(int) noexcept {
+        Iterator operator++(int) ENTT_NOEXCEPT {
             Iterator orig = *this;
             return ++(*this), orig;
         }
 
-        Iterator & operator+=(difference_type value) noexcept {
-            pos -= value;
+        Iterator & operator--() ENTT_NOEXCEPT {
+            return ++index, *this;
+        }
+
+        Iterator operator--(int) ENTT_NOEXCEPT {
+            Iterator orig = *this;
+            return --(*this), orig;
+        }
+
+        Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
+            index -= value;
             return *this;
         }
 
-        Iterator operator+(difference_type value) noexcept {
-            return Iterator{instances, pos-value};
+        Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
+            return Iterator{instances, index-value};
         }
 
-        bool operator==(const Iterator &other) const noexcept {
-            return other.pos == pos;
+        inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
+            return (*this += -value);
         }
 
-        bool operator!=(const Iterator &other) const noexcept {
+        inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
+            return (*this + -value);
+        }
+
+        difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
+            return other.index - index;
+        }
+
+        reference operator[](const difference_type value) const ENTT_NOEXCEPT {
+            return instances[index-value-1];
+        }
+
+        bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
+            return other.index == index;
+        }
+
+        inline bool operator!=(const Iterator &other) const ENTT_NOEXCEPT {
             return !(*this == other);
         }
 
-        reference operator*() noexcept {
-            return instances[pos-1];
+        bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
+            return index > other.index;
         }
 
-        pointer operator->() noexcept {
-            return &instances.data()[pos-1];
+        bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
+            return index < other.index;
+        }
+
+        inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
+            return !(*this > other);
+        }
+
+        inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
+            return !(*this < other);
+        }
+
+        pointer operator->() const ENTT_NOEXCEPT {
+            return (instances+index-1);
+        }
+
+        inline reference operator*() const ENTT_NOEXCEPT {
+            return *operator->();
         }
 
     private:
-        std::vector<value_type> &instances;
-        std::size_t pos;
+        pointer instances;
+        index_type index;
     };
 
 public:
@@ -491,15 +682,15 @@ public:
     using object_type = Type;
     /*! @brief Underlying entity identifier. */
     using entity_type = typename underlying_type::entity_type;
-    /*! @brief Entity dependent position type. */
-    using pos_type = typename underlying_type::pos_type;
     /*! @brief Unsigned integer type. */
     using size_type = typename underlying_type::size_type;
     /*! @brief Input iterator type. */
-    using iterator_type = Iterator;
+    using iterator_type = Iterator<false>;
+    /*! @brief Constant input iterator type. */
+    using const_iterator_type = Iterator<true>;
 
     /*! @brief Default constructor. */
-    SparseSet() noexcept = default;
+    SparseSet() ENTT_NOEXCEPT = default;
 
     /*! @brief Copying a sparse set isn't allowed. */
     SparseSet(const SparseSet &) = delete;
@@ -519,7 +710,7 @@ public:
      *
      * @param cap Desired capacity.
      */
-    void reserve(size_type cap) {
+    void reserve(const size_type cap) {
         underlying_type::reserve(cap);
         instances.reserve(cap);
     }
@@ -539,7 +730,7 @@ public:
      *
      * @return A pointer to the array of objects.
      */
-    const object_type * raw() const noexcept {
+    const object_type * raw() const ENTT_NOEXCEPT {
         return instances.data();
     }
 
@@ -558,7 +749,7 @@ public:
      *
      * @return A pointer to the array of objects.
      */
-    object_type * raw() noexcept {
+    object_type * raw() ENTT_NOEXCEPT {
         return instances.data();
     }
 
@@ -574,8 +765,42 @@ public:
      *
      * @return An iterator to the first instance of the given type.
      */
-    iterator_type begin() noexcept {
-        return Iterator{instances, instances.size()};
+    const_iterator_type cbegin() const ENTT_NOEXCEPT {
+        const typename traits_type::difference_type pos = instances.size();
+        return const_iterator_type{instances.data(), pos};
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning.
+     *
+     * The returned iterator points to the first instance of the given type. If
+     * the sparse set is empty, the returned iterator will be equal to `end()`.
+     *
+     * @note
+     * Input iterators stay true to the order imposed by a call to either `sort`
+     * or `respect`.
+     *
+     * @return An iterator to the first instance of the given type.
+     */
+    inline const_iterator_type begin() const ENTT_NOEXCEPT {
+        return cbegin();
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning.
+     *
+     * The returned iterator points to the first instance of the given type. If
+     * the sparse set is empty, the returned iterator will be equal to `end()`.
+     *
+     * @note
+     * Input iterators stay true to the order imposed by a call to either `sort`
+     * or `respect`.
+     *
+     * @return An iterator to the first instance of the given type.
+     */
+    iterator_type begin() ENTT_NOEXCEPT {
+        const typename traits_type::difference_type pos = instances.size();
+        return iterator_type{instances.data(), pos};
     }
 
     /**
@@ -592,8 +817,62 @@ public:
      * @return An iterator to the element following the last instance of the
      * given type.
      */
-    iterator_type end() noexcept {
-        return Iterator{instances, 0};
+    const_iterator_type cend() const ENTT_NOEXCEPT {
+        return const_iterator_type{instances.data(), {}};
+    }
+
+    /**
+     * @brief Returns an iterator to the end.
+     *
+     * The returned iterator points to the element following the last instance
+     * of the given type. Attempting to dereference the returned iterator
+     * results in undefined behavior.
+     *
+     * @note
+     * Input iterators stay true to the order imposed by a call to either `sort`
+     * or `respect`.
+     *
+     * @return An iterator to the element following the last instance of the
+     * given type.
+     */
+    inline const_iterator_type end() const ENTT_NOEXCEPT {
+        return cend();
+    }
+
+    /**
+     * @brief Returns an iterator to the end.
+     *
+     * The returned iterator points to the element following the last instance
+     * of the given type. Attempting to dereference the returned iterator
+     * results in undefined behavior.
+     *
+     * @note
+     * Input iterators stay true to the order imposed by a call to either `sort`
+     * or `respect`.
+     *
+     * @return An iterator to the element following the last instance of the
+     * given type.
+     */
+    iterator_type end() ENTT_NOEXCEPT {
+        return iterator_type{instances.data(), {}};
+    }
+
+    /**
+     * @brief Returns a reference to the element at the given position.
+     * @param pos Position of the element to return.
+     * @return A reference to the requested element.
+     */
+    inline const object_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
+        return cbegin()[pos];
+    }
+
+    /**
+     * @brief Returns a reference to the element at the given position.
+     * @param pos Position of the element to return.
+     * @return A reference to the requested element.
+     */
+    inline object_type & operator[](const size_type pos) ENTT_NOEXCEPT {
+        return const_cast<object_type &>(const_cast<const SparseSet *>(this)->operator[](pos));
     }
 
     /**
@@ -608,7 +887,7 @@ public:
      * @param entity A valid entity identifier.
      * @return The object associated to the entity.
      */
-    const object_type & get(entity_type entity) const noexcept {
+    const object_type & get(const entity_type entity) const ENTT_NOEXCEPT {
         return instances[underlying_type::get(entity)];
     }
 
@@ -624,7 +903,7 @@ public:
      * @param entity A valid entity identifier.
      * @return The object associated to the entity.
      */
-    object_type & get(entity_type entity) noexcept {
+    inline object_type & get(const entity_type entity) ENTT_NOEXCEPT {
         return const_cast<object_type &>(const_cast<const SparseSet *>(this)->get(entity));
     }
 
@@ -650,7 +929,7 @@ public:
      */
     template<typename... Args>
     std::enable_if_t<std::is_constructible<Type, Args...>::value, object_type &>
-    construct(entity_type entity, Args &&... args) {
+    construct(const entity_type entity, Args &&... args) {
         underlying_type::construct(entity);
         instances.emplace_back(std::forward<Args>(args)...);
         return instances.back();
@@ -678,7 +957,7 @@ public:
      */
     template<typename... Args>
     std::enable_if_t<!std::is_constructible<Type, Args...>::value, object_type &>
-    construct(entity_type entity, Args &&... args) {
+    construct(const entity_type entity, Args &&... args) {
         underlying_type::construct(entity);
         instances.emplace_back(Type{std::forward<Args>(args)...});
         return instances.back();
@@ -695,7 +974,7 @@ public:
      *
      * @param entity A valid entity identifier.
      */
-    void destroy(entity_type entity) override {
+    void destroy(const entity_type entity) override {
         // swapping isn't required here, we are getting rid of the last element
         // however, we must protect ourselves from self assignments (see #37)
         auto tmp = std::move(instances.back());
@@ -719,24 +998,42 @@ public:
      * bool(const Type &, const Type &)
      * @endcode
      *
+     * Moreover, the comparison function object shall induce a
+     * _strict weak ordering_ on the values.
+     *
+     * The sort function oject must offer a member function template
+     * `operator()` that accepts three arguments:
+     *
+     * * An iterator to the first element of the range to sort.
+     * * An iterator past the last element of the range to sort.
+     * * A comparison function to use to compare the elements.
+     *
+     * The comparison funtion object received by the sort function object hasn't
+     * necessarily the type of the one passed along with the other parameters to
+     * this member function.
+     *
      * @note
      * Attempting to iterate elements using a raw pointer returned by a call to
      * either `data` or `raw` gives no guarantees on the order, even though
      * `sort` has been invoked.
      *
      * @tparam Compare Type of comparison function object.
+     * @tparam Sort Type of sort function object.
+     * @tparam Args Types of arguments to forward to the sort function object.
      * @param compare A valid comparison function object.
+     * @param sort A valid sort function object.
+     * @param args Arguments to forward to the sort function object, if any.
      */
-    template<typename Compare>
-    void sort(Compare compare) {
-        std::vector<pos_type> copy(instances.size());
+    template<typename Compare, typename Sort = StdSort, typename... Args>
+    void sort(Compare compare, Sort sort = Sort{}, Args &&... args) {
+        std::vector<size_type> copy(instances.size());
         std::iota(copy.begin(), copy.end(), 0);
 
-        std::sort(copy.begin(), copy.end(), [this, compare = std::move(compare)](auto lhs, auto rhs) {
+        sort(copy.begin(), copy.end(), [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
             return compare(const_cast<const object_type &>(instances[rhs]), const_cast<const object_type &>(instances[lhs]));
-        });
+        }, std::forward<Args>(args)...);
 
-        for(pos_type pos = 0, last = copy.size(); pos < last; ++pos) {
+        for(size_type pos = 0, last = copy.size(); pos < last; ++pos) {
             auto curr = pos;
             auto next = copy[curr];
 
@@ -775,11 +1072,11 @@ public:
      *
      * @param other The sparse sets that imposes the order of the entities.
      */
-    void respect(const SparseSet<Entity> &other) noexcept {
-        auto from = other.begin();
-        auto to = other.end();
+    void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
+        auto from = other.cbegin();
+        auto to = other.cend();
 
-        pos_type pos = underlying_type::size() - 1;
+        size_type pos = underlying_type::size() - 1;
         const auto *local = underlying_type::data();
 
         while(pos && from != to) {

src/entt/entity/utility.hpp

@@ -0,0 +1,27 @@
+#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 {};
+
+
+/*! @brief Break type used to disambiguate overloads. */
+struct break_t final {};
+
+
+}
+
+
+#endif // ENTT_ENTITY_UTILITY_HPP

src/entt/entt.hpp

@@ -1,11 +1,17 @@
+#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/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"
@@ -13,9 +19,7 @@
 #include "resource/cache.hpp"
 #include "resource/handle.hpp"
 #include "resource/loader.hpp"
-#include "signal/bus.hpp"
 #include "signal/delegate.hpp"
 #include "signal/dispatcher.hpp"
 #include "signal/emitter.hpp"
 #include "signal/sigh.hpp"
-#include "signal/signal.hpp"

src/entt/locator/locator.hpp

@@ -5,6 +5,7 @@
 #include <memory>
 #include <utility>
 #include <cassert>
+#include "../config/config.h"
 
 
 namespace entt {
@@ -35,7 +36,7 @@ struct ServiceLocator final {
      * @brief Tests if a valid service implementation is set.
      * @return True if the service is set, false otherwise.
      */
-    inline static bool empty() noexcept {
+    inline static bool empty() ENTT_NOEXCEPT {
         return !static_cast<bool>(service);
     }
 
@@ -49,7 +50,7 @@ struct ServiceLocator final {
      *
      * @return A reference to the service implementation currently set, if any.
      */
-    inline static std::weak_ptr<Service> get() noexcept {
+    inline static std::weak_ptr<Service> get() ENTT_NOEXCEPT {
         return service;
     }
 
@@ -67,7 +68,7 @@ struct ServiceLocator final {
      *
      * @return A reference to the service implementation currently set, if any.
      */
-    inline static Service & ref() noexcept {
+    inline static Service & ref() ENTT_NOEXCEPT {
         return *service;
     }
 

src/entt/process/process.hpp

@@ -5,6 +5,7 @@
 #include <type_traits>
 #include <functional>
 #include <utility>
+#include "../config/config.h"
 
 
 namespace entt {
@@ -114,7 +115,7 @@ class Process {
     }
 
     template<State S, typename... Args>
-    void tick(char, tag<S>, Args &&...) {}
+    void tick(char, tag<S>, Args &&...) const ENTT_NOEXCEPT {}
 
 protected:
     /**
@@ -123,7 +124,7 @@ protected:
      * The function is idempotent and it does nothing if the process isn't
      * alive.
      */
-    void succeed() noexcept {
+    void succeed() ENTT_NOEXCEPT {
         if(alive()) {
             current = State::SUCCEEDED;
         }
@@ -135,7 +136,7 @@ protected:
      * The function is idempotent and it does nothing if the process isn't
      * alive.
      */
-    void fail() noexcept {
+    void fail() ENTT_NOEXCEPT {
         if(alive()) {
             current = State::FAILED;
         }
@@ -147,7 +148,7 @@ protected:
      * The function is idempotent and it does nothing if the process isn't
      * running.
      */
-    void pause() noexcept {
+    void pause() ENTT_NOEXCEPT {
         if(current == State::RUNNING) {
             current = State::PAUSED;
         }
@@ -159,7 +160,7 @@ protected:
      * The function is idempotent and it does nothing if the process isn't
      * paused.
      */
-    void unpause() noexcept {
+    void unpause() ENTT_NOEXCEPT {
         if(current  == State::PAUSED) {
             current  = State::RUNNING;
         }
@@ -170,7 +171,7 @@ public:
     using delta_type = Delta;
 
     /*! @brief Default destructor. */
-    virtual ~Process() noexcept {
+    virtual ~Process() ENTT_NOEXCEPT {
         static_assert(std::is_base_of<Process, Derived>::value, "!");
     }
 
@@ -182,7 +183,7 @@ public:
      *
      * @param immediately Requests an immediate operation.
      */
-    void abort(bool immediately = false) noexcept {
+    void abort(const bool immediately = false) ENTT_NOEXCEPT {
         if(alive()) {
             current = State::ABORTED;
 
@@ -196,7 +197,7 @@ public:
      * @brief Returns true if a process is either running or paused.
      * @return True if the process is still alive, false otherwise.
      */
-    bool alive() const noexcept {
+    bool alive() const ENTT_NOEXCEPT {
         return current == State::RUNNING || current == State::PAUSED;
     }
 
@@ -204,7 +205,7 @@ public:
      * @brief Returns true if a process is already terminated.
      * @return True if the process is terminated, false otherwise.
      */
-    bool dead() const noexcept {
+    bool dead() const ENTT_NOEXCEPT {
         return current == State::FINISHED;
     }
 
@@ -212,7 +213,7 @@ public:
      * @brief Returns true if a process is currently paused.
      * @return True if the process is paused, false otherwise.
      */
-    bool paused() const noexcept {
+    bool paused() const ENTT_NOEXCEPT {
         return current == State::PAUSED;
     }
 
@@ -220,7 +221,7 @@ public:
      * @brief Returns true if a process terminated with errors.
      * @return True if the process terminated with errors, false otherwise.
      */
-    bool rejected() const noexcept {
+    bool rejected() const ENTT_NOEXCEPT {
         return stopped;
     }
 
@@ -229,7 +230,7 @@ public:
      * @param delta Elapsed time.
      * @param data Optional data.
      */
-    void tick(Delta delta, void *data = nullptr) {
+    void tick(const Delta delta, void *data = nullptr) {
         switch (current) {
         case State::UNINITIALIZED:
             tick(0, tag<State::UNINITIALIZED>{}, data);
@@ -326,7 +327,7 @@ struct ProcessAdaptor: Process<ProcessAdaptor<Func, Delta>, Delta>, private Func
      * @param delta Elapsed time.
      * @param data Optional data.
      */
-    void update(Delta delta, void *data) {
+    void update(const Delta delta, void *data) {
         Func::operator()(delta, data, [this]() { this->succeed(); }, [this]() { this->fail(); });
     }
 };

src/entt/process/scheduler.hpp

@@ -5,9 +5,9 @@
 #include <vector>
 #include <memory>
 #include <utility>
-#include <iterator>
 #include <algorithm>
 #include <type_traits>
+#include "../config/config.h"
 #include "process.hpp"
 
 
@@ -42,31 +42,27 @@ namespace entt {
  */
 template<typename Delta>
 class Scheduler final {
-    template<typename T>
-    struct tag { using type = T; };
-
     struct ProcessHandler final {
         using instance_type = std::unique_ptr<void, void(*)(void *)>;
-        using update_type = bool(*)(ProcessHandler &, Delta, void *);
-        using abort_type = void(*)(ProcessHandler &, bool);
+        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_type update;
-        abort_type abort;
+        update_fn_type *update;
+        abort_fn_type *abort;
         next_type next;
     };
 
-    template<typename Lambda>
-    struct Then final: Lambda {
-        Then(Lambda &&lambda, ProcessHandler *handler)
-            : Lambda{std::forward<Lambda>(lambda)}, handler{handler}
+    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 = Lambda::operator()(handler, tag<Proc>{}, std::forward<Args>(args)...);
+            handler = Scheduler::then<Proc>(handler, std::forward<Args>(args)...);
             return std::move(*this);
         }
 
@@ -81,7 +77,7 @@ class Scheduler final {
     };
 
     template<typename Proc>
-    static bool update(ProcessHandler &handler, Delta delta, void *data) {
+    static bool update(ProcessHandler &handler, const Delta delta, void *data) {
         auto *process = static_cast<Proc *>(handler.instance.get());
         process->tick(delta, data);
 
@@ -100,7 +96,7 @@ class Scheduler final {
     }
 
     template<typename Proc>
-    static void abort(ProcessHandler &handler, bool immediately) {
+    static void abort(ProcessHandler &handler, const bool immediately) {
         static_cast<Proc *>(handler.instance.get())->abort(immediately);
     }
 
@@ -109,20 +105,15 @@ class Scheduler final {
         delete static_cast<Proc *>(proc);
     }
 
-    auto then(ProcessHandler *handler) {
-        auto lambda = [](ProcessHandler *handler, auto next, auto... args) {
-            using Proc = typename decltype(next)::type;
+    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();
+        }
 
-            if(handler) {
-                auto proc = typename ProcessHandler::instance_type{new Proc{std::forward<decltype(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;
-        };
-
-        return Then<decltype(lambda)>{std::move(lambda), handler};
+        return handler;
     }
 
 public:
@@ -130,7 +121,7 @@ public:
     using size_type = typename std::vector<ProcessHandler>::size_type;
 
     /*! @brief Default constructor. */
-    Scheduler() noexcept= default;
+    Scheduler() ENTT_NOEXCEPT = default;
 
     /*! @brief Copying a scheduler isn't allowed. */
     Scheduler(const Scheduler &) = delete;
@@ -139,14 +130,14 @@ public:
 
     /*! @brief Copying a scheduler isn't allowed. @return This scheduler. */
     Scheduler & operator=(const Scheduler &) = delete;
-    /*! @brief Default move assignament operator. @return This scheduler. */
+    /*! @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 noexcept {
+    size_type size() const ENTT_NOEXCEPT {
         return handlers.size();
     }
 
@@ -154,7 +145,7 @@ public:
      * @brief Returns true if at least a process is currently scheduled.
      * @return True if there are scheduled processes, false otherwise.
      */
-    bool empty() const noexcept {
+    bool empty() const ENTT_NOEXCEPT {
         return handlers.empty();
     }
 
@@ -201,7 +192,7 @@ public:
         ProcessHandler handler{std::move(proc), &Scheduler::update<Proc>, &Scheduler::abort<Proc>, nullptr};
         handlers.push_back(std::move(handler));
 
-        return then(&handlers.back());
+        return Then{&handlers.back()};
     }
 
     /**
@@ -271,7 +262,7 @@ public:
      * @param delta Elapsed time.
      * @param data Optional data.
      */
-    void update(Delta delta, void *data = nullptr) {
+    void update(const Delta delta, void *data = nullptr) {
         bool clean = false;
 
         for(auto pos = handlers.size(); pos; --pos) {
@@ -297,7 +288,7 @@ public:
      *
      * @param immediately Requests an immediate operation.
      */
-    void abort(bool immediately = false) {
+    void abort(const bool immediately = false) {
         decltype(handlers) exec;
         exec.swap(handlers);
 

src/entt/resource/cache.hpp

@@ -6,6 +6,7 @@
 #include <utility>
 #include <type_traits>
 #include <unordered_map>
+#include "../config/config.h"
 #include "../core/hashed_string.hpp"
 #include "handle.hpp"
 #include "loader.hpp"
@@ -38,20 +39,20 @@ public:
     ResourceCache() = default;
 
     /*! @brief Copying a cache isn't allowed. */
-    ResourceCache(const ResourceCache &) noexcept = delete;
+    ResourceCache(const ResourceCache &) ENTT_NOEXCEPT = delete;
     /*! @brief Default move constructor. */
-    ResourceCache(ResourceCache &&) noexcept = default;
+    ResourceCache(ResourceCache &&) ENTT_NOEXCEPT = default;
 
     /*! @brief Copying a cache isn't allowed. @return This cache. */
-    ResourceCache & operator=(const ResourceCache &) noexcept = delete;
+    ResourceCache & operator=(const ResourceCache &) ENTT_NOEXCEPT = delete;
     /*! @brief Default move assignment operator. @return This cache. */
-    ResourceCache & operator=(ResourceCache &&) noexcept = default;
+    ResourceCache & operator=(ResourceCache &&) ENTT_NOEXCEPT = default;
 
     /**
      * @brief Number of resources managed by a cache.
      * @return Number of resources currently stored.
      */
-    size_type size() const noexcept {
+    size_type size() const ENTT_NOEXCEPT {
         return resources.size();
     }
 
@@ -59,7 +60,7 @@ public:
      * @brief Returns true if a cache contains no resources, false otherwise.
      * @return True if the cache contains no resources, false otherwise.
      */
-    bool empty() const noexcept {
+    bool empty() const ENTT_NOEXCEPT {
         return resources.empty();
     }
 
@@ -69,7 +70,7 @@ public:
      * 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() noexcept {
+    void clear() ENTT_NOEXCEPT {
         resources.clear();
     }
 
@@ -92,7 +93,7 @@ public:
      * @return True if the resource is ready to use, false otherwise.
      */
     template<typename Loader, typename... Args>
-    bool load(resource_type id, Args &&... args) {
+    bool load(const resource_type id, Args &&... args) {
         static_assert(std::is_base_of<ResourceLoader<Loader, Resource>, Loader>::value, "!");
 
         bool loaded = true;
@@ -125,7 +126,7 @@ public:
      * @return True if the resource is ready to use, false otherwise.
      */
     template<typename Loader, typename... Args>
-    bool reload(resource_type id, Args &&... args) {
+    bool reload(const resource_type id, Args &&... args) {
         return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
     }
 
@@ -159,7 +160,7 @@ public:
      * @param id Unique resource identifier.
      * @return A handle for the given resource.
      */
-    ResourceHandle<Resource> handle(resource_type id) const {
+    ResourceHandle<Resource> handle(const resource_type id) const {
         auto it = resources.find(id);
         return { it == resources.end() ? nullptr : it->second };
     }
@@ -169,8 +170,8 @@ public:
      * @param id Unique resource identifier.
      * @return True if the cache contains the resource, false otherwise.
      */
-    bool contains(resource_type id) const noexcept {
-        return !(resources.find(id) == resources.cend());
+    bool contains(const resource_type id) const ENTT_NOEXCEPT {
+        return (resources.find(id) != resources.cend());
     }
 
     /**
@@ -181,7 +182,7 @@ public:
      *
      * @param id Unique resource identifier.
      */
-    void discard(resource_type id) noexcept {
+    void discard(const resource_type id) ENTT_NOEXCEPT {
         auto it = resources.find(id);
 
         if(it != resources.end()) {

src/entt/resource/handle.hpp

@@ -5,6 +5,7 @@
 #include <memory>
 #include <utility>
 #include <cassert>
+#include "../config/config.h"
 
 
 namespace entt {
@@ -31,20 +32,20 @@ class ResourceHandle final {
     /*! @brief Resource handles are friends of their caches. */
     friend class ResourceCache<Resource>;
 
-    ResourceHandle(std::shared_ptr<Resource> res) noexcept
+    ResourceHandle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
         : resource{std::move(res)}
     {}
 
 public:
     /*! @brief Default copy constructor. */
-    ResourceHandle(const ResourceHandle &) noexcept = default;
+    ResourceHandle(const ResourceHandle &) ENTT_NOEXCEPT = default;
     /*! @brief Default move constructor. */
-    ResourceHandle(ResourceHandle &&) noexcept = default;
+    ResourceHandle(ResourceHandle &&) ENTT_NOEXCEPT = default;
 
     /*! @brief Default copy assignment operator. @return This handle. */
-    ResourceHandle & operator=(const ResourceHandle &) noexcept = default;
+    ResourceHandle & operator=(const ResourceHandle &) ENTT_NOEXCEPT = default;
     /*! @brief Default move assignment operator. @return This handle. */
-    ResourceHandle & operator=(ResourceHandle &&) noexcept = default;
+    ResourceHandle & operator=(ResourceHandle &&) ENTT_NOEXCEPT = default;
 
     /**
      * @brief Gets a reference to the managed resource.
@@ -56,7 +57,7 @@ public:
      *
      * @return A reference to the managed resource.
      */
-    const Resource & get() const noexcept {
+    const Resource & get() const ENTT_NOEXCEPT {
         assert(static_cast<bool>(resource));
         return *resource;
     }
@@ -69,7 +70,7 @@ public:
      * An assertion will abort the execution at runtime in debug mode if the
      * handle is empty.
      */
-    inline operator const Resource & () const noexcept { return get(); }
+    inline operator const Resource &() const ENTT_NOEXCEPT { return get(); }
 
     /**
      * @brief Dereferences a handle to obtain the managed resource.
@@ -81,10 +82,10 @@ public:
      *
      * @return A reference to the managed resource.
      */
-    inline const Resource & operator *() const noexcept { return get(); }
+    inline const Resource & operator *() const ENTT_NOEXCEPT { return get(); }
 
     /**
-     * @brief Gets a pointer to the managed resource from a handle .
+     * @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/>
@@ -94,7 +95,7 @@ public:
      * @return A pointer to the managed resource or `nullptr` if the handle
      * contains no resource at all.
      */
-    inline const Resource * operator ->() const noexcept {
+    inline const Resource * operator ->() const ENTT_NOEXCEPT {
         assert(static_cast<bool>(resource));
         return resource.get();
     }

src/entt/signal/bus.hpp

@@ -1,305 +0,0 @@
-#ifndef ENTT_SIGNAL_BUS_HPP
-#define ENTT_SIGNAL_BUS_HPP
-
-
-#include <cstddef>
-#include <utility>
-#include "signal.hpp"
-#include "sigh.hpp"
-
-
-namespace entt {
-
-
-/**
- * @brief Minimal event bus.
- *
- * Primary template isn't defined on purpose. The main reason for which it
- * exists is to work around the doxygen's parsing capabilities. In fact, there
- * is no need to declare it actually.
- */
-template<template<typename...> class, typename...>
-class Bus;
-
-
-/**
- * @brief Event bus specialization for multiple types.
- *
- * The event bus is designed to allow an easy registration of specific member
- * functions to a bunch of signal handlers (either manager or unmanaged).
- * Classes must publicly expose the required member functions to allow the bus
- * to detect them for the purpose of registering and unregistering
- * instances.<br/>
- * In particular, for each event type `E`, a matching member function has the
- * following signature: `void receive(const E &)`. Events will be properly
- * redirected to all the listeners by calling the right member functions, if
- * any.
- *
- * @tparam Sig Type of signal handler to use.
- * @tparam Event The list of events managed by the bus.
- */
-template<template<typename...> class Sig, typename Event, typename... Other>
-class Bus<Sig, Event, Other...>
-        : private Bus<Sig, Event>, private Bus<Sig, Other>...
-{
-public:
-    /*! @brief Unsigned integer type. */
-    using size_type = std::size_t;
-
-    /**
-     * @brief Unregisters all the member functions of an instance.
-     *
-     * A bus is used to convey a certain set of events. This method detects
-     * and unregisters from the bus all the matching member functions of an
-     * instance.<br/>
-     * For each event type `E`, a matching member function has the following
-     * signature: `void receive(const E &)`.
-     *
-     * @tparam Instance Type of instance to unregister.
-     * @param instance A valid instance of the right type.
-     */
-    template<typename Instance>
-    void unreg(Instance instance) {
-        using accumulator_type = int[];
-        accumulator_type accumulator = {
-            (Bus<Sig, Event>::unreg(instance), 0),
-            (Bus<Sig, Other>::unreg(instance), 0)...
-        };
-        return void(accumulator);
-    }
-
-    /**
-     * @brief Registers all the member functions of an instance.
-     *
-     * A bus is used to convey a certain set of events. This method detects
-     * and registers to the bus all the matching member functions of an
-     * instance.<br/>
-     * For each event type `E`, a matching member function has the following
-     * signature: `void receive(const E &)`.
-     *
-     * @tparam Instance Type of instance to register.
-     * @param instance A valid instance of the right type.
-     */
-    template<typename Instance>
-    void reg(Instance instance) {
-        using accumulator_type = int[];
-        accumulator_type accumulator = {
-            (Bus<Sig, Event>::reg(instance), 0),
-            (Bus<Sig, Other>::reg(instance), 0)...
-        };
-        return void(accumulator);
-    }
-
-    /**
-     * @brief Number of listeners connected to the bus.
-     * @return Number of listeners currently connected.
-     */
-    size_type size() const noexcept {
-        using accumulator_type = std::size_t[];
-        std::size_t sz = Bus<Sig, Event>::size();
-        accumulator_type accumulator = { sz, (sz += Bus<Sig, Other>::size())... };
-        return void(accumulator), sz;
-    }
-
-    /**
-     * @brief Returns false if at least a listener is connected to the bus.
-     * @return True if the bus has no listeners connected, false otherwise.
-     */
-    bool empty() const noexcept {
-        using accumulator_type = bool[];
-        bool ret = Bus<Sig, Event>::empty();
-        accumulator_type accumulator = { ret, (ret = ret && Bus<Sig, Other>::empty())... };
-        return void(accumulator), ret;
-    }
-
-    /**
-     * @brief Connects a free function to the bus.
-     * @tparam Type Type of event to which to connect the function.
-     * @tparam Function A valid free function pointer.
-     */
-    template<typename Type, void(*Function)(const Type &)>
-    void connect() {
-        Bus<Sig, Type>::template connect<Function>();
-    }
-
-    /**
-     * @brief Disconnects a free function from the bus.
-     * @tparam Type Type of event from which to disconnect the function.
-     * @tparam Function A valid free function pointer.
-     */
-    template<typename Type, void(*Function)(const Type &)>
-    void disconnect() {
-        Bus<Sig, Type>::template disconnect<Function>();
-    }
-
-    /**
-     * @brief Publishes an event.
-     *
-     * All the listeners are notified. Order isn't guaranteed.
-     *
-     * @tparam Type Type of event to publish.
-     * @tparam Args Types of arguments to use to construct the event.
-     * @param args Arguments to use to construct the event.
-     */
-    template<typename Type, typename... Args>
-    void publish(Args &&... args) {
-        Bus<Sig, Type>::publish(std::forward<Args>(args)...);
-    }
-};
-
-
-/**
- * @brief Event bus specialization for a single type.
- *
- * The event bus is designed to allow an easy registration of a specific member
- * function to a signal handler (either manager or unmanaged).
- * Classes must publicly expose the required member function to allow the bus to
- * detect it for the purpose of registering and unregistering instances.<br/>
- * In particular, a matching member function has the following signature:
- * `void receive(const Event &)`. Events of the given type will be properly
- * redirected to all the listeners by calling the right member function, if any.
- *
- * @tparam Sig Type of signal handler to use.
- * @tparam Event Type of event managed by the bus.
- */
-template<template<typename...> class Sig, typename Event>
-class Bus<Sig, Event> {
-    using signal_type = Sig<void(const Event &)>;
-
-    template<typename Class>
-    using instance_type = typename signal_type::template instance_type<Class>;
-
-    template<typename Class>
-    auto disconnect(int, instance_type<Class> instance)
-    -> decltype(std::declval<Class>().receive(std::declval<Event>()), void()) {
-        signal.template disconnect<Class, &Class::receive>(std::move(instance));
-    }
-
-    template<typename Class>
-    auto connect(int, instance_type<Class> instance)
-    -> decltype(std::declval<Class>().receive(std::declval<Event>()), void()) {
-        signal.template connect<Class, &Class::receive>(std::move(instance));
-    }
-
-    template<typename Class> void disconnect(char, instance_type<Class>) {}
-    template<typename Class> void connect(char, instance_type<Class>) {}
-
-public:
-    /*! @brief Unsigned integer type. */
-    using size_type = typename signal_type::size_type;
-
-    /**
-     * @brief Unregisters member functions of instances.
-     *
-     * This method tries to detect and unregister from the bus matching member
-     * functions of instances.<br/>
-     * A matching member function has the following signature:
-     * `void receive(const Event &)`.
-     *
-     * @tparam Class Type of instance to unregister.
-     * @param instance A valid instance of the right type.
-     */
-    template<typename Class>
-    void unreg(instance_type<Class> instance) {
-        disconnect(0, std::move(instance));
-    }
-
-    /**
-     * @brief Tries to register an instance.
-     *
-     * This method tries to detect and register to the bus matching member
-     * functions of instances.<br/>
-     * A matching member function has the following signature:
-     * `void receive(const Event &)`.
-     *
-     * @tparam Class Type of instance to register.
-     * @param instance A valid instance of the right type.
-     */
-    template<typename Class>
-    void reg(instance_type<Class> instance) {
-        connect(0, std::move(instance));
-    }
-
-    /**
-     * @brief Number of listeners connected to the bus.
-     * @return Number of listeners currently connected.
-     */
-    size_type size() const noexcept {
-        return signal.size();
-    }
-
-    /**
-     * @brief Returns false if at least a listener is connected to the bus.
-     * @return True if the bus has no listeners connected, false otherwise.
-     */
-    bool empty() const noexcept {
-        return signal.empty();
-    }
-
-    /**
-     * @brief Connects a free function to the bus.
-     * @tparam Function A valid free function pointer.
-     */
-    template<void(*Function)(const Event &)>
-    void connect() {
-        signal.template connect<Function>();
-    }
-
-    /**
-     * @brief Disconnects a free function from the bus.
-     * @tparam Function A valid free function pointer.
-     */
-    template<void(*Function)(const Event &)>
-    void disconnect() {
-        signal.template disconnect<Function>();
-    }
-
-    /**
-     * @brief Publishes an event.
-     *
-     * All the listeners are notified. Order isn't guaranteed.
-     *
-     * @tparam Args Types of arguments to use to construct the event.
-     * @param args Arguments to use to construct the event.
-     */
-    template<typename... Args>
-    void publish(Args &&... args) {
-        signal.publish({ std::forward<Args>(args)... });
-    }
-
-private:
-    signal_type signal;
-};
-
-
-/**
- * @brief Managed event bus.
- *
- * A managed event bus uses the Signal class template as an underlying type. The
- * type of the instances is the one required by the signal handler:
- * `std::shared_ptr<Class>` (a shared pointer).
- *
- * @tparam Event The list of events managed by the bus.
- */
-template<typename... Event>
-using ManagedBus = Bus<Signal, Event...>;
-
-/**
- * @brief Unmanaged event bus.
- *
- * An unmanaged event bus uses the SigH class template as an underlying type.
- * The type of the instances is the one required by the signal handler:
- * `Class *` (a naked pointer).<br/>
- * When it comes to work with this kind of bus, users must guarantee that the
- * lifetimes of the instances overcome the one of the bus itself.
- *
- * @tparam Event The list of events managed by the bus.
- */
-template<typename... Event>
-using UnmanagedBus = Bus<SigH, Event...>;
-
-
-}
-
-
-#endif // ENTT_SIGNAL_BUS_HPP

src/entt/signal/delegate.hpp

@@ -3,6 +3,7 @@
 
 
 #include <utility>
+#include "../config/config.h"
 
 
 namespace entt {
@@ -33,33 +34,40 @@ class Delegate;
  */
 template<typename Ret, typename... Args>
 class Delegate<Ret(Args...)> final {
-    using proto_type = Ret(*)(void *, Args...);
-    using stub_type = std::pair<void *, proto_type>;
-
-    static Ret fallback(void *, Args...) noexcept { return {}; }
+    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...)>
+    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() noexcept
-        : stub{std::make_pair(nullptr, &fallback)}
+    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() noexcept {
+    void connect() ENTT_NOEXCEPT {
         stub = std::make_pair(nullptr, &proto<Function>);
     }
 
@@ -74,8 +82,8 @@ public:
      * @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) noexcept {
+    template<typename Class, Ret(Class:: *Member)(Args...)>
+    void connect(Class *instance) ENTT_NOEXCEPT {
         stub = std::make_pair(instance, &proto<Class, Member>);
     }
 
@@ -84,8 +92,8 @@ public:
      *
      * After a reset, a delegate can be safely invoked with no effect.
      */
-    void reset() noexcept {
-        stub = std::make_pair(nullptr, &fallback);
+    void reset() ENTT_NOEXCEPT {
+        stub.second = nullptr;
     }
 
     /**
@@ -93,7 +101,7 @@ public:
      * @param args Arguments to use to invoke the underlying function.
      * @return The value returned by the underlying function.
      */
-    Ret operator()(Args... args) {
+    Ret operator()(Args... args) const {
         return stub.second(stub.first, args...);
     }
 
@@ -105,7 +113,7 @@ public:
      * @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 noexcept {
+    bool operator==(const Delegate<Ret(Args...)> &other) const ENTT_NOEXCEPT {
         return stub.first == other.stub.first && stub.second == other.stub.second;
     }
 
@@ -126,7 +134,7 @@ private:
  * @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) noexcept {
+bool operator!=(const Delegate<Ret(Args...)> &lhs, const Delegate<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
     return !(lhs == rhs);
 }
 

src/entt/signal/dispatcher.hpp

@@ -6,8 +6,10 @@
 #include <memory>
 #include <utility>
 #include <cstdint>
+#include <algorithm>
+#include <type_traits>
+#include "../config/config.h"
 #include "../core/family.hpp"
-#include "signal.hpp"
 #include "sigh.hpp"
 
 
@@ -20,42 +22,40 @@ namespace entt {
  * 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 signature:
- * `void(const Event &)`. Member functions named `receive` are automatically
- * detected and registered or unregistered by the dispatcher.
+ * type `Event`, listeners must have the following function type:
+ * @code{.cpp}
+ * void(const Event &)
+ * @endcode
  *
- * @tparam Sig Type of the signal handler to use.
+ * 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.
  */
-template<template<typename...> class Sig>
 class Dispatcher final {
     using event_family = Family<struct InternalDispatcherEventFamily>;
 
     template<typename Class, typename Event>
-    using instance_type = typename Sig<void(const Event &)>::template instance_type<Class>;
+    using instance_type = typename SigH<void(const Event &)>::template instance_type<Class>;
 
     struct BaseSignalWrapper {
         virtual ~BaseSignalWrapper() = default;
-        virtual void publish(std::size_t) = 0;
+        virtual void publish() = 0;
     };
 
     template<typename Event>
     struct SignalWrapper final: BaseSignalWrapper {
-        void publish(std::size_t current) override {
-            for(const auto &event: events[current]) {
-                signal.publish(event);
-            }
+        using sink_type = typename SigH<void(const Event &)>::sink_type;
 
-            events[current].clear();
+        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();
         }
 
-        template<typename Class, void(Class::*Member)(const Event &)>
-        inline void connect(instance_type<Class, Event> instance) noexcept {
-            signal.template connect<Class, Member>(std::move(instance));
-        }
-
-        template<typename Class, void(Class::*Member)(const Event &)>
-        inline void disconnect(instance_type<Class, Event> instance) noexcept {
-            signal.template disconnect<Class, Member>(std::move(instance));
+        inline sink_type sink() ENTT_NOEXCEPT {
+            return signal.sink();
         }
 
         template<typename... Args>
@@ -64,19 +64,16 @@ class Dispatcher final {
         }
 
         template<typename... Args>
-        inline void enqueue(std::size_t current, Args &&... args) {
+        inline void enqueue(Args &&... args) {
             events[current].push_back({ std::forward<Args>(args)... });
         }
 
     private:
-        Sig<void(const Event &)> signal{};
+        SigH<void(const Event &)> signal{};
         std::vector<Event> events[2];
+        int current{};
     };
 
-    inline static std::size_t buffer(bool mode) {
-        return mode ? 0 : 1;
-    }
-
     template<typename Event>
     SignalWrapper<Event> & wrapper() {
         const auto type = event_family::type<Event>();
@@ -93,52 +90,30 @@ class Dispatcher final {
     }
 
 public:
-    /*! @brief Default constructor. */
-    Dispatcher() noexcept
-        : wrappers{}, mode{false}
-    {}
+    /*! @brief Type of sink for the given event. */
+    template<typename Event>
+    using sink_type = typename SignalWrapper<Event>::sink_type;
 
     /**
-     * @brief Registers a listener given in the form of a member function.
+     * @brief Returns a sink object for the given event.
      *
-     * A matching member function has the following signature:
-     * `void receive(const Event &)`. Member functions named `receive` are
-     * automatically detected and registered if available.
+     * A sink is an opaque object used to connect listeners to events.
      *
-     * @warning
-     * Connecting a listener during an update may lead to unexpected behavior.
-     * Register listeners before or after invoking the update if possible.
+     * The function type for a listener is:
+     * @code{.cpp}
+     * void(const Event &)
+     * @endcode
      *
-     * @tparam Event Type of event to which to connect the function.
-     * @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 the right type.
+     * 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, typename Class, void(Class::*Member)(const Event &) = &Class::receive>
-    void connect(instance_type<Class, Event> instance) noexcept {
-        wrapper<Event>().template connect<Class, Member>(std::move(instance));
-    }
-
-    /**
-     * @brief Unregisters a listener given in the form of a member function.
-     *
-     * A matching member function has the following signature:
-     * `void receive(const Event &)`. Member functions named `receive` are
-     * automatically detected and unregistered if available.
-     *
-     * @warning
-     * Disconnecting a listener during an update may lead to unexpected
-     * behavior. Unregister listeners before or after invoking the update if
-     * possible.
-     *
-     * @tparam Event Type of event from which to disconnect the function.
-     * @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 the right type.
-     */
-    template<typename Event, typename Class, void(Class::*Member)(const Event &) = &Class::receive>
-    void disconnect(instance_type<Class, Event> instance) noexcept {
-        wrapper<Event>().template disconnect<Class, Member>(std::move(instance));
+    template<typename Event>
+    inline sink_type<Event> sink() ENTT_NOEXCEPT {
+        return wrapper<Event>().sink();
     }
 
     /**
@@ -152,7 +127,7 @@ public:
      * @param args Arguments to use to construct the event.
      */
     template<typename Event, typename... Args>
-    void trigger(Args &&... args) {
+    inline void trigger(Args &&... args) {
         wrapper<Event>().trigger(std::forward<Args>(args)...);
     }
 
@@ -167,58 +142,46 @@ public:
      * @param args Arguments to use to construct the event.
      */
     template<typename Event, typename... Args>
-    void enqueue(Args &&... args) {
-        wrapper<Event>().enqueue(buffer(mode), std::forward<Args>(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 responsability of the users
+     * 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.
      */
-    void update() {
-        const auto buf = buffer(mode);
-        mode = !mode;
-
+    inline void update() const {
         for(auto pos = wrappers.size(); pos; --pos) {
             auto &wrapper = wrappers[pos-1];
 
             if(wrapper) {
-                wrapper->publish(buf);
+                wrapper->publish();
             }
         }
     }
 
 private:
     std::vector<std::unique_ptr<BaseSignalWrapper>> wrappers;
-    bool mode;
 };
 
 
-/**
- * @brief Managed dispatcher.
- *
- * A managed dispatcher uses the Signal class template as an underlying type.
- * The type of the instances is the one required by the signal handler:
- * `std::shared_ptr<Class>` (a shared pointer).
- */
-using ManagedDispatcher = Dispatcher<Signal>;
-
-
-/**
- * @brief Unmanaged dispatcher.
- *
- * An unmanaged dispatcher uses the SigH class template as an underlying type.
- * The type of the instances is the one required by the signal handler:
- * `Class *` (a naked pointer).<br/>
- * When it comes to work with this kind of dispatcher, users must guarantee that
- * the lifetimes of the instances overcome the one of the dispatcher itself.
- */
-using UnmanagedDispatcher = Dispatcher<SigH>;
-
-
 }
 
 

src/entt/signal/emitter.hpp

@@ -10,6 +10,8 @@
 #include <memory>
 #include <vector>
 #include <list>
+#include "../config/config.h"
+#include "../core/family.hpp"
 
 
 namespace entt {
@@ -38,10 +40,12 @@ namespace entt {
  */
 template<typename Derived>
 class Emitter {
+    using handler_family = Family<struct InternalEmitterHandlerFamily>;
+
     struct BaseHandler {
         virtual ~BaseHandler() = default;
-        virtual bool empty() const noexcept = 0;
-        virtual void clear() noexcept = 0;
+        virtual bool empty() const ENTT_NOEXCEPT = 0;
+        virtual void clear() ENTT_NOEXCEPT = 0;
     };
 
     template<typename Event>
@@ -51,14 +55,14 @@ class Emitter {
         using container_type = std::list<element_type>;
         using connection_type = typename container_type::iterator;
 
-        bool empty() const noexcept override {
+        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() noexcept override {
+        void clear() ENTT_NOEXCEPT override {
             if(publishing) {
                 auto func = [](auto &&element) { element.first = true; };
                 std::for_each(onceL.begin(), onceL.end(), func);
@@ -77,7 +81,7 @@ class Emitter {
             return onL.emplace(onL.cend(), false, std::move(listener));
         }
 
-        void erase(connection_type conn) noexcept {
+        void erase(connection_type conn) ENTT_NOEXCEPT {
             conn->first = true;
 
             if(!publishing) {
@@ -111,20 +115,9 @@ class Emitter {
         container_type onL{};
     };
 
-    static std::size_t next() noexcept {
-        static std::size_t counter = 0;
-        return counter++;
-    }
-
-    template<typename>
-    static std::size_t type() noexcept {
-        static std::size_t value = next();
-        return value;
-    }
-
     template<typename Event>
-    Handler<Event> & handler() noexcept {
-        const std::size_t family = type<Event>();
+    Handler<Event> & handler() ENTT_NOEXCEPT {
+        const std::size_t family = handler_family::type<Event>();
 
         if(!(family < handlers.size())) {
             handlers.resize(family+1);
@@ -138,7 +131,7 @@ class Emitter {
     }
 
 public:
-    /** @brief Type of listeners accepted for the given type of event. */
+    /** @brief Type of listeners accepted for the given event. */
     template<typename Event>
     using Listener = typename Handler<Event>::listener_type;
 
@@ -157,7 +150,7 @@ public:
         friend class Emitter;
 
         /*! @brief Default constructor. */
-        Connection() noexcept = default;
+        Connection() ENTT_NOEXCEPT = default;
 
         /**
          * @brief Creates a connection that wraps its underlying instance.
@@ -173,7 +166,7 @@ public:
         Connection(Connection &&) = default;
 
         /**
-         * @brief Default copy assignament operator.
+         * @brief Default copy assignment operator.
          * @return This connection.
          */
         Connection & operator=(const Connection &) = default;
@@ -186,10 +179,10 @@ public:
     };
 
     /*! @brief Default constructor. */
-    Emitter() noexcept = default;
+    Emitter() ENTT_NOEXCEPT = default;
 
     /*! @brief Default destructor. */
-    virtual ~Emitter() noexcept {
+    virtual ~Emitter() ENTT_NOEXCEPT {
         static_assert(std::is_base_of<Emitter<Derived>, Derived>::value, "!");
     }
 
@@ -200,7 +193,7 @@ public:
 
     /*! @brief Copying an emitter isn't allowed. @return This emitter. */
     Emitter & operator=(const Emitter &) = delete;
-    /*! @brief Default move assignament operator. @return This emitter. */
+    /*! @brief Default move assignment operator. @return This emitter. */
     Emitter & operator=(Emitter &&) = default;
 
     /**
@@ -279,7 +272,7 @@ public:
      * @param conn A valid connection.
      */
     template<typename Event>
-    void erase(Connection<Event> conn) noexcept {
+    void erase(Connection<Event> conn) ENTT_NOEXCEPT {
         handler<Event>().erase(std::move(conn));
     }
 
@@ -292,7 +285,7 @@ public:
      * @tparam Event Type of event to reset.
      */
     template<typename Event>
-    void clear() noexcept {
+    void clear() ENTT_NOEXCEPT {
         handler<Event>().clear();
     }
 
@@ -302,9 +295,10 @@ public:
      * All the connections previously returned are invalidated. Using them
      * results in undefined behavior.
      */
-    void clear() noexcept {
-        std::for_each(handlers.begin(), handlers.end(),
-                      [](auto &&handler) { if(handler) { handler->clear(); } });
+    void clear() ENTT_NOEXCEPT {
+        std::for_each(handlers.begin(), handlers.end(), [](auto &&handler) {
+            return handler ? handler->clear() : void();
+        });
     }
 
     /**
@@ -313,8 +307,8 @@ public:
      * @return True if there are no listeners registered, false otherwise.
      */
     template<typename Event>
-    bool empty() const noexcept {
-        const std::size_t family = type<Event>();
+    bool empty() const ENTT_NOEXCEPT {
+        const std::size_t family = handler_family::type<Event>();
 
         return (!(family < handlers.size()) ||
                 !handlers[family] ||
@@ -325,9 +319,10 @@ public:
      * @brief Checks if there are listeners registered with the event emitter.
      * @return True if there are no listeners registered, false otherwise.
      */
-    bool empty() const noexcept {
-        return std::all_of(handlers.cbegin(), handlers.cend(),
-                           [](auto &&handler) { return !handler || handler->empty(); });
+    bool empty() const ENTT_NOEXCEPT {
+        return std::all_of(handlers.cbegin(), handlers.cend(), [](auto &&handler) {
+            return !handler || handler->empty();
+        });
     }
 
 private:

src/entt/signal/sigh.hpp

@@ -5,12 +5,19 @@
 #include <algorithm>
 #include <utility>
 #include <vector>
+#include "../config/config.h"
 
 
 namespace entt {
 
 
-namespace {
+namespace internal {
+
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
 
 
 template<typename, typename>
@@ -19,12 +26,12 @@ struct Invoker;
 
 template<typename Ret, typename... Args, typename Collector>
 struct Invoker<Ret(Args...), Collector> {
-    using proto_type = Ret(*)(void *, Args...);
-    using call_type = std::pair<void *, proto_type>;
+    using proto_fn_type = Ret(void *, Args...);
+    using call_type = std::pair<void *, proto_fn_type *>;
 
     virtual ~Invoker() = default;
 
-    bool invoke(Collector &collector, proto_type proto, void *instance, Args... args) {
+    bool invoke(Collector &collector, proto_fn_type *proto, void *instance, Args... args) const {
         return collector(proto(instance, args...));
     }
 };
@@ -32,12 +39,12 @@ struct Invoker<Ret(Args...), Collector> {
 
 template<typename... Args, typename Collector>
 struct Invoker<void(Args...), Collector> {
-    using proto_type = void(*)(void *, Args...);
-    using call_type = std::pair<void *, proto_type>;
+    using proto_fn_type = void(void *, Args...);
+    using call_type = std::pair<void *, proto_fn_type *>;
 
     virtual ~Invoker() = default;
 
-    bool invoke(Collector &, proto_type proto, void *instance, Args... args) {
+    bool invoke(Collector &, proto_fn_type *proto, void *instance, Args... args) const {
         return (proto(instance, args...), true);
     }
 };
@@ -46,14 +53,14 @@ struct Invoker<void(Args...), Collector> {
 template<typename Ret>
 struct NullCollector final {
     using result_type = Ret;
-    bool operator()(result_type) const noexcept { return true; }
+    bool operator()(result_type) const ENTT_NOEXCEPT { return true; }
 };
 
 
 template<>
 struct NullCollector<void> final {
     using result_type = void;
-    bool operator()() const noexcept { return true; }
+    bool operator()() const ENTT_NOEXCEPT { return true; }
 };
 
 
@@ -71,9 +78,27 @@ 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.
  *
@@ -83,10 +108,126 @@ using DefaultCollectorType = typename DefaultCollector<Function>::collector_type
  * @tparam Function A valid function type.
  * @tparam Collector Type of collector to use, if any.
  */
-template<typename Function, typename Collector = DefaultCollectorType<Function>>
+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 proto_fn_type = Ret(void *, Args...);
+    using call_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... 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...) = &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...)>
+    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.
  *
@@ -111,24 +252,16 @@ class SigH;
  * @tparam Collector Type of collector to use, if any.
  */
 template<typename Ret, typename... Args, typename Collector>
-class SigH<Ret(Args...), Collector> final: private Invoker<Ret(Args...), Collector> {
-    using typename Invoker<Ret(Args...), Collector>::call_type;
-
-    template<Ret(*Function)(Args...)>
-    static Ret proto(void *, Args... args) {
-        return (Function)(args...);
-    }
-
-    template<typename Class, Ret(Class::*Member)(Args... args)>
-    static Ret proto(void *instance, Args... args) {
-        return (static_cast<Class *>(instance)->*Member)(args...);
-    }
+class SigH<Ret(Args...), Collector> final: private internal::Invoker<Ret(Args...), Collector> {
+    using call_type = typename internal::Invoker<Ret(Args...), Collector>::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.
@@ -141,7 +274,7 @@ public:
      * @brief Number of listeners connected to the signal.
      * @return Number of listeners currently connected.
      */
-    size_type size() const noexcept {
+    size_type size() const ENTT_NOEXCEPT {
         return calls.size();
     }
 
@@ -149,80 +282,21 @@ public:
      * @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 noexcept {
+    bool empty() const ENTT_NOEXCEPT {
         return calls.empty();
     }
 
     /**
-     * @brief Disconnects all the listeners from a signal.
-     */
-    void clear() noexcept {
-        calls.clear();
-    }
-
-    /**
-     * @brief Connects a free function to a signal.
+     * @brief Returns a sink object for the given signal.
      *
-     * The signal handler performs checks to avoid multiple connections for free
-     * functions.
+     * 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.
      *
-     * @tparam Function A valid free function pointer.
+     * @return A temporary sink object.
      */
-    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...)>
-    void connect(instance_type<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...)>
-    void disconnect(instance_type<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(instance_type<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());
+    sink_type sink() ENTT_NOEXCEPT {
+        return { calls };
     }
 
     /**
@@ -232,7 +306,7 @@ public:
      *
      * @param args Arguments to use to invoke listeners.
      */
-    void publish(Args... args) {
+    void publish(Args... args) const {
         for(auto pos = calls.size(); pos; --pos) {
             auto &call = calls[pos-1];
             call.second(call.first, args...);
@@ -244,12 +318,10 @@ public:
      * @param args Arguments to use to invoke listeners.
      * @return An instance of the collector filled with collected data.
      */
-    collector_type collect(Args... args) {
+    collector_type collect(Args... args) const {
         collector_type collector;
 
-        for(auto pos = calls.size(); pos; --pos) {
-            auto &call = calls[pos-1];
-
+        for(auto &&call: calls) {
             if(!this->invoke(collector, call.second, call.first, args...)) {
                 break;
             }
@@ -277,7 +349,7 @@ public:
      * @param other Signal with which to compare.
      * @return True if the two signals are identical, false otherwise.
      */
-    bool operator==(const SigH &other) const noexcept {
+    bool operator==(const SigH &other) const ENTT_NOEXCEPT {
         return std::equal(calls.cbegin(), calls.cend(), other.calls.cbegin(), other.calls.cend());
     }
 
@@ -299,7 +371,7 @@ private:
  * @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) noexcept {
+bool operator!=(const SigH<Ret(Args...)> &lhs, const SigH<Ret(Args...)> &rhs) ENTT_NOEXCEPT {
     return !(lhs == rhs);
 }
 

src/entt/signal/signal.hpp

@@ -1,233 +0,0 @@
-#ifndef ENTT_SIGNAL_SIGNAL_HPP
-#define ENTT_SIGNAL_SIGNAL_HPP
-
-
-#include <memory>
-#include <vector>
-#include <utility>
-#include <cstdint>
-#include <iterator>
-#include <algorithm>
-
-
-namespace entt {
-
-
-/**
- * @brief Managed 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.
- */
-template<typename>
-class Signal;
-
-
-/**
- * @brief Managed signal handler definition.
- *
- * Managed signal handler. It works with weak pointers to classes and pointers
- * to member functions as well as pointers to free functions. References are
- * automatically removed when the instances to which they point are freed.
- *
- * This class can be used to create signals used later to notify a bunch of
- * listeners.
- *
- * @tparam Args Types of arguments of a function type.
- */
-template<typename... Args>
-class Signal<void(Args...)> final {
-    using proto_type = bool(*)(std::weak_ptr<void> &, Args...);
-    using call_type = std::pair<std::weak_ptr<void>, proto_type>;
-
-    template<void(*Function)(Args...)>
-    static bool proto(std::weak_ptr<void> &, Args... args) {
-        Function(args...);
-        return true;
-    }
-
-    template<typename Class, void(Class::*Member)(Args...)>
-    static bool proto(std::weak_ptr<void> &wptr, Args... args) {
-        bool ret = false;
-
-        if(!wptr.expired()) {
-            auto ptr = std::static_pointer_cast<Class>(wptr.lock());
-            (ptr.get()->*Member)(args...);
-            ret = true;
-        }
-
-        return ret;
-    }
-
-public:
-    /*! @brief Unsigned integer type. */
-    using size_type = std::size_t;
-
-    /**
-     * @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 = std::shared_ptr<Class>;
-
-    /**
-     * @brief Number of listeners connected to the signal.
-     * @return Number of listeners currently connected.
-     */
-    size_type size() const 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 noexcept {
-        return calls.empty();
-    }
-
-    /**
-     * @brief Disconnects all the listeners from a signal.
-     */
-    void clear() noexcept {
-        calls.clear();
-    }
-
-    /**
-     * @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<void(*Function)(Args...)>
-    void connect() {
-        disconnect<Function>();
-        calls.emplace_back(std::weak_ptr<void>{}, &proto<Function>);
-    }
-
-    /**
-     * @brief Connects a member function for a given instance to a signal.
-     *
-     * 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, void(Class::*Member)(Args...)>
-    void connect(instance_type<Class> instance) {
-        disconnect<Class, Member>(instance);
-        calls.emplace_back(std::move(instance), &proto<Class, Member>);
-    }
-
-    /**
-     * @brief Disconnects a free function from a signal.
-     * @tparam Function A valid free function pointer.
-     */
-    template<void(*Function)(Args...)>
-    void disconnect() {
-        calls.erase(std::remove_if(calls.begin(), calls.end(),
-            [](const call_type &call) { return call.second == &proto<Function> && !call.first.lock(); }
-        ), 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, void(Class::*Member)(Args...)>
-    void disconnect(instance_type<Class> instance) {
-        calls.erase(std::remove_if(calls.begin(), calls.end(),
-            [instance{std::move(instance)}](const call_type &call) { return call.second == &proto<Class, Member> && call.first.lock() == instance; }
-        ), 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(instance_type<Class> instance) {
-        calls.erase(std::remove_if(calls.begin(), calls.end(),
-            [instance{std::move(instance)}](const call_type &call) { return call.first.lock() == instance; }
-        ), calls.end());
-    }
-
-    /**
-     * @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) {
-        std::vector<call_type> next;
-
-        for(auto pos = calls.size(); pos; --pos) {
-            auto &call = calls[pos-1];
-
-            if((call.second)(call.first, args...)) {
-                next.push_back(call);
-            }
-        }
-
-        calls.swap(next);
-    }
-
-    /**
-     * @brief Swaps listeners between the two signals.
-     * @param lhs A valid signal object.
-     * @param rhs A valid signal object.
-     */
-    friend void swap(Signal &lhs, Signal &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 Signal &other) const noexcept {
-        return std::equal(calls.cbegin(), calls.cend(), other.calls.cbegin(), other.calls.cend(), [](const auto &lhs, const auto &rhs) {
-            return (lhs.second == rhs.second) && (lhs.first.lock() == rhs.first.lock());
-        });
-    }
-
-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 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... Args>
-bool operator!=(const Signal<void(Args...)> &lhs, const Signal<void(Args...)> &rhs) noexcept {
-    return !(lhs == rhs);
-}
-
-
-}
-
-
-#endif // ENTT_SIGNAL_SIGNAL_HPP

test/CMakeLists.txt

@@ -4,16 +4,37 @@
 
 add_library(odr OBJECT odr.cpp)
 
+set_target_properties(odr PROPERTIES CXX_EXTENSIONS OFF)
+
+target_include_directories(odr
+    PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_INCLUDE_DIRECTORIES>
+)
+
+target_compile_definitions(odr
+    PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_DEFINITIONS>
+)
+
+target_compile_options(odr
+    PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_OPTIONS>
+    PRIVATE $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-pedantic -Wall>
+)
+
+target_compile_features(odr
+    PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_FEATURES>
+)
+
+macro(ADD_ENTT_TEST TEST_NAME TEST_SOURCE)
+    add_executable(${TEST_NAME} $<TARGET_OBJECTS:odr> ${TEST_SOURCE})
+    target_link_libraries(${TEST_NAME} PRIVATE EnTT gtest_main Threads::Threads)
+    set_target_properties(${TEST_NAME} PROPERTIES CXX_EXTENSIONS OFF)
+    target_compile_options(${TEST_NAME} PRIVATE $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-pedantic -Wall>)
+    add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
+endmacro()
+
 # Test benchmark
 
 if(BUILD_BENCHMARK)
-    add_executable(
-        benchmark
-        $<TARGET_OBJECTS:odr>
-        benchmark/benchmark.cpp
-    )
-    target_link_libraries(benchmark PRIVATE gtest_main Threads::Threads)
-    add_test(NAME benchmark COMMAND benchmark)
+    ADD_ENTT_TEST(benchmark benchmark/benchmark.cpp)
 endif()
 
 # Test mod
@@ -25,15 +46,9 @@ if(BUILD_MOD)
     execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${DUKTAPE_DEPS_DIR})
     set(DUKTAPE_SRC_DIR ${DUKTAPE_DEPS_DIR}/src/src)
 
-    add_executable(
-        mod
-        $<TARGET_OBJECTS:odr>
-        ${DUKTAPE_SRC_DIR}/duktape.c
-        mod/mod.cpp
-    )
+    set(MOD_TEST_SOURCE ${DUKTAPE_SRC_DIR}/duktape.c mod/mod.cpp)
+    ADD_ENTT_TEST(mod "${MOD_TEST_SOURCE}")
     target_include_directories(mod PRIVATE ${DUKTAPE_SRC_DIR})
-    target_link_libraries(mod PRIVATE gtest_main Threads::Threads m)
-    add_test(NAME mod COMMAND mod)
 endif()
 
 # Test snapshot
@@ -45,84 +60,45 @@ if(BUILD_SNAPSHOT)
     execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${CEREAL_DEPS_DIR})
     set(CEREAL_SRC_DIR ${CEREAL_DEPS_DIR}/src/include)
 
-    add_executable(
-        snapshot
-        $<TARGET_OBJECTS:odr>
-        snapshot/snapshot.cpp
-    )
-    target_include_directories(snapshot PRIVATE ${CEREAL_SRC_DIR})
-    target_link_libraries(snapshot PRIVATE gtest_main Threads::Threads)
-    add_test(NAME snapshot COMMAND snapshot)
+    ADD_ENTT_TEST(cereal snapshot/snapshot.cpp)
+    target_include_directories(cereal PRIVATE ${CEREAL_SRC_DIR})
 endif()
 
 # Test core
 
-add_executable(
-    core
-    $<TARGET_OBJECTS:odr>
-    entt/core/family.cpp
-    entt/core/hashed_string.cpp
-    entt/core/ident.cpp
-)
-target_link_libraries(core PRIVATE gtest_main Threads::Threads)
-add_test(NAME core COMMAND core)
+ADD_ENTT_TEST(algorithm entt/core/algorithm.cpp)
+ADD_ENTT_TEST(family entt/core/family.cpp)
+ADD_ENTT_TEST(hashed_string entt/core/hashed_string.cpp)
+ADD_ENTT_TEST(ident entt/core/ident.cpp)
+ADD_ENTT_TEST(monostate entt/core/monostate.cpp)
 
 # Test entity
 
-add_executable(
-    entity
-    $<TARGET_OBJECTS:odr>
-    entt/entity/actor.cpp
-    entt/entity/registry.cpp
-    entt/entity/snapshot.cpp
-    entt/entity/sparse_set.cpp
-    entt/entity/view.cpp
-)
-target_link_libraries(entity PRIVATE gtest_main Threads::Threads)
-add_test(NAME entity COMMAND entity)
+ADD_ENTT_TEST(actor entt/entity/actor.cpp)
+ADD_ENTT_TEST(entity entt/entity/entity.cpp)
+ADD_ENTT_TEST(helper entt/entity/helper.cpp)
+ADD_ENTT_TEST(prototype entt/entity/prototype.cpp)
+ADD_ENTT_TEST(registry entt/entity/registry.cpp)
+ADD_ENTT_TEST(snapshot entt/entity/snapshot.cpp)
+ADD_ENTT_TEST(sparse_set entt/entity/sparse_set.cpp)
+ADD_ENTT_TEST(view entt/entity/view.cpp)
 
 # Test locator
 
-add_executable(
-    locator
-    $<TARGET_OBJECTS:odr>
-    entt/locator/locator.cpp
-)
-target_link_libraries(locator PRIVATE gtest_main Threads::Threads)
-add_test(NAME locator COMMAND locator)
+ADD_ENTT_TEST(locator entt/locator/locator.cpp)
 
 # Test process
 
-add_executable(
-    process
-    $<TARGET_OBJECTS:odr>
-    entt/process/process.cpp
-    entt/process/scheduler.cpp
-)
-target_link_libraries(process PRIVATE gtest_main Threads::Threads)
-add_test(NAME process COMMAND process)
+ADD_ENTT_TEST(process entt/process/process.cpp)
+ADD_ENTT_TEST(scheduler entt/process/scheduler.cpp)
 
 # Test resource
 
-add_executable(
-    resource
-    $<TARGET_OBJECTS:odr>
-    entt/resource/resource.cpp
-)
-target_link_libraries(resource PRIVATE gtest_main Threads::Threads)
-add_test(NAME resource COMMAND resource)
+ADD_ENTT_TEST(resource entt/resource/resource.cpp)
 
 # Test signal
 
-add_executable(
-    signal
-    $<TARGET_OBJECTS:odr>
-    entt/signal/bus.cpp
-    entt/signal/delegate.cpp
-    entt/signal/dispatcher.cpp
-    entt/signal/emitter.cpp
-    entt/signal/sigh.cpp
-    entt/signal/signal.cpp
-)
-target_link_libraries(signal PRIVATE gtest_main Threads::Threads)
-add_test(NAME signal COMMAND signal)
+ADD_ENTT_TEST(delegate entt/signal/delegate.cpp)
+ADD_ENTT_TEST(dispatcher entt/signal/dispatcher.cpp)
+ADD_ENTT_TEST(emitter entt/signal/emitter.cpp)
+ADD_ENTT_TEST(sigh entt/signal/sigh.cpp)

test/benchmark/benchmark.cpp

@@ -2,6 +2,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <chrono>
+#include <iterator>
 #include <gtest/gtest.h>
 #include <entt/entity/registry.hpp>
 
@@ -73,17 +74,15 @@ TEST(Benchmark, IterateCreateDeleteSingleComponent) {
 
     for(int i = 0; i < 10000; i++) {
         for(int j = 0; j < 10000; j++) {
-            registry.create<Position>();
+            const auto entity = registry.create();
+            registry.assign<Position>(entity);
         }
 
         for(auto entity: view) {
-            const auto &position = view.get(entity);
-            (void)position;
-
             if(rand() % 2 == 0) {
                 registry.destroy(entity);
             }
-        };
+        }
     }
 
     timer.elapsed();
@@ -95,12 +94,22 @@ TEST(Benchmark, IterateSingleComponent1M) {
     std::cout << "Iterating over 1000000 entities, one component" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
     }
 
-    Timer timer;
-    registry.view<Position>().each([](auto, auto &) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateSingleComponentRaw1M) {
@@ -109,14 +118,47 @@ TEST(Benchmark, IterateSingleComponentRaw1M) {
     std::cout << "Iterating over 1000000 entities, one component, raw view" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
     }
 
-    Timer timer;
-    for(auto &&component: registry.raw<Position>()) {
-        (void)component;
-    }
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position>(entt::raw_t{}).each(func);
+        timer.elapsed();
+    };
+
+    test([](const auto &) {});
+    test([](auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
+}
+
+TEST(Benchmark, IterateSingleComponentRuntime1M) {
+    entt::DefaultRegistry registry;
+
+    std::cout << "Iterating over 1000000 entities, one component, runtime view" << std::endl;
+
+     for(std::uint64_t i = 0; i < 1000000L; i++) {
+         const auto entity = registry.create();
+         registry.assign<Position>(entity);
+     }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = { registry.type<Position>() };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+    });
 }
 
 TEST(Benchmark, IterateTwoComponents1M) {
@@ -125,12 +167,23 @@ TEST(Benchmark, IterateTwoComponents1M) {
     std::cout << "Iterating over 1000000 entities, two components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
     }
 
-    Timer timer;
-    registry.view<Position, Velocity>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateTwoComponents1MHalf) {
@@ -139,13 +192,26 @@ TEST(Benchmark, IterateTwoComponents1MHalf) {
     std::cout << "Iterating over 1000000 entities, two components, half of the entities have all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity>();
-        if(i % 2) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+
+        if(i % 2) {
+            registry.assign<Position>(entity);
+        }
     }
 
-    Timer timer;
-    registry.view<Position, Velocity>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateTwoComponents1MOne) {
@@ -154,13 +220,26 @@ TEST(Benchmark, IterateTwoComponents1MOne) {
     std::cout << "Iterating over 1000000 entities, two components, only one entity has all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity>();
-        if(i == 5000000L) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+
+        if(i == 5000000L) {
+            registry.assign<Position>(entity);
+        }
     }
 
-    Timer timer;
-    registry.view<Position, Velocity>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateTwoComponentsPersistent1M) {
@@ -170,12 +249,111 @@ TEST(Benchmark, IterateTwoComponentsPersistent1M) {
     std::cout << "Iterating over 1000000 entities, two components, persistent view" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
     }
 
-    Timer timer;
-    registry.persistent<Position, Velocity>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity>(entt::persistent_t{}).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
+}
+
+TEST(Benchmark, IterateTwoComponentsRuntime1M) {
+    entt::DefaultRegistry registry;
+    registry.prepare<Position, Velocity>();
+
+    std::cout << "Iterating over 1000000 entities, two components, runtime view" << std::endl;
+
+    for(std::uint64_t i = 0; i < 1000000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+    }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+        registry.get<Velocity>(entity).x = {};
+    });
+}
+
+TEST(Benchmark, IterateTwoComponentsRuntime1MHalf) {
+    entt::DefaultRegistry registry;
+
+    std::cout << "Iterating over 1000000 entities, two components, half of the entities have all the components, runtime view" << std::endl;
+
+    for(std::uint64_t i = 0; i < 1000000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+
+        if(i % 2) {
+            registry.assign<Position>(entity);
+        }
+    }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+        registry.get<Velocity>(entity).x = {};
+    });
+}
+
+TEST(Benchmark, IterateTwoComponentsRuntime1MOne) {
+    entt::DefaultRegistry registry;
+
+    std::cout << "Iterating over 1000000 entities, two components, only one entity has all the components, runtime view" << std::endl;
+
+    for(std::uint64_t i = 0; i < 1000000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+
+        if(i == 5000000L) {
+            registry.assign<Position>(entity);
+        }
+    }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = { registry.type<Position>(), registry.type<Velocity>() };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+        registry.get<Velocity>(entity).x = {};
+    });
 }
 
 TEST(Benchmark, IterateFiveComponents1M) {
@@ -184,12 +362,26 @@ TEST(Benchmark, IterateFiveComponents1M) {
     std::cout << "Iterating over 1000000 entities, five components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
     }
 
-    Timer timer;
-    registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateFiveComponents1MHalf) {
@@ -198,13 +390,29 @@ TEST(Benchmark, IterateFiveComponents1MHalf) {
     std::cout << "Iterating over 1000000 entities, five components, half of the entities have all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity, Comp<1>, Comp<2>, Comp<3>>();
-        if(i % 2) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+
+        if(i % 2) {
+            registry.assign<Position>(entity);
+        }
     }
 
-    Timer timer;
-    registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateFiveComponents1MOne) {
@@ -213,13 +421,29 @@ TEST(Benchmark, IterateFiveComponents1MOne) {
     std::cout << "Iterating over 1000000 entities, five components, only one entity has all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        auto entity = registry.create<Velocity, Comp<1>, Comp<2>, Comp<3>>();
-        if(i == 5000000L) { registry.assign<Position>(entity); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+
+        if(i == 5000000L) {
+            registry.assign<Position>(entity);
+        }
     }
 
-    Timer timer;
-    registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateFiveComponentsPersistent1M) {
@@ -229,12 +453,150 @@ TEST(Benchmark, IterateFiveComponentsPersistent1M) {
     std::cout << "Iterating over 1000000 entities, five components, persistent view" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
     }
 
-    Timer timer;
-    registry.persistent<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>(entt::persistent_t{}).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
+}
+
+TEST(Benchmark, IterateFiveComponentsRuntime1M) {
+    entt::DefaultRegistry registry;
+    registry.prepare<Position, Velocity, Comp<1>, Comp<2>, Comp<3>>();
+
+    std::cout << "Iterating over 1000000 entities, five components, runtime view" << std::endl;
+
+    for(std::uint64_t i = 0; i < 1000000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+    }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = {
+            registry.type<Position>(),
+            registry.type<Velocity>(),
+            registry.type<Comp<1>>(),
+            registry.type<Comp<2>>(),
+            registry.type<Comp<3>>()
+        };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+        registry.get<Velocity>(entity).x = {};
+        registry.get<Comp<1>>(entity).x = {};
+        registry.get<Comp<2>>(entity).x = {};
+        registry.get<Comp<3>>(entity).x = {};
+    });
+}
+
+TEST(Benchmark, IterateFiveComponentsRuntime1MHalf) {
+    entt::DefaultRegistry registry;
+
+    std::cout << "Iterating over 1000000 entities, five components, half of the entities have all the components, runtime view" << std::endl;
+
+    for(std::uint64_t i = 0; i < 1000000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+
+        if(i % 2) {
+            registry.assign<Position>(entity);
+        }
+    }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = {
+            registry.type<Position>(),
+            registry.type<Velocity>(),
+            registry.type<Comp<1>>(),
+            registry.type<Comp<2>>(),
+            registry.type<Comp<3>>()
+        };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+        registry.get<Velocity>(entity).x = {};
+        registry.get<Comp<1>>(entity).x = {};
+        registry.get<Comp<2>>(entity).x = {};
+        registry.get<Comp<3>>(entity).x = {};
+    });
+}
+
+TEST(Benchmark, IterateFiveComponentsRuntime1MOne) {
+    entt::DefaultRegistry registry;
+
+    std::cout << "Iterating over 1000000 entities, five components, only one entity has all the components, runtime view" << std::endl;
+
+    for(std::uint64_t i = 0; i < 1000000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+
+        if(i == 5000000L) {
+            registry.assign<Position>(entity);
+        }
+    }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = {
+            registry.type<Position>(),
+            registry.type<Velocity>(),
+            registry.type<Comp<1>>(),
+            registry.type<Comp<2>>(),
+            registry.type<Comp<3>>()
+        };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+        registry.get<Velocity>(entity).x = {};
+        registry.get<Comp<1>>(entity).x = {};
+        registry.get<Comp<2>>(entity).x = {};
+        registry.get<Comp<3>>(entity).x = {};
+    });
 }
 
 TEST(Benchmark, IterateTenComponents1M) {
@@ -243,12 +605,31 @@ TEST(Benchmark, IterateTenComponents1M) {
     std::cout << "Iterating over 1000000 entities, ten components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
     }
 
-    Timer timer;
-    registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateTenComponents1MHalf) {
@@ -257,13 +638,34 @@ TEST(Benchmark, IterateTenComponents1MHalf) {
     std::cout << "Iterating over 1000000 entities, ten components, half of the entities have all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; 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); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
+
+        if(i % 2) {
+            registry.assign<Position>(entity);
+        }
     }
 
-    Timer timer;
-    registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateTenComponents1MOne) {
@@ -272,13 +674,34 @@ TEST(Benchmark, IterateTenComponents1MOne) {
     std::cout << "Iterating over 1000000 entities, ten components, only one entity has all the components" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; 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); }
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
+
+        if(i == 5000000L) {
+            registry.assign<Position>(entity);
+        }
     }
 
-    Timer timer;
-    registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>().each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
 }
 
 TEST(Benchmark, IterateTenComponentsPersistent1M) {
@@ -288,12 +711,200 @@ TEST(Benchmark, IterateTenComponentsPersistent1M) {
     std::cout << "Iterating over 1000000 entities, ten components, persistent view" << std::endl;
 
     for(std::uint64_t i = 0; i < 1000000L; i++) {
-        registry.create<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
     }
 
-    Timer timer;
-    registry.persistent<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>().each([](auto, auto &...) {});
-    timer.elapsed();
+    auto test = [&registry](auto func) {
+        Timer timer;
+        registry.view<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>(entt::persistent_t{}).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto, const auto &...) {});
+    test([](auto, auto &... comp) {
+        using accumulator_type = int[];
+        accumulator_type accumulator = { (comp.x = {}, 0)... };
+        (void)accumulator;
+    });
+}
+
+TEST(Benchmark, IterateTenComponentsRuntime1M) {
+    entt::DefaultRegistry registry;
+    registry.prepare<Position, Velocity, Comp<1>, Comp<2>, Comp<3>, Comp<4>, Comp<5>, Comp<6>, Comp<7>, Comp<8>>();
+
+    std::cout << "Iterating over 1000000 entities, ten components, runtime view" << std::endl;
+
+    for(std::uint64_t i = 0; i < 1000000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Position>(entity);
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
+    }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = {
+            registry.type<Position>(),
+            registry.type<Velocity>(),
+            registry.type<Comp<1>>(),
+            registry.type<Comp<2>>(),
+            registry.type<Comp<3>>(),
+            registry.type<Comp<4>>(),
+            registry.type<Comp<5>>(),
+            registry.type<Comp<6>>(),
+            registry.type<Comp<7>>(),
+            registry.type<Comp<8>>()
+        };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+        registry.get<Velocity>(entity).x = {};
+        registry.get<Comp<1>>(entity).x = {};
+        registry.get<Comp<2>>(entity).x = {};
+        registry.get<Comp<3>>(entity).x = {};
+        registry.get<Comp<4>>(entity).x = {};
+        registry.get<Comp<5>>(entity).x = {};
+        registry.get<Comp<6>>(entity).x = {};
+        registry.get<Comp<7>>(entity).x = {};
+        registry.get<Comp<8>>(entity).x = {};
+    });
+}
+
+TEST(Benchmark, IterateTenComponentsRuntime1MHalf) {
+    entt::DefaultRegistry registry;
+
+    std::cout << "Iterating over 1000000 entities, ten components, half of the entities have all the components, runtime view" << std::endl;
+
+    for(std::uint64_t i = 0; i < 1000000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
+
+        if(i % 2) {
+            registry.assign<Position>(entity);
+        }
+    }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = {
+            registry.type<Position>(),
+            registry.type<Velocity>(),
+            registry.type<Comp<1>>(),
+            registry.type<Comp<2>>(),
+            registry.type<Comp<3>>(),
+            registry.type<Comp<4>>(),
+            registry.type<Comp<5>>(),
+            registry.type<Comp<6>>(),
+            registry.type<Comp<7>>(),
+            registry.type<Comp<8>>()
+        };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+        registry.get<Velocity>(entity).x = {};
+        registry.get<Comp<1>>(entity).x = {};
+        registry.get<Comp<2>>(entity).x = {};
+        registry.get<Comp<3>>(entity).x = {};
+        registry.get<Comp<4>>(entity).x = {};
+        registry.get<Comp<5>>(entity).x = {};
+        registry.get<Comp<6>>(entity).x = {};
+        registry.get<Comp<7>>(entity).x = {};
+        registry.get<Comp<8>>(entity).x = {};
+    });
+}
+
+TEST(Benchmark, IterateTenComponentsRuntime1MOne) {
+    entt::DefaultRegistry registry;
+
+    std::cout << "Iterating over 1000000 entities, ten components, only one entity has all the components, runtime view" << std::endl;
+
+    for(std::uint64_t i = 0; i < 1000000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Velocity>(entity);
+        registry.assign<Comp<1>>(entity);
+        registry.assign<Comp<2>>(entity);
+        registry.assign<Comp<3>>(entity);
+        registry.assign<Comp<4>>(entity);
+        registry.assign<Comp<5>>(entity);
+        registry.assign<Comp<6>>(entity);
+        registry.assign<Comp<7>>(entity);
+        registry.assign<Comp<8>>(entity);
+
+        if(i == 5000000L) {
+            registry.assign<Position>(entity);
+        }
+    }
+
+    auto test = [&registry](auto func) {
+        using component_type = typename entt::DefaultRegistry::component_type;
+        component_type types[] = {
+            registry.type<Position>(),
+            registry.type<Velocity>(),
+            registry.type<Comp<1>>(),
+            registry.type<Comp<2>>(),
+            registry.type<Comp<3>>(),
+            registry.type<Comp<4>>(),
+            registry.type<Comp<5>>(),
+            registry.type<Comp<6>>(),
+            registry.type<Comp<7>>(),
+            registry.type<Comp<8>>()
+        };
+
+        Timer timer;
+        registry.view(std::begin(types), std::end(types)).each(func);
+        timer.elapsed();
+    };
+
+    test([](auto) {});
+    test([&registry](auto entity) {
+        registry.get<Position>(entity).x = {};
+        registry.get<Velocity>(entity).x = {};
+        registry.get<Comp<1>>(entity).x = {};
+        registry.get<Comp<2>>(entity).x = {};
+        registry.get<Comp<3>>(entity).x = {};
+        registry.get<Comp<4>>(entity).x = {};
+        registry.get<Comp<5>>(entity).x = {};
+        registry.get<Comp<6>>(entity).x = {};
+        registry.get<Comp<7>>(entity).x = {};
+        registry.get<Comp<8>>(entity).x = {};
+    });
 }
 
 TEST(Benchmark, SortSingle) {
@@ -302,7 +913,8 @@ TEST(Benchmark, SortSingle) {
     std::cout << "Sort 150000 entities, one component" << std::endl;
 
     for(std::uint64_t i = 0; i < 150000L; i++) {
-        registry.create<Position>({ i, i });
+        const auto entity = registry.create();
+        registry.assign<Position>(entity, i, i);
     }
 
     Timer timer;
@@ -320,7 +932,9 @@ TEST(Benchmark, SortMulti) {
     std::cout << "Sort 150000 entities, two components" << std::endl;
 
     for(std::uint64_t i = 0; i < 150000L; i++) {
-        registry.create<Position, Velocity>({ i, i }, { i, i });
+        const auto entity = registry.create();
+        registry.assign<Position>(entity, i, i);
+        registry.assign<Velocity>(entity, i, i);
     }
 
     registry.sort<Position>([](const auto &lhs, const auto &rhs) {
@@ -333,3 +947,63 @@ TEST(Benchmark, SortMulti) {
 
     timer.elapsed();
 }
+
+TEST(Benchmark, AlmostSortedStdSort) {
+    entt::DefaultRegistry registry;
+    entt::DefaultRegistry::entity_type entities[3];
+
+    std::cout << "Sort 150000 entities, almost sorted, std::sort" << std::endl;
+
+    for(std::uint64_t i = 0; i < 150000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Position>(entity, i, i);
+
+        if(!(i % 50000)) {
+            entities[i / 50000] = entity;
+        }
+    }
+
+    for(std::uint64_t i = 0; i < 3; ++i) {
+        registry.destroy(entities[i]);
+        const auto entity = registry.create();
+        registry.assign<Position>(entity, 50000 * i, 50000 * i);
+    }
+
+    Timer timer;
+
+    registry.sort<Position>([](const auto &lhs, const auto &rhs) {
+        return lhs.x > rhs.x && lhs.y > rhs.y;
+    });
+
+    timer.elapsed();
+}
+
+TEST(Benchmark, AlmostSortedInsertionSort) {
+    entt::DefaultRegistry registry;
+    entt::DefaultRegistry::entity_type entities[3];
+
+    std::cout << "Sort 150000 entities, almost sorted, insertion sort" << std::endl;
+
+    for(std::uint64_t i = 0; i < 150000L; i++) {
+        const auto entity = registry.create();
+        registry.assign<Position>(entity, i, i);
+
+        if(!(i % 50000)) {
+            entities[i / 50000] = entity;
+        }
+    }
+
+    for(std::uint64_t i = 0; i < 3; ++i) {
+        registry.destroy(entities[i]);
+        const auto entity = registry.create();
+        registry.assign<Position>(entity, 50000 * i, 50000 * i);
+    }
+
+    Timer timer;
+
+    registry.sort<Position>([](const auto &lhs, const auto &rhs) {
+        return lhs.x > rhs.x && lhs.y > rhs.y;
+    }, entt::InsertionSort{});
+
+    timer.elapsed();
+}

test/entt/core/algorithm.cpp

@@ -0,0 +1,26 @@
+#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(auto i = 0; i < 4; ++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(auto i = 0; i < 4; ++i) {
+        ASSERT_LT(arr[i], arr[i+1]);
+    }
+}

test/entt/core/hashed_string.cpp

@@ -1,33 +1,7 @@
-#include <cstddef>
+#include <type_traits>
 #include <gtest/gtest.h>
 #include <entt/core/hashed_string.hpp>
 
-constexpr bool ptr(const char *str) {
-    using hash_type = entt::HashedString::hash_type;
-
-    return (static_cast<hash_type>(entt::HashedString{str}) == entt::HashedString{str}
-            && static_cast<const char *>(entt::HashedString{str}) == str
-            && entt::HashedString{str} == entt::HashedString{str}
-            && !(entt::HashedString{str} != entt::HashedString{str}));
-}
-
-template<std::size_t N>
-constexpr bool ref(const char (&str)[N]) {
-    using hash_type = entt::HashedString::hash_type;
-
-    return (static_cast<hash_type>(entt::HashedString{str}) == entt::HashedString{str}
-            && static_cast<const char *>(entt::HashedString{str}) == str
-            && entt::HashedString{str} == entt::HashedString{str}
-            && !(entt::HashedString{str} != entt::HashedString{str}));
-}
-
-TEST(HashedString, Constexprness) {
-    // how would you test a constexpr otherwise?
-    static_assert(ptr("foo"), "!");
-    static_assert(ref("bar"), "!");
-    ASSERT_TRUE(true);
-}
-
 TEST(HashedString, Functionalities) {
     using hash_type = entt::HashedString::hash_type;
 
@@ -40,10 +14,21 @@ TEST(HashedString, Functionalities) {
     ASSERT_EQ(static_cast<const char *>(fooHs), "foo");
     ASSERT_EQ(static_cast<const char *>(barHs), bar);
 
-    ASSERT_TRUE(fooHs == fooHs);
-    ASSERT_TRUE(fooHs != barHs);
+    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

@@ -2,32 +2,32 @@
 #include <gtest/gtest.h>
 #include <entt/core/ident.hpp>
 
-struct A {};
-struct B {};
+struct AType {};
+struct AnotherType {};
 
 TEST(Identifier, Uniqueness) {
-    constexpr auto ID = entt::ident<A, B>;
-    constexpr A a;
-    constexpr B b;
+    using ID = entt::Identifier<AType, AnotherType>;
+    constexpr AType anInstance;
+    constexpr AnotherType anotherInstance;
 
-    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>());
+    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<B>()) {
-    case ID.get<A>():
+    switch(ID::get<AnotherType>()) {
+    case ID::get<AType>():
         FAIL();
         break;
-    case ID.get<B>():
+    case ID::get<AnotherType>():
         SUCCEED();
     }
 }
 
 TEST(Identifier, SingleType) {
-    constexpr auto ID = entt::ident<A>;
-    std::integral_constant<decltype(ID)::identifier_type, ID.get()> ic;
+    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

@@ -3,55 +3,74 @@
 #include <entt/entity/actor.hpp>
 #include <entt/entity/registry.hpp>
 
-struct TestActor: entt::DefaultActor<unsigned int> {
-    using entt::DefaultActor<unsigned int>::DefaultActor;
-    void update(unsigned int) {}
-};
+struct ActorComponent final {};
+struct ActorTag final {};
 
-struct Position final {};
-struct Velocity final {};
-
-TEST(Actor, Functionalities) {
+TEST(Actor, Component) {
     entt::DefaultRegistry registry;
-    TestActor *actor = new TestActor{registry};
-    const auto &cactor = *actor;
+    entt::DefaultActor actor{registry};
+    const auto &cactor = actor;
 
-    ASSERT_EQ(&registry, &actor->registry());
+    ASSERT_EQ(&registry, &actor.registry());
     ASSERT_EQ(&registry, &cactor.registry());
-    ASSERT_TRUE(registry.empty<Position>());
-    ASSERT_TRUE(registry.empty<Velocity>());
+    ASSERT_TRUE(registry.empty<ActorComponent>());
     ASSERT_FALSE(registry.empty());
-    ASSERT_FALSE(actor->has<Position>());
-    ASSERT_FALSE(actor->has<Velocity>());
+    ASSERT_FALSE(actor.has<ActorComponent>());
 
-    const auto &position = actor->set<Position>();
+    const auto &component = actor.assign<ActorComponent>();
 
-    ASSERT_EQ(&position, &actor->get<Position>());
-    ASSERT_EQ(&position, &cactor.get<Position>());
-    ASSERT_FALSE(registry.empty<Position>());
-    ASSERT_TRUE(registry.empty<Velocity>());
+    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<Position>());
-    ASSERT_FALSE(actor->has<Velocity>());
+    ASSERT_TRUE(actor.has<ActorComponent>());
 
-    actor->unset<Position>();
+    actor.remove<ActorComponent>();
 
-    ASSERT_TRUE(registry.empty<Position>());
-    ASSERT_TRUE(registry.empty<Velocity>());
+    ASSERT_TRUE(registry.empty<ActorComponent>());
     ASSERT_FALSE(registry.empty());
-    ASSERT_FALSE(actor->has<Position>());
-    ASSERT_FALSE(actor->has<Velocity>());
+    ASSERT_FALSE(actor.has<ActorComponent>());
+}
 
-    actor->set<Position>();
-    actor->set<Velocity>();
+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_FALSE(registry.empty<Position>());
-    ASSERT_FALSE(registry.empty<Velocity>());
+    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());
-    ASSERT_TRUE(registry.empty<Position>());
-    ASSERT_TRUE(registry.empty<Velocity>());
 }

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,49 @@
+#include <gtest/gtest.h>
+#include <entt/entity/helper.hpp>
+#include <entt/entity/registry.hpp>
+
+TEST(Dependency, Functionalities) {
+    entt::DefaultRegistry registry;
+    const auto entity = registry.create();
+    entt::dependency<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::dependency<double, float>(entt::break_t{}, registry.construction<int>());
+    registry.assign<int>(entity);
+
+    ASSERT_FALSE(registry.has<double>(entity));
+    ASSERT_FALSE(registry.has<float>(entity));
+}

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

@@ -6,6 +6,55 @@
 #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;
 
@@ -15,19 +64,23 @@ TEST(DefaultRegistry, Functionalities) {
     ASSERT_NO_THROW(registry.reserve<char>(8));
     ASSERT_TRUE(registry.empty());
 
-    ASSERT_EQ(registry.capacity(), entt::DefaultRegistry::size_type{0});
+    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>());
 
-    auto e0 = registry.create();
-    auto e1 = registry.create<int, 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.capacity(), entt::DefaultRegistry::size_type{2});
     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>());
@@ -54,7 +107,7 @@ TEST(DefaultRegistry, Functionalities) {
     ASSERT_TRUE((registry.has<int, char>(e0)));
     ASSERT_FALSE((registry.has<int, char>(e1)));
 
-    auto e2 = registry.create();
+    const auto e2 = registry.create();
 
     registry.accommodate<int>(e2, registry.get<int>(e0));
     registry.accommodate<char>(e2, registry.get<char>(e0));
@@ -85,9 +138,7 @@ TEST(DefaultRegistry, Functionalities) {
 
     ASSERT_EQ(registry.version(e2), entt::DefaultRegistry::version_type{0});
     ASSERT_EQ(registry.current(e2), entt::DefaultRegistry::version_type{0});
-    ASSERT_EQ(registry.capacity(), entt::DefaultRegistry::size_type{3});
     ASSERT_NO_THROW(registry.destroy(e2));
-    ASSERT_EQ(registry.capacity(), entt::DefaultRegistry::size_type{3});
     ASSERT_EQ(registry.version(e2), entt::DefaultRegistry::version_type{0});
     ASSERT_EQ(registry.current(e2), entt::DefaultRegistry::version_type{1});
 
@@ -106,7 +157,10 @@ TEST(DefaultRegistry, Functionalities) {
     ASSERT_EQ(registry.size(), entt::DefaultRegistry::size_type{0});
     ASSERT_TRUE(registry.empty());
 
-    registry.create<int, char>();
+    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});
@@ -127,22 +181,44 @@ TEST(DefaultRegistry, Functionalities) {
     ASSERT_TRUE(registry.empty<int>());
     ASSERT_TRUE(registry.empty<char>());
 
-    e0 = registry.create<int>();
-    e1 = registry.create();
+    const auto e4 = registry.create();
+    const auto e5 = registry.create();
 
-    ASSERT_NO_THROW(registry.reset<int>(e0));
-    ASSERT_NO_THROW(registry.reset<int>(e1));
+    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, 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;
 
-    auto e0 = registry.create();
-    auto e1 = registry.create();
+    const auto e0 = registry.create();
+    const auto e1 = registry.create();
 
     registry.destroy(e0);
     registry.destroy(e1);
@@ -156,7 +232,7 @@ TEST(DefaultRegistry, CreateDestroyCornerCase) {
 TEST(DefaultRegistry, VersionOverflow) {
     entt::DefaultRegistry registry;
 
-    auto entity = registry.create();
+    const auto entity = registry.create();
     registry.destroy(entity);
 
     ASSERT_EQ(registry.version(entity), entt::DefaultRegistry::version_type{});
@@ -175,9 +251,9 @@ TEST(DefaultRegistry, Each) {
     entt::DefaultRegistry::size_type match;
 
     registry.create();
-    registry.create<int>();
+    registry.assign<int>(registry.create());
     registry.create();
-    registry.create<int>();
+    registry.assign<int>(registry.create());
     registry.create();
 
     tot = 0u;
@@ -226,11 +302,11 @@ TEST(DefaultRegistry, Orphans) {
     entt::DefaultRegistry registry;
     entt::DefaultRegistry::size_type tot{};
 
-    registry.create<int>();
+    registry.assign<int>(registry.create());
     registry.create();
-    registry.create<int>();
+    registry.assign<int>(registry.create());
     registry.create();
-    registry.attach<double>(registry.create());
+    registry.assign<double>(entt::tag_t{}, registry.create());
 
     registry.orphans([&](auto) { ++tot; });
     ASSERT_EQ(tot, 2u);
@@ -246,35 +322,27 @@ TEST(DefaultRegistry, Orphans) {
     ASSERT_EQ(tot, 0u);
 }
 
-TEST(DefaultRegistry, Types) {
-    entt::DefaultRegistry registry;
-
-    ASSERT_EQ(registry.tag<int>(), registry.tag<int>());
-    ASSERT_EQ(registry.component<int>(), registry.component<int>());
-
-    ASSERT_NE(registry.tag<int>(), registry.tag<double>());
-    ASSERT_NE(registry.component<int>(), registry.component<double>());
-}
-
 TEST(DefaultRegistry, CreateDestroyEntities) {
     entt::DefaultRegistry registry;
     entt::DefaultRegistry::entity_type pre{}, post{};
 
     for(int i = 0; i < 10; ++i) {
-        registry.create<double>();
+        const auto entity = registry.create();
+        registry.assign<double>(entity);
     }
 
     registry.reset();
 
     for(int i = 0; i < 7; ++i) {
-        auto entity = registry.create<int>();
+        const auto entity = registry.create();
+        registry.assign<int>(entity);
         if(i == 3) { pre = entity; }
     }
 
     registry.reset();
 
     for(int i = 0; i < 5; ++i) {
-        auto entity = registry.create();
+        const auto entity = registry.create();
         if(i == 3) { post = entity; }
     }
 
@@ -291,25 +359,29 @@ TEST(DefaultRegistry, AttachSetRemoveTags) {
 
     ASSERT_FALSE(registry.has<int>());
 
-    auto entity = registry.create();
-    registry.attach<int>(entity, 42);
+    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.set<int>(3);
+    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);
 
-    auto other = registry.create();
+    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);
@@ -317,22 +389,33 @@ TEST(DefaultRegistry, AttachSetRemoveTags) {
     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));
 
-    registry.attach<int>(entity, 42);
+    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, StandardViews) {
+TEST(DefaultRegistry, StandardView) {
     entt::DefaultRegistry registry;
     auto mview = registry.view<int, char>();
     auto iview = registry.view<int>();
     auto cview = registry.view<char>();
 
-    registry.create(0, 'c');
-    registry.create(0);
-    registry.create(0, 'c');
+    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});
@@ -343,9 +426,9 @@ TEST(DefaultRegistry, StandardViews) {
     ASSERT_EQ(cnt, decltype(mview)::size_type{2});
 }
 
-TEST(DefaultRegistry, PersistentViews) {
+TEST(DefaultRegistry, PersistentView) {
     entt::DefaultRegistry registry;
-    auto view = registry.persistent<int, char>();
+    auto view = registry.view<int, char>(entt::persistent_t{});
 
     ASSERT_TRUE((registry.contains<int, char>()));
     ASSERT_FALSE((registry.contains<int, double>()));
@@ -358,9 +441,16 @@ TEST(DefaultRegistry, PersistentViews) {
 
     ASSERT_FALSE((registry.contains<int, double>()));
 
-    registry.create(0, 'c');
-    registry.create(0);
-    registry.create(0, 'c');
+    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; });
@@ -368,10 +458,28 @@ TEST(DefaultRegistry, PersistentViews) {
     ASSERT_EQ(cnt, decltype(view)::size_type{2});
 }
 
-TEST(DefaultRegistry, CleanStandardViewsAfterReset) {
+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.create(0);
+    registry.assign<int>(registry.create(), 0);
 
     ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{1});
 
@@ -380,10 +488,25 @@ TEST(DefaultRegistry, CleanStandardViewsAfterReset) {
     ASSERT_EQ(view.size(), entt::DefaultRegistry::size_type{0});
 }
 
-TEST(DefaultRegistry, CleanPersistentViewsAfterReset) {
+TEST(DefaultRegistry, CleanPersistentViewAfterReset) {
     entt::DefaultRegistry registry;
-    auto view = registry.persistent<int, char>();
-    registry.create(0, 'c');
+    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});
 
@@ -394,8 +517,8 @@ TEST(DefaultRegistry, CleanPersistentViewsAfterReset) {
 
 TEST(DefaultRegistry, CleanTagsAfterReset) {
     entt::DefaultRegistry registry;
-    auto entity = registry.create();
-    registry.attach<int>(entity);
+    const auto entity = registry.create();
+    registry.assign<int>(entt::tag_t{}, entity);
 
     ASSERT_TRUE(registry.has<int>());
 
@@ -409,9 +532,9 @@ TEST(DefaultRegistry, SortSingle) {
 
     int val = 0;
 
-    registry.create(val++);
-    registry.create(val++);
-    registry.create(val++);
+    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);
@@ -430,9 +553,11 @@ TEST(DefaultRegistry, SortMulti) {
     unsigned int uval = 0u;
     int ival = 0;
 
-    registry.create(uval++, ival++);
-    registry.create(uval++, ival++);
-    registry.create(uval++, ival++);
+    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);
@@ -457,7 +582,7 @@ TEST(DefaultRegistry, SortMulti) {
 TEST(DefaultRegistry, ComponentsWithTypesFromStandardTemplateLibrary) {
     // see #37 - the test shouldn't crash, that's all
     entt::DefaultRegistry registry;
-    auto entity = registry.create();
+    const auto entity = registry.create();
     registry.assign<std::unordered_set<int>>(entity).insert(42);
     registry.destroy(entity);
 }
@@ -466,7 +591,7 @@ TEST(DefaultRegistry, ConstructWithComponents) {
     // it should compile, that's all
     entt::DefaultRegistry registry;
     const auto value = 0;
-    registry.create(value);
+    registry.assign<int>(registry.create(), value);
 }
 
 TEST(DefaultRegistry, MergeTwoRegistries) {
@@ -480,7 +605,9 @@ TEST(DefaultRegistry, MergeTwoRegistries) {
     auto merge = [&ref](const auto &view, auto &dst) {
         view.each([&](auto entity, const auto &component) {
             if(ref.find(entity) == ref.cend()) {
-                ref.emplace(entity, dst.create(component));
+                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);
@@ -488,11 +615,24 @@ TEST(DefaultRegistry, MergeTwoRegistries) {
         });
     };
 
-    src.create<int, float, double>();
-    src.create<char, float, int>();
+    auto e0 = src.create();
+    src.assign<int>(e0);
+    src.assign<float>(e0);
+    src.assign<double>(e0);
 
-    dst.create<int, char, double>();
-    dst.create<float, int>();
+    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); };
@@ -508,3 +648,146 @@ TEST(DefaultRegistry, MergeTwoRegistries) {
     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/entt/entity/snapshot.cpp

@@ -10,9 +10,11 @@ struct OutputArchive {
         : storage{storage}
     {}
 
-    template<typename Value>
-    void operator()(const Value &value) {
-        std::get<std::queue<Value>>(storage).push(value);
+    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:
@@ -25,11 +27,17 @@ struct InputArchive {
         : storage{storage}
     {}
 
-    template<typename Value>
-    void operator()(Value &value) {
-        auto &queue = std::get<std::queue<Value>>(storage);
-        value = queue.front();
-        queue.pop();
+    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:
@@ -43,7 +51,7 @@ struct AnotherComponent {
     int value;
 };
 
-struct Foo {
+struct WhatAComponent {
     entt::DefaultRegistry::entity_type bar;
     std::vector<entt::DefaultRegistry::entity_type> quux;
 };
@@ -51,22 +59,22 @@ struct Foo {
 TEST(Snapshot, Dump) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create();
+    const auto e0 = registry.create();
     registry.assign<int>(e0, 42);
     registry.assign<char>(e0, 'c');
     registry.assign<double>(e0, .1);
 
-    auto e1 = registry.create();
+    const auto e1 = registry.create();
 
-    auto e2 = registry.create();
+    const auto e2 = registry.create();
     registry.assign<int>(e2, 3);
 
-    auto e3 = registry.create();
+    const auto e3 = registry.create();
     registry.assign<char>(e3, '0');
-    registry.attach<float>(e3, .3f);
+    registry.assign<float>(entt::tag_t{}, e3, .3f);
 
-    auto e4 = registry.create();
-    registry.attach<AComponent>(e4);
+    const auto e4 = registry.create();
+    registry.assign<AComponent>(entt::tag_t{}, e4);
 
     registry.destroy(e1);
     auto v1 = registry.current(e1);
@@ -80,7 +88,7 @@ TEST(Snapshot, Dump) {
         std::queue<bool>,
         std::queue<AComponent>,
         std::queue<AnotherComponent>,
-        std::queue<Foo>
+        std::queue<WhatAComponent>
     >;
 
     storage_type storage;
@@ -140,22 +148,22 @@ TEST(Snapshot, Dump) {
 TEST(Snapshot, Partial) {
     entt::DefaultRegistry registry;
 
-    auto e0 = registry.create();
+    const auto e0 = registry.create();
     registry.assign<int>(e0, 42);
     registry.assign<char>(e0, 'c');
     registry.assign<double>(e0, .1);
 
-    auto e1 = registry.create();
+    const auto e1 = registry.create();
 
-    auto e2 = registry.create();
+    const auto e2 = registry.create();
     registry.assign<int>(e2, 3);
 
-    auto e3 = registry.create();
+    const auto e3 = registry.create();
     registry.assign<char>(e3, '0');
-    registry.attach<float>(e3, .3f);
+    registry.assign<float>(entt::tag_t{}, e3, .3f);
 
-    auto e4 = registry.create();
-    registry.attach<AComponent>(e4);
+    const auto e4 = registry.create();
+    registry.assign<AComponent>(entt::tag_t{}, e4);
 
     registry.destroy(e1);
     auto v1 = registry.current(e1);
@@ -168,7 +176,7 @@ TEST(Snapshot, Partial) {
         std::queue<float>,
         std::queue<bool>,
         std::queue<AComponent>,
-        std::queue<Foo>
+        std::queue<WhatAComponent>
     >;
 
     storage_type storage;
@@ -240,6 +248,41 @@ TEST(Snapshot, Partial) {
     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;
 
@@ -255,7 +298,7 @@ TEST(Snapshot, Continuous) {
         std::queue<entity_type>,
         std::queue<AComponent>,
         std::queue<AnotherComponent>,
-        std::queue<Foo>,
+        std::queue<WhatAComponent>,
         std::queue<double>
     >;
 
@@ -267,9 +310,7 @@ TEST(Snapshot, Continuous) {
         src.create();
     }
 
-    src.each([&src](auto entity) {
-        src.destroy(entity);
-    });
+    src.reset();
 
     for(int i = 0; i < 5; ++i) {
         entity = src.create();
@@ -279,14 +320,14 @@ TEST(Snapshot, Continuous) {
         src.assign<AnotherComponent>(entity, i, i);
 
         if(i % 2) {
-            src.assign<Foo>(entity, entity);
+            src.assign<WhatAComponent>(entity, entity);
         } else if(i == 2) {
-            src.attach<double>(entity, .3);
+            src.assign<double>(entt::tag_t{}, entity, .3);
         }
     }
 
-    src.view<Foo>().each([&entities](auto, auto &foo) {
-        foo.quux.insert(foo.quux.begin(), entities.begin(), entities.end());
+    src.view<WhatAComponent>().each([&entities](auto, auto &whatAComponent) {
+        whatAComponent.quux.insert(whatAComponent.quux.begin(), entities.begin(), entities.end());
     });
 
     entity = dst.create();
@@ -296,19 +337,18 @@ TEST(Snapshot, Continuous) {
     src.snapshot()
             .entities(output)
             .destroyed(output)
-            .component<AComponent, AnotherComponent, Foo>(output)
+            .component<AComponent, AnotherComponent, WhatAComponent>(output)
             .tag<double>(output);
 
     loader.entities(input)
             .destroyed(input)
-            .component<AComponent, AnotherComponent>(input)
-            .component<Foo>(input, &Foo::bar, &Foo::quux)
+            .component<AComponent, AnotherComponent, WhatAComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
             .tag<double>(input)
             .orphans();
 
     decltype(dst.size()) aComponentCnt{};
     decltype(dst.size()) anotherComponentCnt{};
-    decltype(dst.size()) fooCnt{};
+    decltype(dst.size()) whatAComponentCnt{};
 
     dst.each([&dst, &aComponentCnt](auto entity) {
         ASSERT_TRUE(dst.has<AComponent>(entity));
@@ -320,14 +360,14 @@ TEST(Snapshot, Continuous) {
         ++anotherComponentCnt;
     });
 
-    dst.view<Foo>().each([&dst, &fooCnt](auto entity, const auto &component) {
+    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));
         }
 
-        ++fooCnt;
+        ++whatAComponentCnt;
     });
 
     ASSERT_TRUE(dst.has<double>());
@@ -342,13 +382,12 @@ TEST(Snapshot, Continuous) {
     src.snapshot()
             .entities(output)
             .destroyed(output)
-            .component<AComponent, AnotherComponent, Foo>(output)
+            .component<AComponent, WhatAComponent, AnotherComponent>(output)
             .tag<double>(output);
 
     loader.entities(input)
             .destroyed(input)
-            .component<AComponent, AnotherComponent>(input)
-            .component<Foo>(input, &Foo::bar, &Foo::quux)
+            .component<AComponent, WhatAComponent, AnotherComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
             .tag<double>(input)
             .orphans();
 
@@ -356,7 +395,7 @@ TEST(Snapshot, Continuous) {
 
     ASSERT_EQ(dst.size<AComponent>(), aComponentCnt);
     ASSERT_EQ(dst.size<AnotherComponent>(), anotherComponentCnt);
-    ASSERT_EQ(dst.size<Foo>(), fooCnt);
+    ASSERT_EQ(dst.size<WhatAComponent>(), whatAComponentCnt);
     ASSERT_TRUE(dst.has<double>());
 
     dst.view<AnotherComponent>().each([](auto, auto &component) {
@@ -365,24 +404,23 @@ TEST(Snapshot, Continuous) {
 
     entity = src.create();
 
-    src.view<Foo>().each([entity](auto, auto &component) {
+    src.view<WhatAComponent>().each([entity](auto, auto &component) {
         component.bar = entity;
     });
 
     src.snapshot()
             .entities(output)
             .destroyed(output)
-            .component<AComponent, AnotherComponent, Foo>(output)
+            .component<WhatAComponent, AComponent, AnotherComponent>(output)
             .tag<double>(output);
 
     loader.entities(input)
             .destroyed(input)
-            .component<AComponent, AnotherComponent>(input)
-            .component<Foo>(input, &Foo::bar, &Foo::quux)
+            .component<WhatAComponent, AComponent, AnotherComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
             .tag<double>(input)
             .orphans();
 
-    dst.view<Foo>().each([&loader, entity](auto, auto &component) {
+    dst.view<WhatAComponent>().each([&loader, entity](auto, auto &component) {
         ASSERT_EQ(component.bar, loader.map(entity));
     });
 
@@ -397,18 +435,17 @@ TEST(Snapshot, Continuous) {
     src.snapshot()
             .entities(output)
             .destroyed(output)
-            .component<AComponent, AnotherComponent, Foo>(output)
+            .component<AComponent, AnotherComponent, WhatAComponent>(output)
             .tag<double>(output);
 
     loader.entities(input)
             .destroyed(input)
-            .component<AComponent, AnotherComponent>(input)
-            .component<Foo>(input, &Foo::bar, &Foo::quux)
+            .component<AComponent, AnotherComponent, WhatAComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
             .tag<double>(input)
             .orphans()
             .shrink();
 
-    dst.view<Foo>().each([&dst, &loader, entity](auto, auto &component) {
+    dst.view<WhatAComponent>().each([&dst](auto, auto &component) {
         ASSERT_FALSE(dst.valid(component.bar));
     });
 
@@ -416,7 +453,7 @@ TEST(Snapshot, Continuous) {
 
     entity = src.create();
 
-    src.view<Foo>().each([entity](auto, auto &component) {
+    src.view<WhatAComponent>().each([entity](auto, auto &component) {
         component.bar = entity;
     });
 
@@ -426,13 +463,12 @@ TEST(Snapshot, Continuous) {
     src.snapshot()
             .entities(output)
             .destroyed(output)
-            .component<AComponent, AnotherComponent, Foo>(output)
+            .component<AComponent, WhatAComponent, AnotherComponent>(output)
             .tag<double>(output);
 
     loader.entities(input)
             .destroyed(input)
-            .component<AComponent, AnotherComponent>(input)
-            .component<Foo>(input, &Foo::bar, &Foo::quux)
+            .component<AComponent, WhatAComponent, AnotherComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
             .tag<double>(input)
             .orphans();
 
@@ -446,13 +482,12 @@ TEST(Snapshot, Continuous) {
     src.snapshot()
             .entities(output)
             .destroyed(output)
-            .component<AComponent, AnotherComponent, Foo>(output)
+            .component<WhatAComponent, AComponent, AnotherComponent>(output)
             .tag<double>(output);
 
     loader.entities(input)
             .destroyed(input)
-            .component<AComponent, AnotherComponent>(input)
-            .component<Foo>(input, &Foo::bar, &Foo::quux)
+            .component<WhatAComponent, AComponent, AnotherComponent>(input, &WhatAComponent::bar, &WhatAComponent::quux)
             .tag<double>(input)
             .orphans();
 
@@ -487,3 +522,54 @@ TEST(Snapshot, ContinuousMoreOnShrink) {
 
     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

@@ -3,11 +3,15 @@
 #include <entt/entity/sparse_set.hpp>
 
 TEST(SparseSetNoType, Functionalities) {
-    entt::SparseSet<unsigned int> set;
+    entt::SparseSet<std::uint64_t> set;
+    const auto &cset = set;
 
-    ASSERT_NO_THROW(set.reserve(42));
+    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));
@@ -18,6 +22,7 @@ TEST(SparseSetNoType, Functionalities) {
 
     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));
@@ -28,6 +33,7 @@ TEST(SparseSetNoType, Functionalities) {
 
     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));
@@ -40,17 +46,121 @@ TEST(SparseSetNoType, Functionalities) {
 
     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<unsigned int>{std::move(set)};
-    entt::SparseSet<unsigned int> other;
+    (void)entt::SparseSet<std::uint64_t>{std::move(set)};
+    entt::SparseSet<std::uint64_t> other;
     other = std::move(set);
 }
 
-TEST(SparseSetNoType, DataBeginEnd) {
-    entt::SparseSet<unsigned int> 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);
@@ -63,27 +173,11 @@ TEST(SparseSetNoType, DataBeginEnd) {
     ASSERT_EQ(*(set.data() + 0u), 3u);
     ASSERT_EQ(*(set.data() + 1u), 12u);
     ASSERT_EQ(*(set.data() + 2u), 42u);
-
-    auto it = set.begin();
-
-    ASSERT_EQ(*it, 42u);
-    ASSERT_EQ(*(it+1), 12u);
-    ASSERT_EQ(*(it+2), 3u);
-    ASSERT_EQ(it += 3, set.end());
-
-    auto begin = set.begin();
-    auto end = set.end();
-
-    ASSERT_EQ(*(begin++), 42u);
-    ASSERT_EQ(*(begin++), 12u);
-    ASSERT_EQ(*(begin++), 3u);
-
-    ASSERT_EQ(begin, end);
 }
 
 TEST(SparseSetNoType, RespectDisjoint) {
-    entt::SparseSet<unsigned int> lhs;
-    entt::SparseSet<unsigned int> rhs;
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
     const auto &clhs = lhs;
 
     lhs.construct(3);
@@ -102,8 +196,8 @@ TEST(SparseSetNoType, RespectDisjoint) {
 }
 
 TEST(SparseSetNoType, RespectOverlap) {
-    entt::SparseSet<unsigned int> lhs;
-    entt::SparseSet<unsigned int> rhs;
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
     const auto &clhs = lhs;
 
     lhs.construct(3);
@@ -124,8 +218,8 @@ TEST(SparseSetNoType, RespectOverlap) {
 }
 
 TEST(SparseSetNoType, RespectOrdered) {
-    entt::SparseSet<unsigned int> lhs;
-    entt::SparseSet<unsigned int> rhs;
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
 
     lhs.construct(1);
     lhs.construct(2);
@@ -164,8 +258,8 @@ TEST(SparseSetNoType, RespectOrdered) {
 }
 
 TEST(SparseSetNoType, RespectReverse) {
-    entt::SparseSet<unsigned int> lhs;
-    entt::SparseSet<unsigned int> rhs;
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
 
     lhs.construct(1);
     lhs.construct(2);
@@ -204,8 +298,8 @@ TEST(SparseSetNoType, RespectReverse) {
 }
 
 TEST(SparseSetNoType, RespectUnordered) {
-    entt::SparseSet<unsigned int> lhs;
-    entt::SparseSet<unsigned int> rhs;
+    entt::SparseSet<std::uint64_t> lhs;
+    entt::SparseSet<std::uint64_t> rhs;
 
     lhs.construct(1);
     lhs.construct(2);
@@ -244,20 +338,24 @@ TEST(SparseSetNoType, RespectUnordered) {
 }
 
 TEST(SparseSetWithType, Functionalities) {
-    entt::SparseSet<unsigned int, int> set;
+    entt::SparseSet<std::uint64_t, int> set;
+    const auto &cset = set;
 
-    ASSERT_NO_THROW(set.reserve(42));
+    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_EQ(set.get(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));
@@ -268,6 +366,7 @@ TEST(SparseSetWithType, Functionalities) {
 
     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));
@@ -280,30 +379,132 @@ TEST(SparseSetWithType, Functionalities) {
 
     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<unsigned int>{std::move(set)};
-    entt::SparseSet<unsigned int> other;
+    (void)entt::SparseSet<std::uint64_t>{std::move(set)};
+    entt::SparseSet<std::uint64_t> 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<unsigned int, AggregateType>{}.construct(0, 42);
+    entt::SparseSet<std::uint64_t, AggregateType>{}.construct(0, 42);
 }
 
 TEST(SparseSetWithType, TypesFromStandardTemplateLibraryMustWork) {
     // see #37 - this test shouldn't crash, that's all
-    entt::SparseSet<unsigned int, std::unordered_set<int>> set;
+    entt::SparseSet<std::uint64_t, std::unordered_set<int>> set;
     set.construct(0).insert(42);
     set.destroy(0);
 }
 
-TEST(SparseSetWithType, RawBeginEnd) {
-    entt::SparseSet<unsigned int, int> set;
+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);
@@ -316,18 +517,10 @@ TEST(SparseSetWithType, RawBeginEnd) {
     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(*(begin++), 9);
-    ASSERT_EQ(*(begin++), 6);
-    ASSERT_EQ(*(begin++), 3);
-    ASSERT_EQ(begin, end);
 }
 
 TEST(SparseSetWithType, SortOrdered) {
-    entt::SparseSet<unsigned int, int> set;
+    entt::SparseSet<std::uint64_t, int> set;
 
     set.construct(12, 12);
     set.construct(42, 9);
@@ -363,7 +556,7 @@ TEST(SparseSetWithType, SortOrdered) {
 }
 
 TEST(SparseSetWithType, SortReverse) {
-    entt::SparseSet<unsigned int, int> set;
+    entt::SparseSet<std::uint64_t, int> set;
 
     set.construct(12, 1);
     set.construct(42, 3);
@@ -399,7 +592,7 @@ TEST(SparseSetWithType, SortReverse) {
 }
 
 TEST(SparseSetWithType, SortUnordered) {
-    entt::SparseSet<unsigned int, int> set;
+    entt::SparseSet<std::uint64_t, int> set;
 
     set.construct(12, 6);
     set.construct(42, 3);
@@ -435,8 +628,8 @@ TEST(SparseSetWithType, SortUnordered) {
 }
 
 TEST(SparseSetWithType, RespectDisjoint) {
-    entt::SparseSet<unsigned int, int> lhs;
-    entt::SparseSet<unsigned int, int> rhs;
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
     const auto &clhs = lhs;
 
     lhs.construct(3, 3);
@@ -463,8 +656,8 @@ TEST(SparseSetWithType, RespectDisjoint) {
 }
 
 TEST(SparseSetWithType, RespectOverlap) {
-    entt::SparseSet<unsigned int, int> lhs;
-    entt::SparseSet<unsigned int, int> rhs;
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
     const auto &clhs = lhs;
 
     lhs.construct(3, 3);
@@ -493,8 +686,8 @@ TEST(SparseSetWithType, RespectOverlap) {
 }
 
 TEST(SparseSetWithType, RespectOrdered) {
-    entt::SparseSet<unsigned int, int> lhs;
-    entt::SparseSet<unsigned int, int> rhs;
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
 
     lhs.construct(1, 0);
     lhs.construct(2, 0);
@@ -539,8 +732,8 @@ TEST(SparseSetWithType, RespectOrdered) {
 }
 
 TEST(SparseSetWithType, RespectReverse) {
-    entt::SparseSet<unsigned int, int> lhs;
-    entt::SparseSet<unsigned int, int> rhs;
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
 
     lhs.construct(1, 0);
     lhs.construct(2, 0);
@@ -585,8 +778,8 @@ TEST(SparseSetWithType, RespectReverse) {
 }
 
 TEST(SparseSetWithType, RespectUnordered) {
-    entt::SparseSet<unsigned int, int> lhs;
-    entt::SparseSet<unsigned int, int> rhs;
+    entt::SparseSet<std::uint64_t, int> lhs;
+    entt::SparseSet<std::uint64_t, int> rhs;
 
     lhs.construct(1, 0);
     lhs.construct(2, 0);
@@ -631,9 +824,9 @@ TEST(SparseSetWithType, RespectUnordered) {
 }
 
 TEST(SparseSetWithType, ReferencesGuaranteed) {
-    struct Type { int value; };
+    struct InternalType { int value; };
 
-    entt::SparseSet<unsigned int, Type> set;
+    entt::SparseSet<std::uint64_t, InternalType> set;
 
     set.construct(0, 0);
     set.construct(1, 1);
@@ -659,3 +852,18 @@ TEST(SparseSetWithType, ReferencesGuaranteed) {
     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/locator/locator.cpp

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

test/entt/signal/bus.cpp

@@ -1,141 +0,0 @@
-#include <memory>
-#include <gtest/gtest.h>
-#include <entt/signal/bus.hpp>
-
-struct EventA
-{
-    EventA(int x, int y): value{x+y} {}
-    int value;
-};
-
-struct EventB {};
-struct EventC {};
-
-struct MyListener
-{
-    void receive(const EventA &) { A++; }
-    static void listen(const EventB &) { B++; }
-    void receive(const EventC &) { C++; }
-    void reset() { A = 0; B = 0; C = 0; }
-    int A{0};
-    static int B;
-    int C{0};
-};
-
-int MyListener::B = 0;
-
-template<typename Bus, typename Listener>
-void testRegUnregEmit(Listener listener) {
-    Bus bus;
-
-    listener->reset();
-    bus.template publish<EventA>(40, 2);
-    bus.template publish<EventB>();
-    bus.template publish<EventC>();
-
-    ASSERT_EQ(bus.size(), (decltype(bus.size()))0);
-    ASSERT_TRUE(bus.empty());
-    ASSERT_EQ(listener->A, 0);
-    ASSERT_EQ(listener->B, 0);
-    ASSERT_EQ(listener->C, 0);
-
-    bus.reg(listener);
-    bus.template connect<EventB, &MyListener::listen>();
-
-    listener->reset();
-    bus.template publish<EventA>(40, 2);
-    bus.template publish<EventB>();
-    bus.template publish<EventC>();
-
-    ASSERT_EQ(bus.size(), (decltype(bus.size()))3);
-    ASSERT_FALSE(bus.empty());
-    ASSERT_EQ(listener->A, 1);
-    ASSERT_EQ(listener->B, 1);
-    ASSERT_EQ(listener->C, 1);
-
-    bus.unreg(listener);
-
-    listener->reset();
-    bus.template publish<EventA>(40, 2);
-    bus.template publish<EventB>();
-    bus.template publish<EventC>();
-
-    ASSERT_EQ(bus.size(), (decltype(bus.size()))1);
-    ASSERT_FALSE(bus.empty());
-    ASSERT_EQ(listener->A, 0);
-    ASSERT_EQ(listener->B, 1);
-    ASSERT_EQ(listener->C, 0);
-
-    bus.template disconnect<EventB, MyListener::listen>();
-
-    listener->reset();
-    bus.template publish<EventA>(40, 2);
-    bus.template publish<EventB>();
-    bus.template publish<EventC>();
-
-    ASSERT_EQ(bus.size(), (decltype(bus.size()))0);
-    ASSERT_TRUE(bus.empty());
-    ASSERT_EQ(listener->A, 0);
-    ASSERT_EQ(listener->B, 0);
-    ASSERT_EQ(listener->C, 0);
-}
-
-TEST(ManagedBus, RegUnregEmit) {
-    using MyManagedBus = entt::ManagedBus<EventA, EventB, EventC>;
-    testRegUnregEmit<MyManagedBus>(std::make_shared<MyListener>());
-}
-
-TEST(ManagedBus, ExpiredListeners) {
-    entt::ManagedBus<EventA, EventB, EventC> bus;
-    auto listener = std::make_shared<MyListener>();
-
-    listener->reset();
-    bus.reg(listener);
-    bus.template publish<EventA>(40, 2);
-    bus.template publish<EventB>();
-
-    ASSERT_EQ(bus.size(), (decltype(bus.size()))2);
-    ASSERT_FALSE(bus.empty());
-    ASSERT_EQ(listener->A, 1);
-    ASSERT_EQ(listener->B, 0);
-
-    listener->reset();
-    listener = nullptr;
-
-    ASSERT_EQ(bus.size(), (decltype(bus.size()))2);
-    ASSERT_FALSE(bus.empty());
-
-    EXPECT_NO_THROW(bus.template publish<EventA>(40, 2));
-    EXPECT_NO_THROW(bus.template publish<EventC>());
-
-    ASSERT_EQ(bus.size(), (decltype(bus.size()))0);
-    ASSERT_TRUE(bus.empty());
-}
-
-TEST(UnmanagedBus, RegUnregEmit) {
-    using MyUnmanagedBus = entt::UnmanagedBus<EventA, EventB, EventC>;
-    auto ptr = std::make_unique<MyListener>();
-    testRegUnregEmit<MyUnmanagedBus>(ptr.get());
-}
-
-TEST(UnmanagedBus, ExpiredListeners) {
-    entt::UnmanagedBus<EventA, EventB, EventC> bus;
-    auto listener = std::make_unique<MyListener>();
-
-    listener->reset();
-    bus.reg(listener.get());
-    bus.template publish<EventA>(40, 2);
-    bus.template publish<EventB>();
-
-    ASSERT_EQ(bus.size(), (decltype(bus.size()))2);
-    ASSERT_FALSE(bus.empty());
-    ASSERT_EQ(listener->A, 1);
-    ASSERT_EQ(listener->B, 0);
-
-    listener->reset();
-    listener = nullptr;
-
-    // dangling pointer inside ... well, unmanaged means unmanaged!! :-)
-    ASSERT_EQ(bus.size(), (decltype(bus.size()))2);
-    ASSERT_FALSE(bus.empty());
-}

test/entt/signal/delegate.cpp

@@ -1,12 +1,12 @@
 #include <gtest/gtest.h>
 #include <entt/signal/delegate.hpp>
 
-int f(int i) {
+int delegateFunction(int i) {
     return i*i;
 }
 
-struct S {
-    int f(int i) {
+struct DelegateFunctor {
+    int operator()(int i) {
         return i+i;
     }
 };
@@ -14,13 +14,16 @@ struct S {
 TEST(Delegate, Functionalities) {
     entt::Delegate<int(int)> ffdel;
     entt::Delegate<int(int)> mfdel;
-    S test;
+    DelegateFunctor functor;
 
-    ASSERT_EQ(ffdel(42), int{});
-    ASSERT_EQ(mfdel(42), int{});
+    ASSERT_TRUE(ffdel.empty());
+    ASSERT_TRUE(mfdel.empty());
 
-    ffdel.connect<&f>();
-    mfdel.connect<S, &S::f>(&test);
+    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);
@@ -28,14 +31,14 @@ TEST(Delegate, Functionalities) {
     ffdel.reset();
     mfdel.reset();
 
-    ASSERT_EQ(ffdel(42), int{});
-    ASSERT_EQ(mfdel(42), int{});
+    ASSERT_TRUE(ffdel.empty());
+    ASSERT_TRUE(mfdel.empty());
 }
 
 TEST(Delegate, Comparison) {
     entt::Delegate<int(int)> delegate;
     entt::Delegate<int(int)> def;
-    delegate.connect<&f>();
+    delegate.connect<&delegateFunction>();
 
     ASSERT_EQ(def, entt::Delegate<int(int)>{});
     ASSERT_NE(def, delegate);

test/entt/signal/dispatcher.cpp

@@ -2,46 +2,39 @@
 #include <gtest/gtest.h>
 #include <entt/signal/dispatcher.hpp>
 
-struct Event {};
+struct AnEvent {};
+struct AnotherEvent {};
 
 struct Receiver {
-    void receive(const Event &) { ++cnt; }
+    void receive(const AnEvent &) { ++cnt; }
     void reset() { cnt = 0; }
-    std::size_t cnt{0};
+    int cnt{0};
 };
 
-template<typename Dispatcher, typename Rec>
-void testDispatcher(Rec receiver) {
-    Dispatcher dispatcher;
+TEST(Dispatcher, Functionalities) {
+    entt::Dispatcher dispatcher;
+    Receiver receiver;
 
-    dispatcher.template connect<Event>(receiver);
-    dispatcher.template trigger<Event>();
-    dispatcher.template enqueue<Event>();
+    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, static_cast<decltype(receiver->cnt)>(1));
+    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.update();
-    dispatcher.template trigger<Event>();
+    dispatcher.template trigger<AnEvent>();
 
-    ASSERT_EQ(receiver->cnt, static_cast<decltype(receiver->cnt)>(3));
-
-    receiver->reset();
-
-    dispatcher.template disconnect<Event>(receiver);
-    dispatcher.template trigger<Event>();
-    dispatcher.template enqueue<Event>();
-    dispatcher.update();
-    dispatcher.template trigger<Event>();
-
-    ASSERT_EQ(receiver->cnt, static_cast<decltype(receiver->cnt)>(0));
-}
-
-TEST(ManagedDispatcher, Basics) {
-    testDispatcher<entt::ManagedDispatcher>(std::make_shared<Receiver>());
-}
-
-TEST(UnmanagedDispatcher, Basics) {
-    auto ptr = std::make_unique<Receiver>();
-    testDispatcher<entt::UnmanagedDispatcher>(ptr.get());
+    ASSERT_EQ(receiver.cnt, 0);
 }

test/entt/signal/sigh.cpp

@@ -3,163 +3,18 @@
 #include <gtest/gtest.h>
 #include <entt/signal/sigh.hpp>
 
-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) {
-    struct S {
-        void f() {}
-        void g() {}
-    };
-
-    entt::SigH<void()> sig1;
-    entt::SigH<void()> sig2;
-
-    S s1;
-    S s2;
-
-    sig1.connect<S, &S::f>(&s1);
-    sig2.connect<S, &S::f>(&s2);
-
-    ASSERT_FALSE(sig1 == sig2);
-    ASSERT_TRUE(sig1 != sig2);
-
-    sig1.disconnect<S, &S::f>(&s1);
-    sig2.disconnect<S, &S::f>(&s2);
-
-    sig1.connect<S, &S::f>(&s1);
-    sig2.connect<S, &S::g>(&s1);
-
-    ASSERT_FALSE(sig1 == sig2);
-    ASSERT_TRUE(sig1 != sig2);
-
-    sig1.disconnect<S, &S::f>(&s1);
-    sig2.disconnect<S, &S::g>(&s1);
-
-    ASSERT_TRUE(sig1 == sig2);
-    ASSERT_FALSE(sig1 != sig2);
-
-    sig1.connect<S, &S::f>(&s1);
-    sig1.connect<S, &S::g>(&s1);
-    sig2.connect<S, &S::f>(&s1);
-    sig2.connect<S, &S::g>(&s1);
-
-    ASSERT_TRUE(sig1 == sig2);
-
-    sig1.disconnect<S, &S::f>(&s1);
-    sig1.disconnect<S, &S::g>(&s1);
-    sig2.disconnect<S, &S::f>(&s1);
-    sig2.disconnect<S, &S::g>(&s1);
-
-    sig1.connect<S, &S::f>(&s1);
-    sig1.connect<S, &S::g>(&s1);
-    sig2.connect<S, &S::g>(&s1);
-    sig2.connect<S, &S::f>(&s1);
-
-    ASSERT_FALSE(sig1 == sig2);
-}
-
-struct S {
+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};
 };
 
-TEST(SigH, Clear) {
-    entt::SigH<void(int &)> sigh;
-    sigh.connect<&S::f>();
-
-    ASSERT_FALSE(sigh.empty());
-
-    sigh.clear();
-
-    ASSERT_TRUE(sigh.empty());
-}
-
-TEST(SigH, Swap) {
-    entt::SigH<void(int &)> sigh1;
-    entt::SigH<void(int &)> sigh2;
-
-    sigh1.connect<&S::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.connect<&S::f>();
-    sigh.publish(v);
-
-    ASSERT_FALSE(sigh.empty());
-    ASSERT_EQ((entt::SigH<bool(int)>::size_type)1, sigh.size());
-    ASSERT_EQ(42, v);
-
-    v = 0;
-    sigh.disconnect<&S::f>();
-    sigh.publish(v);
-
-    ASSERT_TRUE(sigh.empty());
-    ASSERT_EQ((entt::SigH<bool(int)>::size_type)0, sigh.size());
-    ASSERT_EQ(0, v);
-
-    sigh.connect<&S::f>();
-}
-
-TEST(SigH, Members) {
-    struct S {
-        bool f(int) { b = !b; return true; }
-        bool g(int) { return b; }
-        bool b{false};
-    };
-
-    S s;
-    S *ptr = &s;
-    entt::SigH<bool(int)> sigh;
-
-    sigh.connect<S, &S::f>(ptr);
-    sigh.publish(42);
-
-    ASSERT_TRUE(s.b);
-    ASSERT_FALSE(sigh.empty());
-    ASSERT_EQ((entt::SigH<bool(int)>::size_type)1, sigh.size());
-
-    sigh.disconnect<S, &S::f>(ptr);
-    sigh.publish(42);
-
-    ASSERT_TRUE(s.b);
-    ASSERT_TRUE(sigh.empty());
-    ASSERT_EQ((entt::SigH<bool(int)>::size_type)0, sigh.size());
-
-    sigh.connect<S, &S::f>(ptr);
-    sigh.connect<S, &S::g>(ptr);
-
-    ASSERT_FALSE(sigh.empty());
-    ASSERT_EQ((entt::SigH<bool(int)>::size_type)2, sigh.size());
-
-    sigh.disconnect(ptr);
-
-    ASSERT_TRUE(sigh.empty());
-    ASSERT_EQ((entt::SigH<bool(int)>::size_type)0, sigh.size());
-}
-
 template<typename Ret>
 struct TestCollectAll {
     std::vector<Ret> vec{};
@@ -190,10 +45,152 @@ struct TestCollectFirst {
     }
 };
 
+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((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((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((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((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((entt::SigH<bool(int)>::size_type)2, sigh.size());
+
+    sigh.sink().disconnect(ptr);
+
+    ASSERT_TRUE(sigh.empty());
+    ASSERT_EQ((entt::SigH<bool(int)>::size_type)0, sigh.size());
+}
+
 TEST(SigH, Collector) {
     entt::SigH<void(), TestCollectAll<void>> sigh_void;
 
-    sigh_void.connect<&TestCollectAll<void>::h>();
+    sigh_void.sink().connect<&TestCollectAll<void>::h>();
     auto collector_void = sigh_void.collect();
 
     ASSERT_FALSE(sigh_void.empty());
@@ -201,9 +198,9 @@ TEST(SigH, Collector) {
 
     entt::SigH<int(), TestCollectAll<int>> sigh_all;
 
-    sigh_all.connect<&TestCollectAll<int>::f>();
-    sigh_all.connect<&TestCollectAll<int>::f>();
-    sigh_all.connect<&TestCollectAll<int>::g>();
+    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());
@@ -214,8 +211,8 @@ TEST(SigH, Collector) {
 
     entt::SigH<int(), TestCollectFirst<int>> sigh_first;
 
-    sigh_first.connect<&TestCollectFirst<int>::f>();
-    sigh_first.connect<&TestCollectFirst<int>::f>();
+    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());

test/entt/signal/signal.cpp

@@ -1,179 +0,0 @@
-#include <memory>
-#include <utility>
-#include <gtest/gtest.h>
-#include <entt/signal/signal.hpp>
-
-struct S {
-    static void f(const int &j) { i = j; }
-    void g(const int &j) { i = j; }
-    void h(const int &) {}
-    static int i;
-};
-
-int S::i = 0;
-
-TEST(Signal, Lifetime) {
-    using signal = entt::Signal<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(Signal, Comparison) {
-    struct S {
-        void f() {}
-        void g() {}
-    };
-
-    entt::Signal<void()> sig1;
-    entt::Signal<void()> sig2;
-
-    auto s1 = std::make_shared<S>();
-    auto s2 = std::make_shared<S>();
-
-    sig1.connect<S, &S::f>(s1);
-    sig2.connect<S, &S::f>(s2);
-
-    ASSERT_FALSE(sig1 == sig2);
-    ASSERT_TRUE(sig1 != sig2);
-
-    sig1.disconnect<S, &S::f>(s1);
-    sig2.disconnect<S, &S::f>(s2);
-
-    sig1.connect<S, &S::f>(s1);
-    sig2.connect<S, &S::g>(s1);
-
-    ASSERT_FALSE(sig1 == sig2);
-    ASSERT_TRUE(sig1 != sig2);
-
-    sig1.disconnect<S, &S::f>(s1);
-    sig2.disconnect<S, &S::g>(s1);
-
-    ASSERT_TRUE(sig1 == sig2);
-    ASSERT_FALSE(sig1 != sig2);
-
-    sig1.connect<S, &S::f>(s1);
-    sig1.connect<S, &S::g>(s1);
-    sig2.connect<S, &S::f>(s1);
-    sig2.connect<S, &S::g>(s1);
-
-    ASSERT_TRUE(sig1 == sig2);
-
-    sig1.disconnect<S, &S::f>(s1);
-    sig1.disconnect<S, &S::g>(s1);
-    sig2.disconnect<S, &S::f>(s1);
-    sig2.disconnect<S, &S::g>(s1);
-
-    sig1.connect<S, &S::f>(s1);
-    sig1.connect<S, &S::g>(s1);
-    sig2.connect<S, &S::g>(s1);
-    sig2.connect<S, &S::f>(s1);
-
-    ASSERT_FALSE(sig1 == sig2);
-}
-
-TEST(Signal, Clear) {
-    entt::Signal<void(const int &)> signal;
-    signal.connect<&S::f>();
-
-    ASSERT_FALSE(signal.empty());
-
-    signal.clear();
-
-    ASSERT_TRUE(signal.empty());
-}
-
-TEST(Signal, Swap) {
-    entt::Signal<void(const int &)> sig1;
-    entt::Signal<void(const int &)> sig2;
-
-    sig1.connect<&S::f>();
-
-    ASSERT_FALSE(sig1.empty());
-    ASSERT_TRUE(sig2.empty());
-
-    std::swap(sig1, sig2);
-
-    ASSERT_TRUE(sig1.empty());
-    ASSERT_FALSE(sig2.empty());
-}
-
-TEST(Signal, Functions) {
-    entt::Signal<void(const int &)> signal;
-    auto val = S::i + 1;
-
-    signal.connect<&S::f>();
-    signal.publish(val);
-
-    ASSERT_FALSE(signal.empty());
-    ASSERT_EQ(entt::Signal<void(const int &)>::size_type{1}, signal.size());
-    ASSERT_EQ(S::i, val);
-
-    signal.disconnect<&S::f>();
-    signal.publish(val+1);
-
-    ASSERT_TRUE(signal.empty());
-    ASSERT_EQ(entt::Signal<void(const int &)>::size_type{0}, signal.size());
-    ASSERT_EQ(S::i, val);
-}
-
-TEST(Signal, Members) {
-    entt::Signal<void(const int &)> signal;
-    auto ptr = std::make_shared<S>();
-    auto val = S::i + 1;
-
-    signal.connect<S, &S::g>(ptr);
-    signal.publish(val);
-
-    ASSERT_FALSE(signal.empty());
-    ASSERT_EQ(entt::Signal<void(const int &)>::size_type{1}, signal.size());
-    ASSERT_EQ(S::i, val);
-
-    signal.disconnect<S, &S::g>(ptr);
-    signal.publish(val+1);
-
-    ASSERT_TRUE(signal.empty());
-    ASSERT_EQ(entt::Signal<void(const int &)>::size_type{0}, signal.size());
-    ASSERT_EQ(S::i, val);
-
-    ++val;
-
-    signal.connect<S, &S::g>(ptr);
-    signal.connect<S, &S::h>(ptr);
-    signal.publish(val);
-
-    ASSERT_FALSE(signal.empty());
-    ASSERT_EQ(entt::Signal<void(const int &)>::size_type{2}, signal.size());
-    ASSERT_EQ(S::i, val);
-
-    signal.disconnect(ptr);
-    signal.publish(val+1);
-
-    ASSERT_TRUE(signal.empty());
-    ASSERT_EQ(entt::Signal<void(const int &)>::size_type{0}, signal.size());
-    ASSERT_EQ(S::i, val);
-}
-
-TEST(Signal, Cleanup) {
-    entt::Signal<void(const int &)> signal;
-    auto ptr = std::make_shared<S>();
-    signal.connect<S, &S::g>(ptr);
-    auto val = S::i;
-    ptr = nullptr;
-
-    ASSERT_FALSE(signal.empty());
-    ASSERT_EQ(S::i, val);
-
-    signal.publish(val);
-
-    ASSERT_TRUE(signal.empty());
-    ASSERT_EQ(S::i, val);
-}

test/mod/mod.cpp

@@ -135,7 +135,6 @@ duk_ret_t get<DuktapeRuntime>(duk_context *ctx, entt::DefaultRegistry &registry)
     duk_push_string(ctx, runtime.components[type].c_str());
     duk_json_decode(ctx, -1);
 
-
     return 1;
 }
 
@@ -157,7 +156,7 @@ class DuktapeRegistry {
     template<typename... Comp>
     void reg() {
         using accumulator_type = int[];
-        accumulator_type acc = { (func[registry.component<Comp>()] = {
+        accumulator_type acc = { (func[registry.type<Comp>()] = {
                                      &::set<Comp>,
                                      &::unset<Comp>,
                                      &::has<Comp>,
@@ -186,7 +185,7 @@ class DuktapeRegistry {
         auto type = duk_require_uint(ctx, 1);
 
         if(type >= udef) {
-            type = registry.component<DuktapeRuntime>();
+            type = registry.type<DuktapeRuntime>();
         }
 
         assert(func.find(type) != func.cend());
@@ -236,34 +235,41 @@ public:
 
         duk_push_array(ctx);
 
-        dreg.registry.each([ctx, nargs, &pos, &dreg](auto entity) {
-            auto &registry = dreg.registry;
-            auto &func = dreg.func;
-            bool match = true;
+        std::vector<typename entt::DefaultRegistry::component_type> components;
+        std::vector<typename entt::DefaultRegistry::component_type> runtime;
 
-            for (duk_idx_t arg = 0; match && arg < nargs; arg++) {
-                auto type = duk_require_uint(ctx, arg);
+        for(duk_idx_t arg = 0; arg < nargs; arg++) {
+            auto type = duk_require_uint(ctx, arg);
 
-                if(type < udef) {
-                    assert(func.find(type) != func.cend());
-                    match = (registry.*func[type].test)(entity);
-                } else {
-                    const auto ctype = registry.component<DuktapeRuntime>();
-                    assert(func.find(ctype) != func.cend());
-                    match = (registry.*func[ctype].test)(entity);
-
-                    if(match) {
-                        auto &components = registry.get<DuktapeRuntime>(entity).components;
-                        match = (components.find(type) != components.cend());
-                    }
+            if(type < udef) {
+                components.push_back(type);
+            } else {
+                if(runtime.empty()) {
+                    components.push_back(dreg.registry.type<DuktapeRuntime>());
                 }
-            }
 
-            if(match) {
+                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;
     }
@@ -287,7 +293,7 @@ const duk_function_list_entry js_DuktapeRegistry_methods[] = {
 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 component<typename decltype(type)::type>());
+        duk_push_uint(ctx, registry.template type<typename decltype(type)::type>());
         duk_def_prop(ctx, idx, DUK_DEFPROP_HAVE_VALUE | DUK_DEFPROP_CLEAR_WRITABLE);
     };
 
@@ -331,8 +337,12 @@ TEST(Mod, Duktape) {
         FAIL();
     }
 
-    registry.create(Position{ 0., 0. }, Renderable{});
-    registry.create(Position{ 0., 0. });
+    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) {"

test/snapshot/snapshot.cpp

@@ -18,17 +18,17 @@ struct Relationship {
     entt::DefaultRegistry::entity_type parent;
 };
 
-template<class Archive>
+template<typename Archive>
 void serialize(Archive &archive, Position &position) {
   archive(position.x, position.y);
 }
 
-template<class Archive>
+template<typename Archive>
 void serialize(Archive &archive, Timer &timer) {
   archive(timer.duration);
 }
 
-template<class Archive>
+template<typename Archive>
 void serialize(Archive &archive, Relationship &relationship) {
   archive(relationship.parent);
 }
@@ -128,8 +128,7 @@ TEST(Snapshot, Continuous) {
     cereal::JSONInputArchive input{storage};
     entt::ContinuousLoader<entt::DefaultRegistry::entity_type> loader{destination};
     loader.entities(input)
-            .component<Position>(input)
-            .component<Relationship>(input, &Relationship::parent)
+            .component<Position, Relationship>(input, &Relationship::parent)
             .component<Timer>(input);
 
     ASSERT_FALSE(destination.valid(e0));