update single include file

* reserve a seq identifier for empty type_info objects
* require type_index to return non-zero values
* make type_info default constructible
* add type_info::operator bool()

.clang-format

@@ -0,0 +1,41 @@
+BasedOnStyle: llvm
+---
+AccessModifierOffset: -4
+AlignEscapedNewlines: DontAlign
+AllowShortBlocksOnASingleLine: Empty
+AllowShortEnumsOnASingleLine: true
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortIfStatementsOnASingleLine: WithoutElse
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakTemplateDeclarations: Yes
+BreakBeforeBinaryOperators: NonAssignment
+BreakBeforeTernaryOperators: true
+ColumnLimit: 0
+DerivePointerAlignment: false
+IncludeCategories:
+  - Regex: '<[[:alnum:]_]+>'
+    Priority: 1
+  - Regex: '<(gtest|gmock)/'
+    Priority: 2
+  - Regex: '<[[:alnum:]_./]+>'
+    Priority: 3
+  - Regex: '<entt/'
+    Priority: 4
+  - Regex: '.*'
+    Priority: 5
+IndentPPDirectives: AfterHash
+IndentWidth: 4
+KeepEmptyLinesAtTheStartOfBlocks: false
+Language: Cpp
+PointerAlignment: Right
+SpaceAfterCStyleCast: false
+SpaceAfterTemplateKeyword: false
+SpaceAroundPointerQualifiers: After
+SpaceBeforeCaseColon: false
+SpaceBeforeCtorInitializerColon: false
+SpaceBeforeInheritanceColon: false
+SpaceBeforeParens: Never
+SpaceBeforeRangeBasedForLoopColon: false
+Standard: Latest
+TabWidth: 4
+UseTab: Never

.github/FUNDING.yml

@@ -0,0 +1,4 @@
+# These are supported funding model platforms
+
+github: skypjack
+custom: https://www.paypal.me/skypjack

.github/workflows/build.yml

@@ -0,0 +1,169 @@
+name: build
+
+on: [push, pull_request]
+
+jobs:
+
+  linux:
+    timeout-minutes: 15
+
+    strategy:
+      matrix:
+        compiler:
+          - pkg: g++-7
+            exe: g++-7
+          - pkg: g++-8
+            exe: g++-8
+          - pkg: g++-9
+            exe: g++-9
+          - pkg: g++-10
+            exe: g++-10
+          - pkg: clang-8
+            exe: clang++-8
+          - pkg: clang-9
+            exe: clang++-9
+          - pkg: clang-10
+            exe: clang++-10
+          - pkg: clang-11
+            exe: clang++-11
+          - pkg: clang-12
+            exe: clang++-12
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Install compiler
+      run: |
+        sudo apt update
+        sudo apt install -y ${{ matrix.compiler.pkg }}
+    - name: Compile tests
+      working-directory: build
+      env:
+        CXX: ${{ matrix.compiler.exe }}
+      run: |
+        cmake -DENTT_BUILD_TESTING=ON -DENTT_BUILD_LIB=ON -DENTT_BUILD_EXAMPLE=ON ..
+        make -j4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 30 -C Debug -j4
+
+  linux-extra:
+    timeout-minutes: 15
+
+    strategy:
+      matrix:
+        compiler: [g++, clang++]
+        id_type: ["std::uint32_t", "std::uint64_t"]
+        cxx_std: [cxx_std_17, cxx_std_20]
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      env:
+        CXX: ${{ matrix.compiler }}
+      run: |
+        cmake -DENTT_BUILD_TESTING=ON -DENTT_CXX_STD=${{ matrix.cxx_std }} -DENTT_ID_TYPE=${{ matrix.id_type }} ..
+        make -j4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 30 -C Debug -j4
+
+  windows:
+    timeout-minutes: 15
+
+    strategy:
+      matrix:
+        toolset: [default, v141, v142, clang-cl]
+        include:
+          - toolset: v141
+            toolset_option: -T"v141"
+          - toolset: v142
+            toolset_option: -T"v142"
+          - toolset: clang-cl
+            toolset_option: -T"ClangCl"
+
+    runs-on: windows-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      run: |
+        cmake -DENTT_BUILD_TESTING=ON -DENTT_BUILD_LIB=ON -DENTT_BUILD_EXAMPLE=ON ${{ matrix.toolset_option }} ..
+        cmake --build . -j 4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 30 -C Debug -j4
+
+  windows-extra:
+    timeout-minutes: 15
+
+    strategy:
+      matrix:
+        id_type: ["std::uint32_t", "std::uint64_t"]
+        cxx_std: [cxx_std_17, cxx_std_20]
+
+    runs-on: windows-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      run: |
+        cmake -DENTT_BUILD_TESTING=ON -DENTT_CXX_STD=${{ matrix.cxx_std }} -DENTT_ID_TYPE=${{ matrix.id_type }} ..
+        cmake --build . -j 4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 30 -C Debug -j4
+
+  macos:
+    timeout-minutes: 15
+    runs-on: macOS-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      run: |
+        cmake -DENTT_BUILD_TESTING=ON -DENTT_BUILD_LIB=ON -DENTT_BUILD_EXAMPLE=ON ..
+        make -j4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 30 -C Debug -j4
+
+  macos-extra:
+    timeout-minutes: 15
+
+    strategy:
+      matrix:
+        id_type: ["std::uint32_t", "std::uint64_t"]
+        cxx_std: [cxx_std_17, cxx_std_20]
+
+    runs-on: macOS-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      run: |
+        cmake -DENTT_BUILD_TESTING=ON -DENTT_CXX_STD=${{ matrix.cxx_std }} -DENTT_ID_TYPE=${{ matrix.id_type }} ..
+        make -j4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 30 -C Debug -j4

.github/workflows/coverage.yml

@@ -0,0 +1,38 @@
+name: coverage
+
+on: [push, pull_request]
+
+jobs:
+
+  codecov:
+    timeout-minutes: 15
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      env:
+        CXXFLAGS: "--coverage -fno-inline"
+        CXX: g++
+      run: |
+        cmake -DENTT_BUILD_TESTING=ON -DENTT_BUILD_LIB=ON -DENTT_BUILD_EXAMPLE=ON ..
+        make -j4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 30 -C Debug -j4
+    - name: Collect data
+      working-directory: build
+      run: |
+        sudo apt install lcov
+        lcov -c -d . -o coverage.info
+        lcov -l coverage.info
+    - name: Upload coverage to Codecov
+      uses: codecov/codecov-action@v2
+      with:
+        token: ${{ secrets.CODECOV_TOKEN }}
+        files: build/coverage.info
+        name: EnTT
+        fail_ci_if_error: true

.github/workflows/deploy.yml

@@ -0,0 +1,39 @@
+name: deploy
+
+on:
+  release:
+    types: published
+
+jobs:
+
+  homebrew-entt:
+    timeout-minutes: 5
+    runs-on: ubuntu-latest
+
+    env:
+      GH_REPO: homebrew-entt
+      FORMULA: entt.rb
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Clone repository
+      working-directory: build
+      env:
+        PERSONAL_ACCESS_TOKEN: ${{ secrets.PERSONAL_ACCESS_TOKEN }}
+      run: git clone https://$GITHUB_ACTOR:$PERSONAL_ACCESS_TOKEN@github.com/$GITHUB_ACTOR/$GH_REPO.git
+    - name: Prepare formula
+      working-directory: build
+      run: |
+        cd $GH_REPO
+        curl "https://github.com/${{ github.repository }}/archive/${{ github.ref }}.tar.gz" --location --fail --silent --show-error --output archive.tar.gz
+        sed -i -e '/url/s/".*"/"'$(echo "https://github.com/${{ github.repository }}/archive/${{ github.ref }}.tar.gz" | sed -e 's/[\/&]/\\&/g')'"/' $FORMULA
+        sed -i -e '/sha256/s/".*"/"'$(openssl sha256 archive.tar.gz | cut -d " " -f 2)'"/' $FORMULA
+    - name: Update remote
+      working-directory: build
+      run: |
+        cd $GH_REPO
+        git config --local user.email "action@github.com"
+        git config --local user.name "$GITHUB_ACTOR"
+        git add $FORMULA
+        git commit -m "Update to ${{ github.ref }}"
+        git push origin master

.github/workflows/sanitizer.yml

@@ -0,0 +1,31 @@
+name: sanitizer
+
+on: [push, pull_request]
+
+jobs:
+
+  clang:
+    timeout-minutes: 15
+
+    strategy:
+      matrix:
+        compiler: [clang++]
+        id_type: ["std::uint32_t", "std::uint64_t"]
+        cxx_std: [cxx_std_17, cxx_std_20]
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      env:
+        CXX: ${{ matrix.compiler }}
+      run: |
+        cmake -DENTT_USE_SANITIZER=ON -DENTT_BUILD_TESTING=ON -DENTT_BUILD_LIB=ON -DENTT_BUILD_EXAMPLE=ON -DENTT_CXX_STD=${{ matrix.cxx_std }} -DENTT_ID_TYPE=${{ matrix.id_type }} ..
+        make -j4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 30 -C Debug -j4

.gitignore

@@ -1,2 +1,13 @@
-# QtCreator
+# Conan
+conan/test_package/build
+
+# IDEs
 *.user
+.idea
+.vscode
+.vs
+CMakeSettings.json
+cpp.hint
+
+# Bazel
+/bazel-*

.travis.yml

@@ -1,73 +0,0 @@
-language: cpp
-dist: trusty
-sudo: false
-
-matrix:
-  include:
-  - os: linux
-    compiler: gcc
-    addons:
-      apt:
-        sources: ['ubuntu-toolchain-r-test']
-        packages: ['g++-6']
-    env: COMPILER=g++-6
-  - os: linux
-    compiler: gcc
-    addons:
-      apt:
-        sources: ['ubuntu-toolchain-r-test']
-        packages: ['g++-7']
-    env: COMPILER=g++-7
-  - os: linux
-    compiler: clang
-    addons:
-      apt:
-        sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-4.0']
-        packages: ['clang-4.0', 'libstdc++-4.9-dev']
-    env: COMPILER=clang++-4.0
-  - os: linux
-    compiler: clang
-    addons:
-      apt:
-        sources: ['ubuntu-toolchain-r-test', 'llvm-toolchain-trusty-5.0']
-        packages: ['clang-5.0', 'libstdc++-4.9-dev']
-    env: COMPILER=clang++-5.0
-  - os: osx
-    osx_image: xcode8.3
-    compiler: clang
-    env: COMPILER=clang++
-  - os: osx
-    osx_image: xcode9.1
-    compiler: clang
-    env: COMPILER=clang++
-  - os: linux
-    compiler: gcc
-    addons:
-      apt:
-        sources: ['ubuntu-toolchain-r-test']
-        packages: ['g++-7']
-    env:
-      - COMPILER=g++-7
-      - CXXFLAGS="-O0 --coverage -fno-inline -fno-inline-small-functions -fno-default-inline"
-    before_script:
-      - pip install --user cpp-coveralls
-    after_success:
-      - coveralls --gcov gcov-7 --gcov-options '\-lp' --root ${TRAVIS_BUILD_DIR} --build-root ${TRAVIS_BUILD_DIR}/build --extension cpp --extension hpp --exclude deps --include src
-
-notifications:
-  email:
-    on_success: never
-    on_failure: always
-
-install:
-- echo ${PATH}
-- cmake --version
-- export CXX=${COMPILER}
-- echo ${CXX}
-- ${CXX} --version
-- ${CXX} -v
-
-script:
-- mkdir -p build && cd build
-- cmake .. && make -j4
-- CTEST_OUTPUT_ON_FAILURE=1 make test

AUTHORS

@@ -1,7 +1,53 @@
 # Author
 
-Michele Caini aka skypjack
+skypjack
 
 # Contributors
 
-Paolo Monteverde aka morbo84
+alexames
+BenediktConze
+bjadamson
+ceeac
+ColinH
+corystegel
+Croydon
+cugone
+dbacchet
+dBagrat
+djarek
+DonKult
+drglove
+eliasdaler
+erez-o
+eugeneko
+gale83
+ghost
+grdowns
+Green-Sky
+Innokentiy-Alaytsev
+Kerndog73
+Koward
+Lawrencemm
+markand
+mhammerc
+Milerius
+Minimonium
+morbo84
+m-waka
+netpoetica
+NixAJ
+Oortonaut
+Paolo-Oliverio
+pgruenbacher
+prowolf
+stefanofiorentino
+suVrik
+szunhammer
+The5-1
+vblanco20-1
+willtunnels
+WizardIke
+WoLfulus 
+w1th0utnam3
+xissburg
+zaucy

BUILD.bazel

@@ -0,0 +1,14 @@
+_msvc_copts = ["/std:c++17"]	
+_gcc_copts = ["-std=c++17"]
+
+cc_library(
+    name = "entt",
+    visibility = ["//visibility:public"],
+    strip_include_prefix = "src",
+    hdrs = glob(["src/**/*.h", "src/**/*.hpp"]),
+    copts = select({
+      "@bazel_tools//src/conditions:windows": _msvc_copts,
+      "@bazel_tools//src/conditions:windows_msvc": _msvc_copts,
+      "//conditions:default": _gcc_copts,
+    }),
+)

CMakeLists.txt

@@ -2,85 +2,295 @@
 # EnTT
 #
 
-cmake_minimum_required(VERSION 3.2)
+cmake_minimum_required(VERSION 3.12.4)
 
 #
-# Building in-tree is not allowed (we take care of your craziness).
+# Read project version
 #
 
-if(${CMAKE_SOURCE_DIR} STREQUAL ${CMAKE_BINARY_DIR})
-    message(FATAL_ERROR "Prevented in-tree built. Please create a build directory outside of the source code and call cmake from there. Thank you.")
-endif()
+set(ENTT_VERSION_REGEX "#define ENTT_VERSION_.*[ \t]+(.+)")
+file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/src/entt/config/version.h" ENTT_VERSION REGEX ${ENTT_VERSION_REGEX})
+list(TRANSFORM ENTT_VERSION REPLACE ${ENTT_VERSION_REGEX} "\\1")
+string(JOIN "." ENTT_VERSION ${ENTT_VERSION})
 
 #
 # Project configuration
 #
 
-project(entt VERSION 2.3.0)
+project(
+    EnTT
+    VERSION ${ENTT_VERSION}
+    DESCRIPTION "Gaming meets modern C++ - a fast and reliable entity-component system (ECS) and much more"
+    HOMEPAGE_URL "https://github.com/skypjack/entt"
+    LANGUAGES C CXX
+)
 
 if(NOT CMAKE_BUILD_TYPE)
     set(CMAKE_BUILD_TYPE Debug)
 endif()
 
-set(SETTINGS_ORGANIZATION "Michele Caini")
-set(SETTINGS_APPLICATION ${PROJECT_NAME})
-set(PROJECT_AUTHOR "Michele Caini")
-set(PROJECT_AUTHOR_EMAIL "michele.caini@gmail.com")
-
-message("*")
-message("* ${PROJECT_NAME} v${PROJECT_VERSION} (${CMAKE_BUILD_TYPE})")
-message("* Copyright (c) 2017 ${PROJECT_AUTHOR} <${PROJECT_AUTHOR_EMAIL}>")
-message("*")
+message(VERBOSE "*")
+message(VERBOSE "* ${PROJECT_NAME} v${PROJECT_VERSION} (${CMAKE_BUILD_TYPE})")
+message(VERBOSE "* Copyright (c) 2017-2022 Michele Caini <michele.caini@gmail.com>")
+message(VERBOSE "*")
 
 #
 # Compiler stuff
 #
 
-set(CMAKE_CXX_STANDARD 14)
-set(CMAKE_CXX_STANDARD_REQUIRED ON)
+option(ENTT_USE_LIBCPP "Use libc++ by adding -stdlib=libc++ flag if available." OFF)
+option(ENTT_USE_SANITIZER "Enable sanitizers by adding -fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined flags if available." OFF)
 
-if(NOT MSVC)
-    set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -Wl,--no-undefined")
-    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")
+if(ENTT_USE_LIBCPP)
+    if(NOT WIN32)
+        include(CheckCXXSourceCompiles)
+        include(CMakePushCheckState)
 
-    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")
+        cmake_push_check_state()
+
+        set(CMAKE_REQUIRED_FLAGS "${CMAKE_REQUIRED_FLAGS} -stdlib=libc++")
+
+        check_cxx_source_compiles("
+            #include<type_traits>
+            int main() { return std::is_same_v<int, char>; }
+        " ENTT_HAS_LIBCPP)
+
+        cmake_pop_check_state()
+    endif()
+
+    if(NOT ENTT_HAS_LIBCPP)
+        message(VERBOSE "The option ENTT_USE_LIBCPP is set but libc++ is not available. The flag will not be added to the target.")
+    endif()
+endif()
+
+if(ENTT_USE_SANITIZER)
+    if(CMAKE_CXX_COMPILER_ID MATCHES "Clang|GNU")
+        set(ENTT_HAS_SANITIZER TRUE CACHE BOOL "" FORCE)
+        mark_as_advanced(ENTT_HAS_SANITIZER)
+    endif()
+
+    if(NOT ENTT_HAS_SANITIZER)
+        message(VERBOSE "The option ENTT_USE_SANITIZER is set but sanitizer support is not available. The flags will not be added to the target.")
     endif()
 endif()
 
 #
-# Include EnTT
+# Add EnTT target
 #
 
-include_directories(${entt_SOURCE_DIR}/src)
+option(ENTT_INCLUDE_HEADERS "Add all EnTT headers to the EnTT target." OFF)
+option(ENTT_INCLUDE_NATVIS "Add EnTT natvis files to the EnTT target." OFF)
+
+if(ENTT_INCLUDE_NATVIS)
+    if(MSVC)
+        set(ENTT_HAS_NATVIS TRUE CACHE BOOL "" FORCE)
+        mark_as_advanced(ENTT_HAS_NATVIS)
+    endif()
+
+    if(NOT ENTT_HAS_NATVIS)
+        message(VERBOSE "The option ENTT_INCLUDE_NATVIS is set but natvis files are not supported. They will not be added to the target.")
+    endif()
+endif()
+
+include(GNUInstallDirs)
+
+add_library(EnTT INTERFACE)
+add_library(EnTT::EnTT ALIAS EnTT)
+
+target_include_directories(
+    EnTT
+    INTERFACE
+        $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
+)
+
+target_compile_features(EnTT INTERFACE cxx_std_17)
+
+if(ENTT_INCLUDE_HEADERS)
+    target_sources(
+        EnTT
+        INTERFACE
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/config/config.h>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/config/macro.h>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/config/version.h>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/container/dense_map.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/container/dense_set.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/container/fwd.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/algorithm.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/any.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/attribute.h>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/compressed_pair.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/enum.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/family.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/fwd.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/hashed_string.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/ident.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/iterator.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/memory.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/monostate.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/tuple.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/type_info.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/type_traits.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/core/utility.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/component.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/entity.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/fwd.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/group.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/handle.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/helper.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/observer.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/organizer.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/registry.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/runtime_view.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/sigh_storage_mixin.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/snapshot.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/sparse_set.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/storage.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/utility.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entity/view.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/locator/locator.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/adl_pointer.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/container.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/ctx.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/factory.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/fwd.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/meta.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/node.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/pointer.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/policy.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/range.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/resolve.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/template.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/type_traits.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/meta/utility.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/platform/android-ndk-r17.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/poly/fwd.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/poly/poly.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/process/process.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/process/scheduler.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/resource/cache.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/resource/fwd.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/resource/loader.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/resource/resource.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/signal/delegate.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/signal/dispatcher.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/signal/emitter.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/signal/fwd.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/signal/sigh.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/entt.hpp>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src/entt/fwd.hpp>
+    )
+endif()
+
+if(ENTT_HAS_NATVIS)
+    target_sources(
+        EnTT
+        INTERFACE
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/config.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/container.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/core.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/entity.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/locator.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/meta.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/platform.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/poly.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/process.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/resource.natvis>
+            $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/natvis/entt/signal.natvis>
+    )
+endif()
+
+if(ENTT_HAS_SANITIZER)
+    target_compile_options(EnTT INTERFACE $<$<CONFIG:Debug>:-fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined>)
+    target_link_libraries(EnTT INTERFACE $<$<CONFIG:Debug>:-fsanitize=address -fno-omit-frame-pointer -fsanitize=undefined>)
+endif()
+
+if(ENTT_HAS_LIBCPP)
+    target_compile_options(EnTT BEFORE INTERFACE -stdlib=libc++)
+endif()
+
+#
+# Install pkg-config file
+#
+
+set(EnTT_PKGCONFIG ${CMAKE_CURRENT_BINARY_DIR}/entt.pc)
+
+configure_file(
+    ${EnTT_SOURCE_DIR}/cmake/in/entt.pc.in
+    ${EnTT_PKGCONFIG}
+    @ONLY
+)
+
+install(
+    FILES ${EnTT_PKGCONFIG}
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig
+)
+
+#
+# Install EnTT
+#
+
+include(CMakePackageConfigHelpers)
+
+install(
+    TARGETS EnTT
+    EXPORT EnTTTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+)
+
+write_basic_package_version_file(
+    EnTTConfigVersion.cmake
+    VERSION ${PROJECT_VERSION}
+    COMPATIBILITY AnyNewerVersion
+)
+
+configure_package_config_file(
+    ${EnTT_SOURCE_DIR}/cmake/in/EnTTConfig.cmake.in
+    EnTTConfig.cmake
+    INSTALL_DESTINATION ${CMAKE_INSTALL_LIBDIR}/EnTT/cmake
+)
+
+export(
+    EXPORT EnTTTargets
+    FILE ${CMAKE_CURRENT_BINARY_DIR}/EnTTTargets.cmake
+    NAMESPACE EnTT::
+)
+
+install(
+    EXPORT EnTTTargets
+    FILE EnTTTargets.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/EnTT/cmake
+    NAMESPACE EnTT::
+)
+
+install(
+    FILES
+        ${PROJECT_BINARY_DIR}/EnTTConfig.cmake
+        ${PROJECT_BINARY_DIR}/EnTTConfigVersion.cmake
+    DESTINATION ${CMAKE_INSTALL_LIBDIR}/EnTT/cmake
+)
+
+install(DIRECTORY src/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
+
+export(PACKAGE EnTT)
 
 #
 # Tests
 #
 
-option(BUILD_TESTING "Enable testing with ctest." ON)
+option(ENTT_BUILD_TESTING "Enable building tests." OFF)
 
-if(BUILD_TESTING)
-    set(THREADS_PREFER_PTHREAD_FLAG ON)
-    find_package(Threads REQUIRED)
+if(ENTT_BUILD_TESTING)
+    option(ENTT_FIND_GTEST_PACKAGE "Enable finding gtest package." OFF)
+    option(ENTT_BUILD_BENCHMARK "Build benchmark." OFF)
+    option(ENTT_BUILD_EXAMPLE "Build examples." OFF)
+    option(ENTT_BUILD_LIB "Build lib tests." OFF)
+    option(ENTT_BUILD_SNAPSHOT "Build snapshot test with Cereal." OFF)
 
-    option(BUILD_BENCHMARK "Build benchmark." OFF)
-    option(BUILD_MOD "Build mod example." OFF)
-
-    # gtest, gtest_main, gmock and gmock_main targets are available from now on
-    set(GOOGLETEST_DEPS_DIR ${entt_SOURCE_DIR}/deps/googletest)
-    configure_file(${entt_SOURCE_DIR}/cmake/in/googletest.in ${GOOGLETEST_DEPS_DIR}/CMakeLists.txt)
-    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY ${GOOGLETEST_DEPS_DIR})
-    execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${GOOGLETEST_DEPS_DIR})
-    set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-    add_subdirectory(${GOOGLETEST_DEPS_DIR}/src ${GOOGLETEST_DEPS_DIR}/build)
+    set(ENTT_ID_TYPE std::uint32_t CACHE STRING "Type of identifiers to use for the tests")
+    set(ENTT_CXX_STD cxx_std_17 CACHE STRING "C++ standard revision to use for the tests")
 
+    include(CTest)
     enable_testing()
     add_subdirectory(test)
 endif()
@@ -89,10 +299,14 @@ endif()
 # Documentation
 #
 
-find_package(Doxygen 1.8)
+option(ENTT_BUILD_DOCS "Enable building with documentation." OFF)
 
-if(DOXYGEN_FOUND)
-    add_subdirectory(docs)
+if(ENTT_BUILD_DOCS)
+    find_package(Doxygen 1.8)
+
+    if(DOXYGEN_FOUND)
+        add_subdirectory(docs)
+    endif()
 endif()
 
 #
@@ -100,11 +314,16 @@ endif()
 #
 
 add_custom_target(
-    entt_aob
+    aob
     SOURCES
-        appveyor.yml
+        .github/workflows/build.yml
+        .github/workflows/coverage.yml
+        .github/workflows/deploy.yml
+        .github/workflows/sanitizer.yml
+        .github/FUNDING.yml
         AUTHORS
+        CONTRIBUTING.md
         LICENSE
         README.md
-        .travis.yml
+        TODO
 )

CONTRIBUTING.md

@@ -0,0 +1,43 @@
+# Contributing
+
+First of all, thank you very much for taking the time to contribute to the
+`EnTT` library.<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 information 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` library 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.

LICENSE

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

TODO

@@ -0,0 +1,27 @@
+* debugging tools (#60): the issue online already contains interesting tips on this, look at it
+* work stealing job system (see #100) + mt scheduler based on const awareness for types
+* add examples (and credits) from @alanjfs :)
+
+EXAMPLES
+* filter on runtime values/variables (not only types)
+* support to polymorphic types (see #859)
+
+WIP:
+* view/group: no storage_traits dependency -> use storage instead of components for the definition
+* resource<T>::operator</<=/>/>=
+* simplify emitter (see uvw), runtime events
+* basic_storage::bind for cross-registry setups
+* uses-allocator construction: any (with allocator support), poly, ...
+* process scheduler: reviews, use free lists internally
+* iterator based try_emplace vs try_insert for perf reasons
+* dedicated entity storage, in-place O(1) release/destroy for non-orphaned entities, out-of-sync model
+* entity-only and exclude-only views
+* custom allocators all over
+* use ENTT_NOEXCEPT_IF as appropriate (ie make compressed_pair conditionally noexcept)
+
+WIP:
+* add user data to type_info
+* write documentation for custom storages and views!!
+* make runtime views use opaque storage and therefore return also elements.
+* entity-aware observer, add observer functions aside observer class
+* deprecate non-owning groups in favor of owning views and view packs, introduce lazy owning views

WORKSPACE

@@ -0,0 +1 @@
+workspace(name = "com_github_skypjack_entt")

appveyor.yml

@@ -1,22 +0,0 @@
-# can use variables like {build} and {branch}
-version: 1.0.{build}
-
-image: Visual Studio 2017
-
-environment:
-  BUILD_DIR: "%APPVEYOR_BUILD_FOLDER%\\build"
-
-platform:
-  - Win32
-
-configuration:
-  - Release
-
-before_build:
-  - cd %BUILD_DIR%
-  - cmake .. -G"Visual Studio 15 2017"
-
-build:
-  parallel: true
-  project: build/entt.sln
-  verbosity: minimal

cmake/in/EnTTConfig.cmake.in

@@ -0,0 +1,5 @@
+@PACKAGE_INIT@
+
+set(EnTT_VERSION "@PROJECT_VERSION@")
+include("${CMAKE_CURRENT_LIST_DIR}/EnTTTargets.cmake")
+check_required_components("@PROJECT_NAME@")

cmake/in/entt.pc.in

@@ -0,0 +1,8 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
+
+Name: EnTT
+Description: Gaming meets modern C++
+Url: https://github.com/skypjack/entt
+Version: @ENTT_VERSION@
+Cflags: -I${includedir}

cmake/in/googletest.in

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

conan/build.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from cpt.packager import ConanMultiPackager
+import os
+
+if __name__ == "__main__":
+    username = os.getenv("GITHUB_ACTOR")
+    tag_version = os.getenv("GITHUB_REF")
+    tag_package = os.getenv("GITHUB_REPOSITORY")
+    login_username = os.getenv("CONAN_LOGIN_USERNAME")
+    package_version = tag_version.replace("refs/tags/v", "")
+    package_name = tag_package.replace("skypjack/", "")
+    reference = "{}/{}".format(package_name, package_version)
+    channel = os.getenv("CONAN_CHANNEL", "stable")
+    upload = os.getenv("CONAN_UPLOAD")
+    stable_branch_pattern = os.getenv("CONAN_STABLE_BRANCH_PATTERN", r"v\d+\.\d+\.\d+.*")
+    test_folder = os.getenv("CPT_TEST_FOLDER", os.path.join("conan", "test_package"))
+    upload_only_when_stable = os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", True)
+    disable_shared = os.getenv("CONAN_DISABLE_SHARED_BUILD", "False")
+
+    builder = ConanMultiPackager(username=username,
+                                 reference=reference,
+                                 channel=channel,
+                                 login_username=login_username,
+                                 upload=upload,
+                                 stable_branch_pattern=stable_branch_pattern,
+                                 upload_only_when_stable=upload_only_when_stable,
+                                 test_folder=test_folder)
+    builder.add()
+
+    filtered_builds = []
+    for settings, options, env_vars, build_requires, reference in builder.items:
+        if disable_shared == "False" or not options["{}:shared".format(package_name)]:
+             filtered_builds.append([settings, options, env_vars, build_requires])
+    builder.builds = filtered_builds
+
+    builder.run()

conan/ci/build.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+
+set -e
+set -x
+
+conan user
+python conan/build.py

conan/ci/install.sh

@@ -0,0 +1,6 @@
+#!/bin/bash
+
+set -e
+set -x
+
+pip install -U conan_package_tools conan

conan/test_package/CMakeLists.txt

@@ -0,0 +1,13 @@
+cmake_minimum_required(VERSION 3.7.2)
+project(test_package)
+
+set(CMAKE_VERBOSE_MAKEFILE TRUE)
+
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+
+include(${CMAKE_BINARY_DIR}/conanbuildinfo.cmake)
+conan_basic_setup()
+
+add_executable(${PROJECT_NAME} test_package.cpp)
+target_link_libraries(${PROJECT_NAME} ${CONAN_LIBS})

conan/test_package/conanfile.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from conans import ConanFile, CMake
+import os
+
+
+class TestPackageConan(ConanFile):
+    settings = "os", "compiler", "build_type", "arch"
+    generators = "cmake"
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def test(self):
+        bin_path = os.path.join("bin", "test_package")
+        self.run(bin_path, run_environment=True)

conan/test_package/test_package.cpp

@@ -0,0 +1,56 @@
+#include <entt/entt.hpp>
+#include <cstdint>
+
+struct position {
+    float x;
+    float y;
+};
+
+struct velocity {
+    float dx;
+    float dy;
+};
+
+void update(entt::registry &registry) {
+    auto view = registry.view<position, velocity>();
+
+    for(auto entity: view) {
+        // gets only the components that are going to be used ...
+
+        auto &vel = view.get<velocity>(entity);
+
+        vel.dx = 0.;
+        vel.dy = 0.;
+
+        // ...
+    }
+}
+
+void update(std::uint64_t dt, entt::registry &registry) {
+    registry.view<position, velocity>().each([dt](auto &pos, auto &vel) {
+        // gets all the components of the view at once ...
+
+        pos.x += vel.dx * dt;
+        pos.y += vel.dy * dt;
+
+        // ...
+    });
+}
+
+int main() {
+    entt::registry registry;
+    std::uint64_t dt = 16;
+
+    for(auto i = 0; i < 10; ++i) {
+        auto entity = registry.create();
+        registry.emplace<position>(entity, i * 1.f, i * 1.f);
+        if(i % 2 == 0) { registry.emplace<velocity>(entity, i * .1f, i * .1f); }
+    }
+
+    update(dt, registry);
+    update(registry);
+
+    // ...
+
+    return EXIT_SUCCESS;
+}

conanfile.py

@@ -0,0 +1,27 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from conans import ConanFile
+
+
+class EnttConan(ConanFile):
+    name = "entt"
+    description = "Gaming meets modern C++ - a fast and reliable entity-component system (ECS) and much more "
+    topics = ("conan," "entt", "gaming", "entity", "ecs")
+    url = "https://github.com/skypjack/entt"
+    homepage = url
+    author = "Michele Caini <michele.caini@gmail.com>"
+    license = "MIT"
+    exports = ["LICENSE"]
+    exports_sources = ["src/*"]
+    no_copy_source = True
+
+    def package(self):
+        self.copy(pattern="LICENSE", dst="licenses")
+        self.copy(pattern="*", dst="include", src="src", keep_path=True)
+
+    def package_info(self):
+        if not self.in_local_cache:
+            self.cpp_info.includedirs = ["src"]
+
+    def package_id(self):
+        self.info.header_only()

deps/.gitignore

@@ -1,2 +0,0 @@
-*
-!.gitignore

docs/CMakeLists.txt

@@ -2,20 +2,36 @@
 # Doxygen configuration (documentation)
 #
 
-set(TARGET_DOCS docs)
-
-set(DOXY_SOURCE_DIRECTORY ${entt_SOURCE_DIR}/src)
+set(DOXY_DEPS_DIRECTORY ${EnTT_SOURCE_DIR}/deps)
+set(DOXY_SOURCE_DIRECTORY ${EnTT_SOURCE_DIR}/src)
 set(DOXY_DOCS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
 set(DOXY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
 configure_file(doxy.in doxy.cfg @ONLY)
 
 add_custom_target(
-    ${TARGET_DOCS}
+    docs ALL
     COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doxy.cfg
-    WORKING_DIRECTORY ${entt_SOURCE_DIR}
+    WORKING_DIRECTORY ${EnTT_SOURCE_DIR}
     VERBATIM
-    SOURCES doxy.in
+    SOURCES
+        dox/extra.dox
+        md/config.md
+        md/container.md
+        md/core.md
+        md/entity.md
+        md/faq.md
+        md/lib.md
+        md/links.md
+        md/locator.md
+        md/meta.md
+        md/poly.md
+        md/process.md
+        md/reference.md
+        md/resource.md
+        md/signal.md
+        md/unreal.md
+        doxy.in
 )
 
 install(

docs/LICENSE

@@ -1,395 +0,0 @@
-Attribution 4.0 International
-
-=======================================================================
-
-Creative Commons Corporation ("Creative Commons") is not a law firm and
-does not provide legal services or legal advice. Distribution of
-Creative Commons public licenses does not create a lawyer-client or
-other relationship. Creative Commons makes its licenses and related
-information available on an "as-is" basis. Creative Commons gives no
-warranties regarding its licenses, any material licensed under their
-terms and conditions, or any related information. Creative Commons
-disclaims all liability for damages resulting from their use to the
-fullest extent possible.
-
-Using Creative Commons Public Licenses
-
-Creative Commons public licenses provide a standard set of terms and
-conditions that creators and other rights holders may use to share
-original works of authorship and other material subject to copyright
-and certain other rights specified in the public license below. The
-following considerations are for informational purposes only, are not
-exhaustive, and do not form part of our licenses.
-
-     Considerations for licensors: Our public licenses are
-     intended for use by those authorized to give the public
-     permission to use material in ways otherwise restricted by
-     copyright and certain other rights. Our licenses are
-     irrevocable. Licensors should read and understand the terms
-     and conditions of the license they choose before applying it.
-     Licensors should also secure all rights necessary before
-     applying our licenses so that the public can reuse the
-     material as expected. Licensors should clearly mark any
-     material not subject to the license. This includes other CC-
-     licensed material, or material used under an exception or
-     limitation to copyright. More considerations for licensors:
-	wiki.creativecommons.org/Considerations_for_licensors
-
-     Considerations for the public: By using one of our public
-     licenses, a licensor grants the public permission to use the
-     licensed material under specified terms and conditions. If
-     the licensor's permission is not necessary for any reason--for
-     example, because of any applicable exception or limitation to
-     copyright--then that use is not regulated by the license. Our
-     licenses grant only permissions under copyright and certain
-     other rights that a licensor has authority to grant. Use of
-     the licensed material may still be restricted for other
-     reasons, including because others have copyright or other
-     rights in the material. A licensor may make special requests,
-     such as asking that all changes be marked or described.
-     Although not required by our licenses, you are encouraged to
-     respect those requests where reasonable. More_considerations
-     for the public: 
-	wiki.creativecommons.org/Considerations_for_licensees
-
-=======================================================================
-
-Creative Commons Attribution 4.0 International Public License
-
-By exercising the Licensed Rights (defined below), You accept and agree
-to be bound by the terms and conditions of this Creative Commons
-Attribution 4.0 International Public License ("Public License"). To the
-extent this Public License may be interpreted as a contract, You are
-granted the Licensed Rights in consideration of Your acceptance of
-these terms and conditions, and the Licensor grants You such rights in
-consideration of benefits the Licensor receives from making the
-Licensed Material available under these terms and conditions.
-
-
-Section 1 -- Definitions.
-
-  a. Adapted Material means material subject to Copyright and Similar
-     Rights that is derived from or based upon the Licensed Material
-     and in which the Licensed Material is translated, altered,
-     arranged, transformed, or otherwise modified in a manner requiring
-     permission under the Copyright and Similar Rights held by the
-     Licensor. For purposes of this Public License, where the Licensed
-     Material is a musical work, performance, or sound recording,
-     Adapted Material is always produced where the Licensed Material is
-     synched in timed relation with a moving image.
-
-  b. Adapter's License means the license You apply to Your Copyright
-     and Similar Rights in Your contributions to Adapted Material in
-     accordance with the terms and conditions of this Public License.
-
-  c. Copyright and Similar Rights means copyright and/or similar rights
-     closely related to copyright including, without limitation,
-     performance, broadcast, sound recording, and Sui Generis Database
-     Rights, without regard to how the rights are labeled or
-     categorized. For purposes of this Public License, the rights
-     specified in Section 2(b)(1)-(2) are not Copyright and Similar
-     Rights.
-
-  d. Effective Technological Measures means those measures that, in the
-     absence of proper authority, may not be circumvented under laws
-     fulfilling obligations under Article 11 of the WIPO Copyright
-     Treaty adopted on December 20, 1996, and/or similar international
-     agreements.
-
-  e. Exceptions and Limitations means fair use, fair dealing, and/or
-     any other exception or limitation to Copyright and Similar Rights
-     that applies to Your use of the Licensed Material.
-
-  f. Licensed Material means the artistic or literary work, database,
-     or other material to which the Licensor applied this Public
-     License.
-
-  g. Licensed Rights means the rights granted to You subject to the
-     terms and conditions of this Public License, which are limited to
-     all Copyright and Similar Rights that apply to Your use of the
-     Licensed Material and that the Licensor has authority to license.
-
-  h. Licensor means the individual(s) or entity(ies) granting rights
-     under this Public License.
-
-  i. Share means to provide material to the public by any means or
-     process that requires permission under the Licensed Rights, such
-     as reproduction, public display, public performance, distribution,
-     dissemination, communication, or importation, and to make material
-     available to the public including in ways that members of the
-     public may access the material from a place and at a time
-     individually chosen by them.
-
-  j. Sui Generis Database Rights means rights other than copyright
-     resulting from Directive 96/9/EC of the European Parliament and of
-     the Council of 11 March 1996 on the legal protection of databases,
-     as amended and/or succeeded, as well as other essentially
-     equivalent rights anywhere in the world.
-
-  k. You means the individual or entity exercising the Licensed Rights
-     under this Public License. Your has a corresponding meaning.
-
-
-Section 2 -- Scope.
-
-  a. License grant.
-
-       1. Subject to the terms and conditions of this Public License,
-          the Licensor hereby grants You a worldwide, royalty-free,
-          non-sublicensable, non-exclusive, irrevocable license to
-          exercise the Licensed Rights in the Licensed Material to:
-
-            a. reproduce and Share the Licensed Material, in whole or
-               in part; and
-
-            b. produce, reproduce, and Share Adapted Material.
-
-       2. Exceptions and Limitations. For the avoidance of doubt, where
-          Exceptions and Limitations apply to Your use, this Public
-          License does not apply, and You do not need to comply with
-          its terms and conditions.
-
-       3. Term. The term of this Public License is specified in Section
-          6(a).
-
-       4. Media and formats; technical modifications allowed. The
-          Licensor authorizes You to exercise the Licensed Rights in
-          all media and formats whether now known or hereafter created,
-          and to make technical modifications necessary to do so. The
-          Licensor waives and/or agrees not to assert any right or
-          authority to forbid You from making technical modifications
-          necessary to exercise the Licensed Rights, including
-          technical modifications necessary to circumvent Effective
-          Technological Measures. For purposes of this Public License,
-          simply making modifications authorized by this Section 2(a)
-          (4) never produces Adapted Material.
-
-       5. Downstream recipients.
-
-            a. Offer from the Licensor -- Licensed Material. Every
-               recipient of the Licensed Material automatically
-               receives an offer from the Licensor to exercise the
-               Licensed Rights under the terms and conditions of this
-               Public License.
-
-            b. No downstream restrictions. You may not offer or impose
-               any additional or different terms or conditions on, or
-               apply any Effective Technological Measures to, the
-               Licensed Material if doing so restricts exercise of the
-               Licensed Rights by any recipient of the Licensed
-               Material.
-
-       6. No endorsement. Nothing in this Public License constitutes or
-          may be construed as permission to assert or imply that You
-          are, or that Your use of the Licensed Material is, connected
-          with, or sponsored, endorsed, or granted official status by,
-          the Licensor or others designated to receive attribution as
-          provided in Section 3(a)(1)(A)(i).
-
-  b. Other rights.
-
-       1. Moral rights, such as the right of integrity, are not
-          licensed under this Public License, nor are publicity,
-          privacy, and/or other similar personality rights; however, to
-          the extent possible, the Licensor waives and/or agrees not to
-          assert any such rights held by the Licensor to the limited
-          extent necessary to allow You to exercise the Licensed
-          Rights, but not otherwise.
-
-       2. Patent and trademark rights are not licensed under this
-          Public License.
-
-       3. To the extent possible, the Licensor waives any right to
-          collect royalties from You for the exercise of the Licensed
-          Rights, whether directly or through a collecting society
-          under any voluntary or waivable statutory or compulsory
-          licensing scheme. In all other cases the Licensor expressly
-          reserves any right to collect such royalties.
-
-
-Section 3 -- License Conditions.
-
-Your exercise of the Licensed Rights is expressly made subject to the
-following conditions.
-
-  a. Attribution.
-
-       1. If You Share the Licensed Material (including in modified
-          form), You must:
-
-            a. retain the following if it is supplied by the Licensor
-               with the Licensed Material:
-
-                 i. identification of the creator(s) of the Licensed
-                    Material and any others designated to receive
-                    attribution, in any reasonable manner requested by
-                    the Licensor (including by pseudonym if
-                    designated);
-
-                ii. a copyright notice;
-
-               iii. a notice that refers to this Public License;
-
-                iv. a notice that refers to the disclaimer of
-                    warranties;
-
-                 v. a URI or hyperlink to the Licensed Material to the
-                    extent reasonably practicable;
-
-            b. indicate if You modified the Licensed Material and
-               retain an indication of any previous modifications; and
-
-            c. indicate the Licensed Material is licensed under this
-               Public License, and include the text of, or the URI or
-               hyperlink to, this Public License.
-
-       2. You may satisfy the conditions in Section 3(a)(1) in any
-          reasonable manner based on the medium, means, and context in
-          which You Share the Licensed Material. For example, it may be
-          reasonable to satisfy the conditions by providing a URI or
-          hyperlink to a resource that includes the required
-          information.
-
-       3. If requested by the Licensor, You must remove any of the
-          information required by Section 3(a)(1)(A) to the extent
-          reasonably practicable.
-
-       4. If You Share Adapted Material You produce, the Adapter's
-          License You apply must not prevent recipients of the Adapted
-          Material from complying with this Public License.
-
-
-Section 4 -- Sui Generis Database Rights.
-
-Where the Licensed Rights include Sui Generis Database Rights that
-apply to Your use of the Licensed Material:
-
-  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
-     to extract, reuse, reproduce, and Share all or a substantial
-     portion of the contents of the database;
-
-  b. if You include all or a substantial portion of the database
-     contents in a database in which You have Sui Generis Database
-     Rights, then the database in which You have Sui Generis Database
-     Rights (but not its individual contents) is Adapted Material; and
-
-  c. You must comply with the conditions in Section 3(a) if You Share
-     all or a substantial portion of the contents of the database.
-
-For the avoidance of doubt, this Section 4 supplements and does not
-replace Your obligations under this Public License where the Licensed
-Rights include other Copyright and Similar Rights.
-
-
-Section 5 -- Disclaimer of Warranties and Limitation of Liability.
-
-  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
-     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
-     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
-     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
-     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
-     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
-     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
-     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
-     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
-     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
-
-  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
-     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
-     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
-     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
-     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
-     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
-     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
-     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
-     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
-
-  c. The disclaimer of warranties and limitation of liability provided
-     above shall be interpreted in a manner that, to the extent
-     possible, most closely approximates an absolute disclaimer and
-     waiver of all liability.
-
-
-Section 6 -- Term and Termination.
-
-  a. This Public License applies for the term of the Copyright and
-     Similar Rights licensed here. However, if You fail to comply with
-     this Public License, then Your rights under this Public License
-     terminate automatically.
-
-  b. Where Your right to use the Licensed Material has terminated under
-     Section 6(a), it reinstates:
-
-       1. automatically as of the date the violation is cured, provided
-          it is cured within 30 days of Your discovery of the
-          violation; or
-
-       2. upon express reinstatement by the Licensor.
-
-     For the avoidance of doubt, this Section 6(b) does not affect any
-     right the Licensor may have to seek remedies for Your violations
-     of this Public License.
-
-  c. For the avoidance of doubt, the Licensor may also offer the
-     Licensed Material under separate terms or conditions or stop
-     distributing the Licensed Material at any time; however, doing so
-     will not terminate this Public License.
-
-  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
-     License.
-
-
-Section 7 -- Other Terms and Conditions.
-
-  a. The Licensor shall not be bound by any additional or different
-     terms or conditions communicated by You unless expressly agreed.
-
-  b. Any arrangements, understandings, or agreements regarding the
-     Licensed Material not stated herein are separate from and
-     independent of the terms and conditions of this Public License.
-
-
-Section 8 -- Interpretation.
-
-  a. For the avoidance of doubt, this Public License does not, and
-     shall not be interpreted to, reduce, limit, restrict, or impose
-     conditions on any use of the Licensed Material that could lawfully
-     be made without permission under this Public License.
-
-  b. To the extent possible, if any provision of this Public License is
-     deemed unenforceable, it shall be automatically reformed to the
-     minimum extent necessary to make it enforceable. If the provision
-     cannot be reformed, it shall be severed from this Public License
-     without affecting the enforceability of the remaining terms and
-     conditions.
-
-  c. No term or condition of this Public License will be waived and no
-     failure to comply consented to unless expressly agreed to by the
-     Licensor.
-
-  d. Nothing in this Public License constitutes or may be interpreted
-     as a limitation upon, or waiver of, any privileges and immunities
-     that apply to the Licensor or You, including from the legal
-     processes of any jurisdiction or authority.
-
-
-=======================================================================
-
-Creative Commons is not a party to its public
-licenses. Notwithstanding, Creative Commons may elect to apply one of
-its public licenses to material it publishes and in those instances
-will be considered the “Licensor.” The text of the Creative Commons
-public licenses is dedicated to the public domain under the CC0 Public
-Domain Dedication. Except for the limited purpose of indicating that
-material is shared under a Creative Commons public license or as
-otherwise permitted by the Creative Commons policies published at
-creativecommons.org/policies, Creative Commons does not authorize the
-use of the trademark "Creative Commons" or any other trademark or logo
-of Creative Commons without its prior written consent including,
-without limitation, in connection with any unauthorized modifications
-to any of its public licenses or any other arrangements,
-understandings, or agreements concerning use of licensed material. For
-the avoidance of doubt, this paragraph does not form part of the
-public licenses.
-
-Creative Commons may be contacted at creativecommons.org.

docs/doxy.in

@@ -1,4 +1,4 @@
-# Doxyfile 1.8.13
+# Doxyfile 1.9.1
 
 # This file describes the settings to be used by the documentation system
 # doxygen (www.doxygen.org) for a project.
@@ -17,11 +17,11 @@
 # Project related configuration options
 #---------------------------------------------------------------------------
 
-# This tag specifies the encoding used for all characters in the config file
-# that follow. The default is UTF-8 which is also the encoding used for all text
-# before the first occurrence of this tag. Doxygen uses libiconv (or the iconv
-# built into libc) for the transcoding. See http://www.gnu.org/software/libiconv
-# for the list of possible encodings.
+# This tag specifies the encoding used for all characters in the configuration
+# file that follow. The default is UTF-8 which is also the encoding used for all
+# text before the first occurrence of this tag. Doxygen uses libiconv (or the
+# iconv built into libc) for the transcoding. See
+# https://www.gnu.org/software/libiconv/ for the list of possible encodings.
 # The default value is: UTF-8.
 
 DOXYFILE_ENCODING      = UTF-8
@@ -93,6 +93,14 @@ ALLOW_UNICODE_NAMES    = NO
 
 OUTPUT_LANGUAGE        = English
 
+# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all
+# documentation generated by doxygen is written. Doxygen will use this
+# information to generate all generated output in the proper direction.
+# Possible values are: None, LTR, RTL and Context.
+# The default value is: None.
+
+OUTPUT_TEXT_DIRECTION  = None
+
 # If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member
 # descriptions after the members that are listed in the file and class
 # documentation (similar to Javadoc). Set to NO to disable this.
@@ -179,6 +187,16 @@ SHORT_NAMES            = NO
 
 JAVADOC_AUTOBRIEF      = NO
 
+# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line
+# such as
+# /***************
+# as being the beginning of a Javadoc-style comment "banner". If set to NO, the
+# Javadoc-style will behave just like regular comments and it will not be
+# interpreted by doxygen.
+# The default value is: NO.
+
+JAVADOC_BANNER         = NO
+
 # If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first
 # line (until the first dot) of a Qt-style comment as the brief description. If
 # set to NO, the Qt-style will behave just like regular Qt-style comments (thus
@@ -199,6 +217,14 @@ QT_AUTOBRIEF           = NO
 
 MULTILINE_CPP_IS_BRIEF = NO
 
+# By default Python docstrings are displayed as preformatted text and doxygen's
+# special commands cannot be used. By setting PYTHON_DOCSTRING to NO the
+# doxygen's special commands can be used and the contents of the docstring
+# documentation blocks is shown as doxygen documentation.
+# The default value is: YES.
+
+PYTHON_DOCSTRING       = YES
+
 # If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the
 # documentation from any documented member that it re-implements.
 # The default value is: YES.
@@ -226,16 +252,15 @@ TAB_SIZE               = 4
 # will allow you to put the command \sideeffect (or @sideeffect) in the
 # documentation, which will result in a user-defined paragraph with heading
 # "Side Effects:". You can put \n's in the value part of an alias to insert
-# newlines.
+# newlines (in the resulting output). You can put ^^ in the value part of an
+# alias to insert a newline as if a physical newline was in the original file.
+# When you need a literal { or } or , in the value part of an alias you have to
+# escape them by means of a backslash (\), this can lead to conflicts with the
+# commands \{ and \} for these it is advised to use the version @{ and @} or use
+# a double escape (\\{ and \\})
 
 ALIASES                =
 
-# This tag can be used to specify a number of word-keyword mappings (TCL only).
-# A mapping has the form "name=value". For example adding "class=itcl::class"
-# will allow you to use the command class in the itcl::class meaning.
-
-TCL_SUBST              =
-
 # Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources
 # only. Doxygen will then generate output that is more tailored for C. For
 # instance, some of the names that are used will be different. The list of all
@@ -264,28 +289,40 @@ OPTIMIZE_FOR_FORTRAN   = NO
 
 OPTIMIZE_OUTPUT_VHDL   = NO
 
+# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice
+# sources only. Doxygen will then generate output that is more tailored for that
+# language. For instance, namespaces will be presented as modules, types will be
+# separated into more groups, etc.
+# The default value is: NO.
+
+OPTIMIZE_OUTPUT_SLICE  = NO
+
 # Doxygen selects the parser to use depending on the extension of the files it
 # parses. With this tag you can assign which parser to use for a given
 # extension. Doxygen has a built-in mapping, but you can override or extend it
 # using this tag. The format is ext=language, where ext is a file extension, and
-# language is one of the parsers supported by doxygen: IDL, Java, Javascript,
-# C#, C, C++, D, PHP, Objective-C, Python, Fortran (fixed format Fortran:
-# FortranFixed, free formatted Fortran: FortranFree, unknown formatted Fortran:
-# Fortran. In the later case the parser tries to guess whether the code is fixed
-# or free formatted code, this is the default for Fortran type files), VHDL. For
-# instance to make doxygen treat .inc files as Fortran files (default is PHP),
-# and .f files as C (default is Fortran), use: inc=Fortran f=C.
+# language is one of the parsers supported by doxygen: IDL, Java, JavaScript,
+# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL,
+# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran:
+# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser
+# tries to guess whether the code is fixed or free formatted code, this is the
+# default for Fortran type files). For instance to make doxygen treat .inc files
+# as Fortran files (default is PHP), and .f files as C (default is Fortran),
+# use: inc=Fortran f=C.
 #
 # Note: For files without extension you can use no_extension as a placeholder.
 #
 # Note that for custom extensions you also need to set FILE_PATTERNS otherwise
-# the files are not read by doxygen.
+# the files are not read by doxygen. When specifying no_extension you should add
+# * to the FILE_PATTERNS.
+#
+# Note see also the list of default file extension mappings.
 
 EXTENSION_MAPPING      =
 
 # If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments
 # according to the Markdown format, which allows for more readable
-# documentation. See http://daringfireball.net/projects/markdown/ for details.
+# documentation. See https://daringfireball.net/projects/markdown/ for details.
 # The output of markdown processing is further processed by doxygen, so you can
 # mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in
 # case of backward compatibilities issues.
@@ -297,10 +334,10 @@ MARKDOWN_SUPPORT       = YES
 # to that level are automatically included in the table of contents, even if
 # they do not have an id attribute.
 # Note: This feature currently applies only to Markdown headings.
-# Minimum value: 0, maximum value: 99, default value: 0.
+# Minimum value: 0, maximum value: 99, default value: 5.
 # This tag requires that the tag MARKDOWN_SUPPORT is set to YES.
 
-TOC_INCLUDE_HEADINGS   = 4
+TOC_INCLUDE_HEADINGS   = 5
 
 # When enabled doxygen tries to link words that correspond to documented
 # classes, or namespaces to their corresponding documentation. Such a link can
@@ -327,7 +364,7 @@ BUILTIN_STL_SUPPORT    = NO
 CPP_CLI_SUPPORT        = NO
 
 # Set the SIP_SUPPORT tag to YES if your project consists of sip (see:
-# http://www.riverbankcomputing.co.uk/software/sip/intro) sources only. Doxygen
+# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen
 # will parse them like normal C++ but will assume all classes use public instead
 # of private inheritance when no explicit protection keyword is present.
 # The default value is: NO.
@@ -413,6 +450,19 @@ TYPEDEF_HIDES_STRUCT   = NO
 
 LOOKUP_CACHE_SIZE      = 0
 
+# The NUM_PROC_THREADS specifies the number threads doxygen is allowed to use
+# during processing. When set to 0 doxygen will based this on the number of
+# cores available in the system. You can set it explicitly to a value larger
+# than 0 to get more control over the balance between CPU load and processing
+# speed. At this moment only the input processing can be done using multiple
+# threads. Since this is still an experimental feature the default is set to 1,
+# which efficively disables parallel processing. Please report any issues you
+# encounter. Generating dot graphs in parallel is controlled by the
+# DOT_NUM_THREADS setting.
+# Minimum value: 0, maximum value: 32, default value: 1.
+
+NUM_PROC_THREADS       = 1
+
 #---------------------------------------------------------------------------
 # Build related configuration options
 #---------------------------------------------------------------------------
@@ -433,6 +483,12 @@ EXTRACT_ALL            = NO
 
 EXTRACT_PRIVATE        = NO
 
+# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual
+# methods of a class will be included in the documentation.
+# The default value is: NO.
+
+EXTRACT_PRIV_VIRTUAL   = NO
+
 # If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal
 # scope will be included in the documentation.
 # The default value is: NO.
@@ -470,6 +526,13 @@ EXTRACT_LOCAL_METHODS  = NO
 
 EXTRACT_ANON_NSPACES   = NO
 
+# If this flag is set to YES, the name of an unnamed parameter in a declaration
+# will be determined by the corresponding definition. By default unnamed
+# parameters remain unnamed in the output.
+# The default value is: YES.
+
+RESOLVE_UNNAMED_PARAMS = YES
+
 # If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all
 # undocumented members inside documented classes or files. If set to NO these
 # members will be included in the various overviews, but no documentation
@@ -487,8 +550,8 @@ HIDE_UNDOC_MEMBERS     = NO
 HIDE_UNDOC_CLASSES     = NO
 
 # If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend
-# (class|struct|union) declarations. If set to NO, these declarations will be
-# included in the documentation.
+# declarations. If set to NO, these declarations will be included in the
+# documentation.
 # The default value is: NO.
 
 HIDE_FRIEND_COMPOUNDS  = NO
@@ -507,11 +570,18 @@ HIDE_IN_BODY_DOCS      = NO
 
 INTERNAL_DOCS          = NO
 
-# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file
-# names in lower-case letters. If set to YES, upper-case letters are also
-# allowed. This is useful if you have classes or files whose names only differ
-# in case and if your file system supports case sensitive file names. Windows
-# and Mac users are advised to set this option to NO.
+# With the correct setting of option CASE_SENSE_NAMES doxygen will better be
+# able to match the capabilities of the underlying filesystem. In case the
+# filesystem is case sensitive (i.e. it supports files in the same directory
+# whose names only differ in casing), the option must be set to YES to properly
+# deal with such files in case they appear in the input. For filesystems that
+# are not case sensitive the option should be be set to NO to properly deal with
+# output files written for symbols that only differ in casing, such as for two
+# classes, one named CLASS and the other named Class, and to also support
+# references to files without having to specify the exact matching casing. On
+# Windows (including Cygwin) and MacOS, users should typically set this option
+# to NO, whereas on Linux or other Unix flavors it should typically be set to
+# YES.
 # The default value is: system dependent.
 
 CASE_SENSE_NAMES       = YES
@@ -698,7 +768,7 @@ LAYOUT_FILE            =
 # The CITE_BIB_FILES tag can be used to specify one or more bib files containing
 # the reference definitions. This must be a list of .bib files. The .bib
 # extension is automatically appended if omitted. This requires the bibtex tool
-# to be installed. See also http://en.wikipedia.org/wiki/BibTeX for more info.
+# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info.
 # For LaTeX the style of the bibliography can be controlled using
 # LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the
 # search path. See also \cite for info how to create references.
@@ -743,13 +813,17 @@ WARN_IF_DOC_ERROR      = YES
 # This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that
 # are documented, but have no documentation for their parameters or return
 # value. If set to NO, doxygen will only warn about wrong or incomplete
-# parameter documentation, but not about the absence of documentation.
+# parameter documentation, but not about the absence of documentation. If
+# EXTRACT_ALL is set to YES then this flag will automatically be disabled.
 # The default value is: NO.
 
 WARN_NO_PARAMDOC       = YES
 
 # If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when
-# a warning is encountered.
+# a warning is encountered. If the WARN_AS_ERROR tag is set to FAIL_ON_WARNINGS
+# then doxygen will continue running as if WARN_AS_ERROR tag is set to NO, but
+# at the end of the doxygen process doxygen will return with a non-zero status.
+# Possible values are: NO, YES and FAIL_ON_WARNINGS.
 # The default value is: NO.
 
 WARN_AS_ERROR          = NO
@@ -780,13 +854,15 @@ WARN_LOGFILE           =
 # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING
 # Note: If this tag is empty the current directory is searched.
 
-INPUT                  = @DOXY_SOURCE_DIRECTORY@ @DOXY_DOCS_DIRECTORY@ @PROJECT_SOURCE_DIR@/README.md
+INPUT                  = @DOXY_SOURCE_DIRECTORY@ \
+                         @DOXY_DOCS_DIRECTORY@ \
+                         @PROJECT_SOURCE_DIR@/README.md
 
 # This tag can be used to specify the character encoding of the source files
 # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses
 # libiconv (or the iconv built into libc) for the transcoding. See the libiconv
-# documentation (see: http://www.gnu.org/software/libiconv) for the list of
-# possible encodings.
+# documentation (see:
+# https://www.gnu.org/software/libiconv/) for the list of possible encodings.
 # The default value is: UTF-8.
 
 INPUT_ENCODING         = UTF-8
@@ -799,15 +875,17 @@ INPUT_ENCODING         = UTF-8
 # need to set EXTENSION_MAPPING for the extension otherwise the files are not
 # read by doxygen.
 #
+# Note the list of default checked file patterns might differ from the list of
+# default file extension mappings.
+#
 # If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp,
 # *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h,
 # *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc,
-# *.m, *.markdown, *.md, *.mm, *.dox, *.py, *.pyw, *.f90, *.f95, *.f03, *.f08,
-# *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf and *.qsf.
+# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment),
+# *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, *.vhdl,
+# *.ucf, *.qsf and *.ice.
 
-FILE_PATTERNS          = *.cpp \
-                         *.c++ \
-                         *.h \
+FILE_PATTERNS          = *.h \
                          *.hpp \
                          *.md \
                          *.dox
@@ -825,7 +903,7 @@ RECURSIVE              = YES
 # Note that relative paths are relative to the directory from which doxygen is
 # run.
 
-EXCLUDE                =
+EXCLUDE                = @DOXY_DEPS_DIRECTORY@
 
 # The EXCLUDE_SYMLINKS tag can be used to select whether or not files or
 # directories that are symbolic links (a Unix file system feature) are excluded
@@ -963,7 +1041,7 @@ INLINE_SOURCES         = NO
 STRIP_CODE_COMMENTS    = YES
 
 # If the REFERENCED_BY_RELATION tag is set to YES then for each documented
-# function all documented functions referencing it will be listed.
+# entity all documented functions referencing it will be listed.
 # The default value is: NO.
 
 REFERENCED_BY_RELATION = NO
@@ -995,12 +1073,12 @@ SOURCE_TOOLTIPS        = YES
 # If the USE_HTAGS tag is set to YES then the references to source code will
 # point to the HTML generated by the htags(1) tool instead of doxygen built-in
 # source browser. The htags tool is part of GNU's global source tagging system
-# (see http://www.gnu.org/software/global/global.html). You will need version
+# (see https://www.gnu.org/software/global/global.html). You will need version
 # 4.8.6 or higher.
 #
 # To use it do the following:
 # - Install the latest version of global
-# - Enable SOURCE_BROWSER and USE_HTAGS in the config file
+# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file
 # - Make sure the INPUT points to the root of the source tree
 # - Run doxygen as normal
 #
@@ -1023,16 +1101,22 @@ USE_HTAGS              = NO
 VERBATIM_HEADERS       = YES
 
 # If the CLANG_ASSISTED_PARSING tag is set to YES then doxygen will use the
-# clang parser (see: http://clang.llvm.org/) for more accurate parsing at the
-# cost of reduced performance. This can be particularly helpful with template
-# rich C++ code for which doxygen's built-in parser lacks the necessary type
-# information.
+# clang parser (see:
+# http://clang.llvm.org/) for more accurate parsing at the cost of reduced
+# performance. This can be particularly helpful with template rich C++ code for
+# which doxygen's built-in parser lacks the necessary type information.
 # Note: The availability of this option depends on whether or not doxygen was
-# generated with the -Duse-libclang=ON option for CMake.
+# generated with the -Duse_libclang=ON option for CMake.
 # The default value is: NO.
 
 CLANG_ASSISTED_PARSING = NO
 
+# If clang assisted parsing is enabled and the CLANG_ADD_INC_PATHS tag is set to
+# YES then doxygen will add the directory of each input to the include path.
+# The default value is: YES.
+
+CLANG_ADD_INC_PATHS    = YES
+
 # If clang assisted parsing is enabled you can provide the compiler with command
 # line options that you would normally use when invoking the compiler. Note that
 # the include paths will already be set by doxygen for the files and directories
@@ -1041,6 +1125,19 @@ CLANG_ASSISTED_PARSING = NO
 
 CLANG_OPTIONS          =
 
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the directory containing a file called compile_commands.json. This
+# file is the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) containing the
+# options used when the source files were built. This is equivalent to
+# specifying the -p option to a clang tool, such as clang-check. These options
+# will then be passed to the parser. Any options specified with CLANG_OPTIONS
+# will be added as well.
+# Note: The availability of this option depends on whether or not doxygen was
+# generated with the -Duse_libclang=ON option for CMake.
+
+CLANG_DATABASE_PATH    =
+
 #---------------------------------------------------------------------------
 # Configuration options related to the alphabetical class index
 #---------------------------------------------------------------------------
@@ -1052,13 +1149,6 @@ CLANG_OPTIONS          =
 
 ALPHABETICAL_INDEX     = YES
 
-# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in
-# which the alphabetical index list will be split.
-# Minimum value: 1, maximum value: 20, default value: 5.
-# This tag requires that the tag ALPHABETICAL_INDEX is set to YES.
-
-COLS_IN_ALPHA_INDEX    = 5
-
 # In case all classes in a project start with a common prefix, all classes will
 # be put under the same header in the alphabetical index. The IGNORE_PREFIX tag
 # can be used to specify a prefix (or a list of prefixes) that should be ignored
@@ -1159,7 +1249,7 @@ HTML_EXTRA_FILES       =
 # The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen
 # will adjust the colors in the style sheet and background images according to
 # this color. Hue is specified as an angle on a colorwheel, see
-# http://en.wikipedia.org/wiki/Hue for more information. For instance the value
+# https://en.wikipedia.org/wiki/Hue for more information. For instance the value
 # 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300
 # purple, and 360 is red again.
 # Minimum value: 0, maximum value: 359, default value: 220.
@@ -1195,6 +1285,17 @@ HTML_COLORSTYLE_GAMMA  = 80
 
 HTML_TIMESTAMP         = NO
 
+# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML
+# documentation will contain a main index with vertical navigation menus that
+# are dynamically created via JavaScript. If disabled, the navigation index will
+# consists of multiple levels of tabs that are statically embedded in every HTML
+# page. Disable this option to support browsers that do not have JavaScript,
+# like the Qt help browser.
+# The default value is: YES.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_DYNAMIC_MENUS     = YES
+
 # If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML
 # documentation will contain sections that can be hidden and shown after the
 # page has loaded.
@@ -1218,13 +1319,14 @@ HTML_INDEX_NUM_ENTRIES = 100
 
 # If the GENERATE_DOCSET tag is set to YES, additional index files will be
 # generated that can be used as input for Apple's Xcode 3 integrated development
-# environment (see: http://developer.apple.com/tools/xcode/), introduced with
-# OSX 10.5 (Leopard). To create a documentation set, doxygen will generate a
-# Makefile in the HTML output directory. Running make will produce the docset in
-# that directory and running make install will install the docset in
+# environment (see:
+# https://developer.apple.com/xcode/), introduced with OSX 10.5 (Leopard). To
+# create a documentation set, doxygen will generate a Makefile in the HTML
+# output directory. Running make will produce the docset in that directory and
+# running make install will install the docset in
 # ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at
-# startup. See http://developer.apple.com/tools/creatingdocsetswithdoxygen.html
-# for more information.
+# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy
+# genXcode/_index.html for more information.
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTML is set to YES.
 
@@ -1263,8 +1365,8 @@ DOCSET_PUBLISHER_NAME  = Publisher
 # If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three
 # additional HTML index files: index.hhp, index.hhc, and index.hhk. The
 # index.hhp is a project file that can be read by Microsoft's HTML Help Workshop
-# (see: http://www.microsoft.com/en-us/download/details.aspx?id=21138) on
-# Windows.
+# (see:
+# https://www.microsoft.com/en-us/download/details.aspx?id=21138) on Windows.
 #
 # The HTML Help Workshop contains a compiler that can convert all HTML output
 # generated by doxygen into a single compiled HTML file (.chm). Compiled HTML
@@ -1294,7 +1396,7 @@ CHM_FILE               =
 HHC_LOCATION           =
 
 # The GENERATE_CHI flag controls if a separate .chi index file is generated
-# (YES) or that it should be included in the master .chm file (NO).
+# (YES) or that it should be included in the main .chm file (NO).
 # The default value is: NO.
 # This tag requires that the tag GENERATE_HTMLHELP is set to YES.
 
@@ -1339,7 +1441,8 @@ QCH_FILE               =
 
 # The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help
 # Project output. For more information please see Qt Help Project / Namespace
-# (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#namespace).
+# (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace).
 # The default value is: org.doxygen.Project.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1347,8 +1450,8 @@ QHP_NAMESPACE          = org.doxygen.Project
 
 # The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt
 # Help Project output. For more information please see Qt Help Project / Virtual
-# Folders (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#virtual-
-# folders).
+# Folders (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual-folders).
 # The default value is: doc.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
@@ -1356,30 +1459,30 @@ QHP_VIRTUAL_FOLDER     = doc
 
 # If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom
 # filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_NAME   =
 
 # The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the
 # custom filter to add. For more information please see Qt Help Project / Custom
-# Filters (see: http://qt-project.org/doc/qt-4.8/qthelpproject.html#custom-
-# filters).
+# Filters (see:
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom-filters).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_CUST_FILTER_ATTRS  =
 
 # The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this
 # project's filter section matches. Qt Help Project / Filter Attributes (see:
-# http://qt-project.org/doc/qt-4.8/qthelpproject.html#filter-attributes).
+# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes).
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHP_SECT_FILTER_ATTRS  =
 
-# The QHG_LOCATION tag can be used to specify the location of Qt's
-# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the
-# generated .qhp file.
+# The QHG_LOCATION tag can be used to specify the location (absolute path
+# including file name) of Qt's qhelpgenerator. If non-empty doxygen will try to
+# run qhelpgenerator on the generated .qhp file.
 # This tag requires that the tag GENERATE_QHP is set to YES.
 
 QHG_LOCATION           =
@@ -1456,6 +1559,17 @@ TREEVIEW_WIDTH         = 250
 
 EXT_LINKS_IN_WINDOW    = NO
 
+# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg
+# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see
+# https://inkscape.org) to generate formulas as SVG images instead of PNGs for
+# the HTML output. These images will generally look nicer at scaled resolutions.
+# Possible values are: png (the default) and svg (looks nicer but requires the
+# pdf2svg or inkscape tool).
+# The default value is: png.
+# This tag requires that the tag GENERATE_HTML is set to YES.
+
+HTML_FORMULA_FORMAT    = png
+
 # Use this tag to change the font size of LaTeX formulas included as images in
 # the HTML documentation. When you change the font size after a successful
 # doxygen run you need to manually remove any form_*.png images from the HTML
@@ -1465,7 +1579,7 @@ EXT_LINKS_IN_WINDOW    = NO
 
 FORMULA_FONTSIZE       = 10
 
-# Use the FORMULA_TRANPARENT tag to determine whether or not the images
+# Use the FORMULA_TRANSPARENT tag to determine whether or not the images
 # generated for formulas are transparent PNGs. Transparent PNGs are not
 # supported properly for IE 6.0, but are supported on all modern browsers.
 #
@@ -1476,8 +1590,14 @@ FORMULA_FONTSIZE       = 10
 
 FORMULA_TRANSPARENT    = YES
 
+# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands
+# to create new LaTeX commands to be used in formulas as building blocks. See
+# the section "Including formulas" for details.
+
+FORMULA_MACROFILE      =
+
 # Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see
-# http://www.mathjax.org) which uses client side Javascript for the rendering
+# https://www.mathjax.org) which uses client side JavaScript for the rendering
 # instead of using pre-rendered bitmaps. Use this if you do not have LaTeX
 # installed or if you want to formulas look prettier in the HTML output. When
 # enabled you may also need to install MathJax separately and configure the path
@@ -1489,7 +1609,7 @@ USE_MATHJAX            = NO
 
 # When MathJax is enabled you can set the default output format to be used for
 # the MathJax output. See the MathJax site (see:
-# http://docs.mathjax.org/en/latest/output.html) for more details.
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details.
 # Possible values are: HTML-CSS (which is slower, but has the best
 # compatibility), NativeMML (i.e. MathML) and SVG.
 # The default value is: HTML-CSS.
@@ -1504,11 +1624,11 @@ MATHJAX_FORMAT         = HTML-CSS
 # MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax
 # Content Delivery Network so you can quickly see the result without installing
 # MathJax. However, it is strongly recommended to install a local copy of
-# MathJax from http://www.mathjax.org before deployment.
-# The default value is: http://cdn.mathjax.org/mathjax/latest.
+# MathJax from https://www.mathjax.org before deployment.
+# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
-MATHJAX_RELPATH        = http://cdn.mathjax.org/mathjax/latest
+MATHJAX_RELPATH        = https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/
 
 # The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax
 # extension names that should be enabled during MathJax rendering. For example
@@ -1519,7 +1639,8 @@ MATHJAX_EXTENSIONS     =
 
 # The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces
 # of code that will be used on startup of the MathJax code. See the MathJax site
-# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an
+# (see:
+# http://docs.mathjax.org/en/v2.7-latest/output.html) for more details. For an
 # example see the documentation.
 # This tag requires that the tag USE_MATHJAX is set to YES.
 
@@ -1547,7 +1668,7 @@ MATHJAX_CODEFILE       =
 SEARCHENGINE           = YES
 
 # When the SERVER_BASED_SEARCH tag is enabled the search engine will be
-# implemented using a web server instead of a web client using Javascript. There
+# implemented using a web server instead of a web client using JavaScript. There
 # are two flavors of web server based searching depending on the EXTERNAL_SEARCH
 # setting. When disabled, doxygen will generate a PHP script for searching and
 # an index file used by the script. When EXTERNAL_SEARCH is enabled the indexing
@@ -1566,7 +1687,8 @@ SERVER_BASED_SEARCH    = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/).
+# Xapian (see:
+# https://xapian.org/).
 #
 # See the section "External Indexing and Searching" for details.
 # The default value is: NO.
@@ -1579,8 +1701,9 @@ EXTERNAL_SEARCH        = NO
 #
 # Doxygen ships with an example indexer (doxyindexer) and search engine
 # (doxysearch.cgi) which are based on the open source search engine library
-# Xapian (see: http://xapian.org/). See the section "External Indexing and
-# Searching" for details.
+# Xapian (see:
+# https://xapian.org/). See the section "External Indexing and Searching" for
+# details.
 # This tag requires that the tag SEARCHENGINE is set to YES.
 
 SEARCHENGINE_URL       =
@@ -1631,21 +1754,35 @@ LATEX_OUTPUT           = latex
 # The LATEX_CMD_NAME tag can be used to specify the LaTeX command name to be
 # invoked.
 #
-# Note that when enabling USE_PDFLATEX this option is only used for generating
-# bitmaps for formulas in the HTML output, but not in the Makefile that is
-# written to the output directory.
-# The default file is: latex.
+# Note that when not enabling USE_PDFLATEX the default is latex when enabling
+# USE_PDFLATEX the default is pdflatex and when in the later case latex is
+# chosen this is overwritten by pdflatex. For specific output languages the
+# default can have been set differently, this depends on the implementation of
+# the output language.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
-LATEX_CMD_NAME         = latex
+LATEX_CMD_NAME         =
 
 # The MAKEINDEX_CMD_NAME tag can be used to specify the command name to generate
 # index for LaTeX.
+# Note: This tag is used in the Makefile / make.bat.
+# See also: LATEX_MAKEINDEX_CMD for the part in the generated output file
+# (.tex).
 # The default file is: makeindex.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
 MAKEINDEX_CMD_NAME     = makeindex
 
+# The LATEX_MAKEINDEX_CMD tag can be used to specify the command name to
+# generate index for LaTeX. In case there is no backslash (\) as first character
+# it will be automatically added in the LaTeX code.
+# Note: This tag is used in the generated output file (.tex).
+# See also: MAKEINDEX_CMD_NAME for the part in the Makefile / make.bat.
+# The default value is: makeindex.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_MAKEINDEX_CMD    = makeindex
+
 # If the COMPACT_LATEX tag is set to YES, doxygen generates more compact LaTeX
 # documents. This may be useful for small projects and may help to save some
 # trees in general.
@@ -1730,9 +1867,11 @@ LATEX_EXTRA_FILES      =
 
 PDF_HYPERLINKS         = YES
 
-# If the USE_PDFLATEX tag is set to YES, doxygen will use pdflatex to generate
-# the PDF file directly from the LaTeX files. Set this option to YES, to get a
-# higher quality PDF documentation.
+# If the USE_PDFLATEX tag is set to YES, doxygen will use the engine as
+# specified with LATEX_CMD_NAME to generate the PDF file directly from the LaTeX
+# files. Set this option to YES, to get a higher quality PDF documentation.
+#
+# See also section LATEX_CMD_NAME for selecting the engine.
 # The default value is: YES.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1766,7 +1905,7 @@ LATEX_SOURCE_CODE      = NO
 
 # The LATEX_BIB_STYLE tag can be used to specify the style to use for the
 # bibliography, e.g. plainnat, or ieeetr. See
-# http://en.wikipedia.org/wiki/BibTeX and \cite for more info.
+# https://en.wikipedia.org/wiki/BibTeX and \cite for more info.
 # The default value is: plain.
 # This tag requires that the tag GENERATE_LATEX is set to YES.
 
@@ -1780,6 +1919,14 @@ LATEX_BIB_STYLE        = plain
 
 LATEX_TIMESTAMP        = NO
 
+# The LATEX_EMOJI_DIRECTORY tag is used to specify the (relative or absolute)
+# path from which the emoji images will be read. If a relative path is entered,
+# it will be relative to the LATEX_OUTPUT directory. If left blank the
+# LATEX_OUTPUT directory will be used.
+# This tag requires that the tag GENERATE_LATEX is set to YES.
+
+LATEX_EMOJI_DIRECTORY  =
+
 #---------------------------------------------------------------------------
 # Configuration options related to the RTF output
 #---------------------------------------------------------------------------
@@ -1819,9 +1966,9 @@ COMPACT_RTF            = NO
 
 RTF_HYPERLINKS         = NO
 
-# Load stylesheet definitions from file. Syntax is similar to doxygen's config
-# file, i.e. a series of assignments. You only have to provide replacements,
-# missing definitions are set to their default value.
+# Load stylesheet definitions from file. Syntax is similar to doxygen's
+# configuration file, i.e. a series of assignments. You only have to provide
+# replacements, missing definitions are set to their default value.
 #
 # See also section "Doxygen usage" for information on how to generate the
 # default style sheet that doxygen normally uses.
@@ -1830,8 +1977,8 @@ RTF_HYPERLINKS         = NO
 RTF_STYLESHEET_FILE    =
 
 # Set optional variables used in the generation of an RTF document. Syntax is
-# similar to doxygen's config file. A template extensions file can be generated
-# using doxygen -e rtf extensionFile.
+# similar to doxygen's configuration file. A template extensions file can be
+# generated using doxygen -e rtf extensionFile.
 # This tag requires that the tag GENERATE_RTF is set to YES.
 
 RTF_EXTENSIONS_FILE    =
@@ -1917,6 +2064,13 @@ XML_OUTPUT             = xml
 
 XML_PROGRAMLISTING     = YES
 
+# If the XML_NS_MEMB_FILE_SCOPE tag is set to YES, doxygen will include
+# namespace members in file scope as well, matching the HTML output.
+# The default value is: NO.
+# This tag requires that the tag GENERATE_XML is set to YES.
+
+XML_NS_MEMB_FILE_SCOPE = NO
+
 #---------------------------------------------------------------------------
 # Configuration options related to the DOCBOOK output
 #---------------------------------------------------------------------------
@@ -1949,9 +2103,9 @@ DOCBOOK_PROGRAMLISTING = NO
 #---------------------------------------------------------------------------
 
 # If the GENERATE_AUTOGEN_DEF tag is set to YES, doxygen will generate an
-# AutoGen Definitions (see http://autogen.sf.net) file that captures the
-# structure of the code including all documentation. Note that this feature is
-# still experimental and incomplete at the moment.
+# AutoGen Definitions (see http://autogen.sourceforge.net/) file that captures
+# the structure of the code including all documentation. Note that this feature
+# is still experimental and incomplete at the moment.
 # The default value is: NO.
 
 GENERATE_AUTOGEN_DEF   = NO
@@ -2011,7 +2165,7 @@ ENABLE_PREPROCESSING   = YES
 # The default value is: NO.
 # This tag requires that the tag ENABLE_PREPROCESSING is set to YES.
 
-MACRO_EXPANSION        = NO
+MACRO_EXPANSION        = YES
 
 # If the EXPAND_ONLY_PREDEF and MACRO_EXPANSION tags are both set to YES then
 # the macro expansion is limited to the macros specified with the PREDEFINED and
@@ -2118,12 +2272,6 @@ EXTERNAL_GROUPS        = YES
 
 EXTERNAL_PAGES         = YES
 
-# The PERL_PATH should be the absolute path and name of the perl script
-# interpreter (i.e. the result of 'which perl').
-# The default file (with absolute path) is: /usr/bin/perl.
-
-PERL_PATH              = /usr/bin/perl
-
 #---------------------------------------------------------------------------
 # Configuration options related to the dot tool
 #---------------------------------------------------------------------------
@@ -2137,15 +2285,6 @@ PERL_PATH              = /usr/bin/perl
 
 CLASS_DIAGRAMS         = YES
 
-# You can define message sequence charts within doxygen comments using the \msc
-# command. Doxygen will then run the mscgen tool (see:
-# http://www.mcternan.me.uk/mscgen/)) to produce the chart and insert it in the
-# documentation. The MSCGEN_PATH tag allows you to specify the directory where
-# the mscgen tool resides. If left empty the tool is assumed to be found in the
-# default search path.
-
-MSCGEN_PATH            =
-
 # You can include diagrams made with dia in doxygen documentation. Doxygen will
 # then run dia to produce the diagram and insert it in the documentation. The
 # DIA_PATH tag allows you to specify the directory where the dia binary resides.
@@ -2243,10 +2382,32 @@ UML_LOOK               = NO
 # but if the number exceeds 15, the total amount of fields shown is limited to
 # 10.
 # Minimum value: 0, maximum value: 100, default value: 10.
-# This tag requires that the tag HAVE_DOT is set to YES.
+# This tag requires that the tag UML_LOOK is set to YES.
 
 UML_LIMIT_NUM_FIELDS   = 10
 
+# If the DOT_UML_DETAILS tag is set to NO, doxygen will show attributes and
+# methods without types and arguments in the UML graphs. If the DOT_UML_DETAILS
+# tag is set to YES, doxygen will add type and arguments for attributes and
+# methods in the UML graphs. If the DOT_UML_DETAILS tag is set to NONE, doxygen
+# will not generate fields with class member information in the UML graphs. The
+# class diagrams will look similar to the default class diagrams but using UML
+# notation for the relationships.
+# Possible values are: NO, YES and NONE.
+# The default value is: NO.
+# This tag requires that the tag UML_LOOK is set to YES.
+
+DOT_UML_DETAILS        = NO
+
+# The DOT_WRAP_THRESHOLD tag can be used to set the maximum number of characters
+# to display on a single line. If the actual line length exceeds this threshold
+# significantly it will wrapped across multiple lines. Some heuristics are apply
+# to avoid ugly line breaks.
+# Minimum value: 0, maximum value: 1000, default value: 17.
+# This tag requires that the tag HAVE_DOT is set to YES.
+
+DOT_WRAP_THRESHOLD     = 17
+
 # If the TEMPLATE_RELATIONS tag is set to YES then the inheritance and
 # collaboration graphs will show the relations between templates and their
 # instances.
@@ -2438,9 +2599,11 @@ DOT_MULTI_TARGETS      = NO
 
 GENERATE_LEGEND        = YES
 
-# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate dot
+# If the DOT_CLEANUP tag is set to YES, doxygen will remove the intermediate
 # files that are used to generate the various graphs.
+#
+# Note: This setting is not only used for dot files but also for msc and
+# plantuml temporary files.
 # The default value is: YES.
-# This tag requires that the tag HAVE_DOT is set to YES.
 
 DOT_CLEANUP            = YES

docs/md/config.md

@@ -0,0 +1,111 @@
+# Crash Course: configuration
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [Definitions](#definitions)
+  * [ENTT_NOEXCEPTION](#entt_noexcept)
+  * [ENTT_USE_ATOMIC](#entt_use_atomic)
+  * [ENTT_ID_TYPE](#entt_id_type)
+  * [ENTT_SPARSE_PAGE](#entt_sparse_page)
+  * [ENTT_PACKED_PAGE](#entt_packed_page)
+  * [ENTT_ASSERT](#entt_assert)
+    * [ENTT_DISABLE_ASSERT](#entt_disable_assert)
+  * [ENTT_NO_ETO](#entt_no_eto)
+  * [ENTT_STANDARD_CPP](#entt_standard_cpp)
+
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+`EnTT` doesn't offer many hooks for customization but it certainly offers
+some.<br/>
+In the vast majority of cases, users will have no interest in changing the
+default parameters. For all other cases, the list of possible configurations
+with which it's possible to adjust the behavior of the library at runtime can be
+found below.
+
+# Definitions
+
+All options are intended as parameters to the compiler (or user-defined macros
+within the compilation units, if preferred).<br/>
+Each parameter can result in internal library definitions. It's not recommended
+to try to also modify these definitions, since there is no guarantee that they
+will remain stable over time unlike the options below.
+
+## ENTT_NOEXCEPTION
+
+This parameter can be used to switch off exception handling in `EnTT`.<br/>
+To do this, simply define the variable without assigning any value to it. This
+is roughly equivalent to setting the compiler flag `-ff-noexceptions`.
+
+## ENTT_USE_ATOMIC
+
+In general, `EnTT` doesn't offer primitives to support multi-threading. Many of
+the features can be split over multiple threads without any explicit control and
+the user is the only one who knows if and when a synchronization point is
+required.<br/>
+However, some features aren't easily accessible to users and can be made
+thread-safe by means of this definition.
+
+## ENTT_ID_TYPE
+
+`entt::id_type` is directly controlled by this definition and widely used within
+the library.<br/>
+By default, its type is `std::uint32_t`. However, users can define a different
+default type if necessary.
+
+## ENTT_SPARSE_PAGE
+
+It's known that the ECS module of `EnTT` is based on _sparse sets_. What is less
+known perhaps is that the sparse arrays are paged to reduce memory usage.<br/>
+Default size of pages (that is, the number of elements they contain) is 4096 but
+users can adjust it if appropriate. In all case, the chosen value **must** be a
+power of 2.
+
+## ENTT_PACKED_PAGE
+
+Similar to sparse arrays, packed arrays of components are paginated as well. In
+However, int this case the aim isn't to reduce memory usage but to have pointer
+stability upon component creation.<br/>
+Default size of pages (that is, the number of elements they contain) is 1024 but
+users can adjust it if appropriate. In all case, the chosen value **must** be a
+power of 2.
+
+## ENTT_ASSERT
+
+For performance reasons, `EnTT` doesn't use exceptions or any other control
+structures. In fact, it offers many features that result in undefined behavior
+if not used correctly.<br/>
+To get around this, the library relies on a lot of asserts for the purpose of
+detecting errors in debug builds. By default, it uses `assert` internally, but
+users are allowed to overwrite its behavior by setting this variable.
+
+### ENTT_DISABLE_ASSERT
+
+Assertions may in turn affect performance to an extent when enabled. Whether
+`ENTT_ASSERT` is redefined or not, all asserts can be disabled at once by means
+of this definition.<br/>
+Note that `ENTT_DISABLE_ASSERT` takes precedence over the redefinition of
+`ENTT_ASSERT` and is therefore meant to disable all controls no matter what.
+
+## ENTT_NO_ETO
+
+In order to reduce memory consumption and increase performance, empty types are
+never stored by the ECS module of `EnTT`.<br/>
+Use this variable to treat these types like all others and therefore to create a
+dedicated storage for them.
+
+## ENTT_STANDARD_CPP
+
+`EnTT` mixes non-standard language features with others that are perfectly
+compliant to offer some of its functionalities.<br/>
+This definition will prevent the library from using non-standard techniques,
+that is, functionalities that aren't fully compliant with the standard C++.<br/>
+While there are no known portability issues at the time of this writing, this
+should make the library fully portable anyway if needed.

docs/md/container.md

@@ -0,0 +1,67 @@
+# Crash Course: containers
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [Containers](#containers)
+  * [Dense map](#dense-map)
+  * [Dense set](#dense-set)
+
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+The standard C++ library offers a wide range of containers and it's really
+difficult to do better (although it's very easy to do worse, as many examples
+available online demonstrate).<br/>
+`EnTT` doesn't try in any way to replace what is offered by the standard. Quite
+the opposite, given the widespread use that is made of standard containers.<br/>
+However, the library also tries to fill a gap in features and functionality by
+making available some containers initially developed for internal use.
+
+This section of the library is likely to grow larger over time. However, for the
+moment it's quite small and mainly aimed at satisfying some internal needs.<br/>
+For all containers made available, full test coverage and stability over time is
+guaranteed as usual.
+
+# Containers
+
+## Dense map
+
+The dense map made available in `EnTT` is a hash map that aims to return a
+packed array of elements, so as to reduce the number of jumps in memory during
+iterations.<br/>
+The implementation is based on _sparse sets_ and each bucket is identified by an
+implicit list within the packed array itself.
+
+The interface is very close to its counterpart in the standard library, that is,
+`std::unordered_map`.<br/>
+However, both local and non-local iterators returned by a dense map belong to
+the input iterator category although they respectively model the concepts of a
+_forward iterator_ type and a _random access iterator_ type.<br/>
+This is because they return a pair of references rather than a reference to a
+pair. In other words, dense maps return a so called _proxy iterator_ the value
+type of which is:
+
+* `std::pair<const Key &, Type &>` for non-const iterator types.
+* `std::pair<const Key &, const Type &>` for const iterator types.
+
+This is quite different from what any standard library map returns and should be
+taken into account when looking for a drop-in replacement.
+
+## Dense set
+
+The dense set made available in `EnTT` is a hash set that aims to return a
+packed array of elements, so as to reduce the number of jumps in memory during
+iterations.<br/>
+The implementation is based on _sparse sets_ and each bucket is identified by an
+implicit list within the packed array itself.
+
+The interface is in all respects similar to its counterpart in the standard
+library, that is, `std::unordered_set`.<br/>
+Therefore, there is no need to go into the API description.

docs/md/core.md

@@ -0,0 +1,920 @@
+# Crash Course: core functionalities
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [Any as in any type](#any-as-in-any-type)
+  * [Small buffer optimization](#small-buffer-optimization)
+  * [Alignment requirement](#alignment-requirement)
+* [Compressed pair](#compressed-pair)
+* [Enum as bitmask](#enum-as-bitmask)
+* [Hashed strings](#hashed-strings)
+  * [Wide characters](wide-characters)
+  * [Conflicts](#conflicts)
+* [Memory](#memory)
+  * [Power of two and fast modulus](#power-of-two-and-fast-modulus)
+  * [Allocator aware unique pointers](#allocator-aware-unique-pointers)
+* [Monostate](#monostate)
+* [Type support](#type-support)
+  * [Built-in RTTI support](#built-in-rtti-support)
+    * [Type info](#type-info)
+    * [Almost unique identifiers](#almost-unique-identifiers)
+  * [Type traits](#type-traits)
+    * [Size of](#size-of)
+    * [Is applicable](#is-applicable)
+    * [Constness as](#constness-as)
+    * [Member class type](#member-class-type)
+    * [Integral constant](#integral-constant)
+    * [Tag](#tag)
+    * [Type list and value list](#type-list-and-value-list)
+* [Unique sequential identifiers](#unique-sequential-identifiers)
+  * [Compile-time generator](#compile-time-generator)
+  * [Runtime generator](#runtime-generator)
+* [Utilities](#utilities)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+`EnTT` comes with a bunch of core functionalities mostly used by the other parts
+of the library itself.<br/>
+Hardly users will include these features in their code, but it's worth
+describing what `EnTT` offers so as not to reinvent the wheel in case of need.
+
+# Any as in any type
+
+`EnTT` comes with its own `any` type. It may seem redundant considering that
+C++17 introduced `std::any`, but it is not (hopefully).<br/>
+First of all, the _type_ returned by an `std::any` is a const reference to an
+`std::type_info`, an implementation defined class that's not something everyone
+wants to see in a software. Furthermore, there is no way to connect it with the
+type system of the library and therefore with its integrated RTTI support.<br/>
+Note that this class is largely used internally by the library itself.
+
+The API is very similar to that of its most famous counterpart, mainly because
+this class serves the same purpose of being an opaque container for any type of
+value.<br/>
+Instances of `any` also minimize the number of allocations by relying on a well
+known technique called _small buffer optimization_ and a fake vtable.
+
+Creating an object of the `any` type, whether empty or not, is trivial:
+
+```cpp
+// an empty container
+entt::any empty{};
+
+// a container for an int
+entt::any any{0};
+
+// in place construction
+entt::any in_place{std::in_place_type<int>, 42};
+```
+
+Alternatively, the `make_any` function serves the same purpose but requires to
+always be explicit about the type:
+
+```cpp
+entt::any any = entt::make_any<int>(42);
+```
+
+In both cases, the `any` class takes the burden of destroying the contained
+element when required, regardless of the storage strategy used for the specific
+object.<br/>
+Furthermore, an instance of `any` isn't tied to an actual type. Therefore, the
+wrapper is reconfigured when it's assigned a new object of a type other than
+the one it contains.
+
+There exists also a way to directly assign a value to the variable contained by
+an `entt::any`, without necessarily replacing it. This is especially useful when
+the object is used in _aliasing mode_, as described below:
+
+```cpp
+entt::any any{42};
+entt::any value{3};
+
+// assigns by copy
+any.assign(value);
+
+// assigns by move
+any.assign(std::move(value));
+```
+
+The `any` class will also perform a check on the type information and whether or
+not the original type was copy or move assignable, as appropriate.<br/>
+In all cases, the `assign` function returns a boolean value to indicate the
+success or failure of the operation.
+
+When in doubt about the type of object contained, the `type` member function of
+`any` returns a const reference to the `type_info` associated with its element,
+or `type_id<void>()` if the container is empty. The type is also used internally
+when comparing two `any` objects:
+
+```cpp
+if(any == empty) { /* ... */ }
+```
+
+In this case, before proceeding with a comparison, it's verified that the _type_
+of the two objects is actually the same.<br/>
+Refer to the `EnTT` type system documentation for more details about how
+`type_info` works and on possible risks of a comparison.
+
+A particularly interesting feature of this class is that it can also be used as
+an opaque container for const and non-const references:
+
+```cpp
+int value = 42;
+
+entt::any any{std::in_place_type<int &>(value)};
+entt::any cany = entt::make_any<const int &>(value);
+entt::any fwd = entt::forward_as_any(value);
+
+any.emplace<const int &>(value);
+```
+
+In other words, whenever `any` is explicitly told to construct an _alias_, it
+acts as a pointer to the original instance rather than making a copy of it or
+moving it internally. The contained object is never destroyed and users must
+ensure that its lifetime exceeds that of the container.<br/>
+Similarly, it's possible to create non-owning copies of `any` from an existing
+object:
+
+```cpp
+// aliasing constructor
+entt::any ref = other.as_ref();
+```
+
+In this case, it doesn't matter if the original container actually holds an
+object or acts already as a reference for unmanaged elements, the new instance
+thus created won't create copies and will only serve as a reference for the
+original item.<br/>
+This means that, starting from the example above, both `ref` and `other` will
+point to the same object, whether it's initially contained in `other` or already
+an unmanaged element.
+
+As a side note, it's worth mentioning that, while everything works transparently
+when it comes to non-const references, there are some exceptions when it comes
+to const references.<br/>
+In particular, the `data` member function invoked on a non-const instance of
+`any` that wraps a const reference will return a null pointer in all cases.
+
+To cast an instance of `any` to a type, the library offers a set of `any_cast`
+functions in all respects similar to their most famous counterparts.<br/>
+The only difference is that, in the case of `EnTT`, these won't raise exceptions
+but will only trigger an assert in debug mode, otherwise resulting in undefined
+behavior in case of misuse in release mode.
+
+## Small buffer optimization
+
+The `any` class uses a technique called _small buffer optimization_ to reduce
+the number of allocations where possible.<br/>
+The default reserved size for an instance of `any` is `sizeof(double[2])`.
+However, this is also configurable if needed. In fact, `any` is defined as an
+alias for `basic_any<Len>`, where `Len` is the size above.<br/>
+Users can easily set a custom size or define their own aliases:
+
+```cpp
+using my_any = entt::basic_any<sizeof(double[4])>;
+```
+
+This feature, in addition to allowing the choice of a size that best suits the
+needs of an application, also offers the possibility of forcing dynamic creation
+of objects during construction.<br/>
+In other terms, if the size is 0, `any` avoids the use of any optimization and
+always dynamically allocates objects (except for aliasing cases).
+
+Note that the size of the internal storage as well as the alignment requirements
+are directly part of the type and therefore contribute to define different types
+that won't be able to interoperate with each other.
+
+## Alignment requirement
+
+The alignment requirement is optional and by default the most stringent (the
+largest) for any object whose size is at most equal to the one provided.<br/>
+The `basic_any` class template inspects the alignment requirements in each case,
+even when not provided and may decide not to use the small buffer optimization
+in order to meet them.
+
+The alignment requirement is provided as an optional second parameter following
+the desired size for the internal storage:
+
+```cpp
+using my_any = entt::basic_any<sizeof(double[4]), alignof(double[4])>;
+```
+
+Note that the alignment requirements as well as the size of the internal storage
+are directly part of the type and therefore contribute to define different types
+that won't be able to interoperate with each other.
+
+# Compressed pair
+
+Primarily designed for internal use and far from being feature complete, the
+`compressed_pair` class does exactly what it promises: it tries to reduce the
+size of a pair by exploiting _Empty Base Class Optimization_ (or _EBCO_).<br/>
+This class **is not** a drop-in replacement for `std::pair`. However, it offers
+enough functionalities to be a good alternative for when reducing memory usage
+is more important than having some cool and probably useless feature.
+
+Although the API is very close to that of `std::pair` (apart from the fact that
+the template parameters are inferred from the constructor and therefore there is
+no` entt::make_compressed_pair`), the major difference is that `first` and
+`second` are functions for implementation needs:
+
+```cpp
+entt::compressed_pair pair{0, 3.};
+pair.first() = 42;
+```
+
+There isn't much to describe then. It's recommended to rely on documentation and
+intuition. At the end of the day, it's just a pair and nothing more.
+
+# Enum as bitmask
+
+Sometimes it's useful to be able to use enums as bitmasks. However, enum classes
+aren't really suitable for the purpose out of the box. Main problem is that they
+don't convert implicitly to their underlying type.<br/>
+All that remains is to make a choice between using old-fashioned enums (with all
+their problems that I don't want to discuss here) or writing _ugly_ code.
+
+Fortunately, there is also a third way: adding enough operators in the global
+scope to treat enum classes as bitmask transparently.<br/>
+The ultimate goal is to be able to write code like the following (or maybe
+something more meaningful, but this should give a grasp and remain simple at the
+same time):
+
+```cpp
+enum class my_flag {
+    unknown = 0x01,
+    enabled = 0x02,
+    disabled = 0x04
+};
+
+const my_flag flags = my_flag::enabled;
+const bool is_enabled = !!(flags & my_flag::enabled);
+```
+
+The problem with adding all operators to the global scope is that these will
+come into play even when not required, with the risk of introducing errors that
+are difficult to deal with.<br/>
+However, C++ offers enough tools to get around this problem. In particular, the
+library requires users to register all enum classes for which bitmask support
+should be enabled:
+
+```cpp
+template<>
+struct entt::enum_as_bitmask<my_flag>
+    : std::true_type
+{};
+```
+
+This is handy when dealing with enum classes defined by third party libraries
+and over which the users have no control. However, it's also verbose and can be
+avoided by adding a specific value to the enum class itself:
+
+```cpp
+enum class my_flag {
+    unknown = 0x01,
+    enabled = 0x02,
+    disabled = 0x04,
+    _entt_enum_as_bitmask
+};
+```
+
+In this case, there is no need to specialize the `enum_as_bitmask` traits, since
+`EnTT` will automatically detect the flag and enable the bitmask support.<br/>
+Once the enum class has been registered (in one way or the other) all the most
+common operators will be available, such as `&`, `|` but also `&=` and `|=`.
+Refer to the official documentation for the full list of operators.
+
+# Hashed strings
+
+A hashed string is a zero overhead unique identifier. Users can use
+human-readable identifiers in the codebase while using their numeric
+counterparts at runtime, thus without affecting performance.<br/>
+The class has an implicit `constexpr` constructor that chews a bunch of
+characters. Once created, all what one can do with it is getting back the
+original string through the `data` member function or converting the instance
+into a number.<br/>
+The good part is that a hashed string can be used wherever a constant expression
+is required and no _string-to-number_ conversion will take place at runtime if
+used carefully.
+
+Example of use:
+
+```cpp
+auto load(entt::hashed_string::hash_type resource) {
+    // uses the numeric representation of the resource to load and return it
+}
+
+auto resource = load(entt::hashed_string{"gui/background"});
+```
+
+There is also a _user defined literal_ dedicated to hashed strings to make them
+more user-friendly:
+
+```cpp
+using namespace entt::literals;
+constexpr auto str = "text"_hs;
+```
+
+To use it, remember that all user defined literals in `EnTT` are enclosed in the
+`entt::literals` namespace. Therefore, the entire namespace or selectively the
+literal of interest must be explicitly included before each use, a bit like
+`std::literals`.<br/>
+Finally, in case users need to create hashed strings at runtime, this class also
+offers the necessary functionalities:
+
+```cpp
+std::string orig{"text"};
+
+// create a full-featured hashed string...
+entt::hashed_string str{orig.c_str()};
+
+// ... or compute only the unique identifier
+const auto hash = entt::hashed_string::value(orig.c_str());
+```
+
+This possibility shouldn't be exploited in tight loops, since the computation
+takes place at runtime and no longer at compile-time and could therefore impact
+performance to some degrees.
+
+## Wide characters
+
+The hashed string has a design that is close to that of an `std::basic_string`.
+It means that `hashed_string` is nothing more than an alias for
+`basic_hashed_string<char>`. For those who want to use the C++ type for wide
+character representation, there exists also the alias `hashed_wstring` for
+`basic_hashed_string<wchar_t>`.<br/>
+In this case, the user defined literal to use to create hashed strings on the
+fly is `_hws`:
+
+```cpp
+constexpr auto str = L"text"_hws;
+```
+
+Note that the hash type of the `hashed_wstring` is the same of its counterpart.
+
+## Conflicts
+
+The hashed string class uses internally FNV-1a to compute the numeric
+counterpart of a string. Because of the _pigeonhole principle_, conflicts are
+possible. This is a fact.<br/>
+There is no silver bullet to solve the problem of conflicts when dealing with
+hashing functions. In this case, the best solution seemed to be to give up.
+That's all.<br/>
+After all, human-readable unique identifiers aren't something strictly defined
+and over which users have not the control. Choosing a slightly different
+identifier is probably the best solution to make the conflict disappear in this
+case.
+
+# Memory
+
+There are a handful of tools within EnTT to interact with memory in one way or
+another.<br/>
+Some are geared towards simplifying the implementation of (internal or external)
+allocator aware containers. Others, on the other hand, are designed to help the
+developer with everyday problems.
+
+The former are very specific and for niche problems. These are tools designed to
+unwrap fancy or plain pointers (`to_address`) or to help forget the meaning of
+acronyms like _POCCA_, _POCMA_ or _POCS_.<br/>
+I won't describe them here in detail. Instead, I recommend reading the inline
+documentation to those interested in the subject.
+
+## Power of two and fast modulus
+
+Finding out if a number is a power of two (`is_power_of_two`) or what the next
+power of two is given a random value (`next_power_of_two`) is very useful at
+times.<br/>
+For example, it helps to allocate memory in pages having a size suitable for the
+fast modulus:
+
+```cpp
+const std::size_t result = entt::fast_mod(value, modulus);
+```
+
+Where `modulus` is necessarily a power of two. Perhaps not everyone knows that
+this type of operation is far superior in terms of performance to the basic
+modulus and for this reason preferred in many areas.
+
+## Allocator aware unique pointers
+
+A nasty thing in C++ (at least up to C++20) is the fact that shared pointers
+support allocators while unique pointers don't.<br/>
+There is a proposal at the moment that also shows among the other things how
+this can be implemented without any compiler support.
+
+The `allocate_unique` function follows this proposal, making a virtue out of
+necessity:
+
+```cpp
+std::unique_ptr<my_type, entt::allocation_deleter<my_type>> ptr = entt::allocate_unique<my_type>(allocator, arguments);
+```
+
+Although the internal implementation is slightly different from what is proposed
+for the standard, this function offers an API that is a drop-in replacement for
+the same feature.
+
+# Monostate
+
+The monostate pattern is often presented as an alternative to a singleton based
+configuration system. This is exactly its purpose in `EnTT`. Moreover, this
+implementation is thread safe by design (hopefully).<br/>
+Keys are represented by hashed strings, values are basic types like `int`s or
+`bool`s. Values of different types can be associated to each key, even more than
+one at a time. Because of this, users must pay attention to use the same type
+both during an assignment and when they try to read back their data. Otherwise,
+they will probably incur in unexpected results.
+
+Example of use:
+
+```cpp
+entt::monostate<entt::hashed_string{"mykey"}>{} = true;
+entt::monostate<"mykey"_hs>{} = 42;
+
+// ...
+
+const bool b = entt::monostate<"mykey"_hs>{};
+const int i = entt::monostate<entt::hashed_string{"mykey"}>{};
+```
+
+# Type support
+
+`EnTT` provides some basic information about types of all kinds.<br/>
+It also offers additional features that are not yet available in the standard
+library or that will never be.
+
+## Built-in RTTI support
+
+Runtime type identification support (or RTTI) is one of the most frequently
+disabled features in the C++ world, especially in the gaming sector. Regardless
+of the reasons for this, it's often a shame not to be able to rely on opaque
+type information at runtime.<br/>
+The library tries to fill this gap by offering a built-in system that doesn't
+serve as a replacement but comes very close to being one and offers similar
+information to that provided by its counterpart.
+
+Basically, the whole system relies on a handful of classes. In particular:
+
+* The unique sequential identifier associated with a given type:
+
+  ```cpp
+  auto index = entt::type_index<a_type>::value();
+  ```
+
+  The returned value isn't guaranteed to be stable across different runs.
+  However, it can be very useful as index in associative and unordered
+  associative containers or for positional accesses in a vector or an array.
+  
+  So as not to conflict with the other tools available, the `family` class isn't
+  used to generate these indexes. Therefore, the numeric identifiers returned by
+  the two tools may differ.<br/>
+  On the other hand, this leaves users with full powers over the `family` class
+  and therefore the generation of custom runtime sequences of indices for their
+  own purposes, if necessary.
+  
+  An external generator can also be used if needed. In fact, `type_index` can be
+  specialized by type and is also _sfinae-friendly_ in order to allow more
+  refined specializations such as:
+  
+  ```cpp
+  template<typename Type>
+  struct entt::type_index<Type, std::void_d<decltype(Type::index())>> {
+      static entt::id_type value() ENTT_NOEXCEPT {
+          return Type::index();
+      }
+  };
+  ```
+  
+  Note that indexes **must** still be generated sequentially in this case.<br/>
+  The tool is widely used within `EnTT`. Generating indices not sequentially
+  would break an assumption and would likely lead to undesired behaviors.
+
+* The hash value associated with a given type:
+
+  ```cpp
+  auto hash = entt::type_hash<a_type>::value();
+  ```
+
+  In general, the `value` function exposed by `type_hash` is also `constexpr`
+  but this isn't guaranteed for all compilers and platforms (although it's valid
+  with the most well-known and popular ones).
+
+  This function **can** use non-standard features of the language for its own
+  purposes. This makes it possible to provide compile-time identifiers that
+  remain stable across different runs.<br/>
+  In all cases, users can prevent the library from using these features by means
+  of the `ENTT_STANDARD_CPP` definition. In this case, there is no guarantee
+  that identifiers remain stable across executions. Moreover, they are generated
+  at runtime and are no longer a compile-time thing.
+
+  As for `type_index`, also `type_hash` is a _sfinae-friendly_ class that can be
+  specialized in order to customize its behavior globally or on a per-type or
+  per-traits basis.
+
+* The name associated with a given type:
+
+  ```cpp
+  auto name = entt::type_name<a_type>::value();
+  ```
+
+  The name associated with a type is extracted from some information generally
+  made available by the compiler in use. Therefore, it may differ depending on
+  the compiler and may be empty in the event that this information isn't
+  available.<br/>
+  For example, given the following class:
+
+  ```cpp
+  struct my_type { /* ... */ };
+  ```
+
+  The name is `my_type` when compiled with GCC or CLang and `struct my_type`
+  when MSVC is in use.<br/>
+  Most of the time the name is also retrieved at compile-time and is therefore
+  always returned through an `std::string_view`. Users can easily access it and
+  modify it as needed, for example by removing the word `struct` to standardize
+  the result. `EnTT` won't do this for obvious reasons, since it requires
+  copying and creating a new string potentially at runtime.
+
+  This function **can** use non-standard features of the language for its own
+  purposes. Users can prevent the library from using non-standard features by
+  means of the `ENTT_STANDARD_CPP` definition. In this case, the name will be
+  empty by default.
+
+  As for `type_index`, also `type_name` is a _sfinae-friendly_ class that can be
+  specialized in order to customize its behavior globally or on a per-type or
+  per-traits basis.
+
+These are then combined into utilities that aim to offer an API that is somewhat
+similar to that offered by the language.
+
+### Type info
+
+The `type_info` class isn't a drop-in replacement for `std::type_info` but can
+provide similar information which are not implementation defined and don't
+require to enable RTTI.<br/>
+Therefore, they can sometimes be even more reliable than those obtained
+otherwise.
+
+Its type defines an opaque class that is also copyable and movable.<br/>
+Objects of this type are generally returned by the `type_id` functions:
+
+```cpp
+// by type
+auto info = entt::type_id<a_type>();
+
+// by value
+auto other = entt::type_id(42);
+```
+
+All elements thus received are nothing more than const references to instances
+of `type_info` with static storage duration.<br/>
+This is convenient for saving the entire object aside for the cost of a pointer.
+However, nothing prevents from constructing `type_info` objects directly:
+
+```cpp
+entt::type_info info{std::in_place_type<int>};
+```
+
+These are the information made available by `type_info`:
+
+* The index associated with a given type:
+
+  ```cpp
+  auto idx = entt::type_id<a_type>().index();
+  ```
+
+  This is also an alias for the following:
+
+  ```cpp
+  auto idx = entt::type_index<std::remove_cv_t<std::remove_reference_t<a_type>>>::value();
+  ```
+
+* The hash value associated with a given type:
+
+  ```cpp
+  auto hash = entt::type_id<a_type>().hash();
+  ```
+
+  This is also an alias for the following:
+
+  ```cpp
+  auto hash = entt::type_hash<std::remove_cv_t<std::remove_reference_t<a_type>>>::value();
+  ```
+
+* The name associated with a given type:
+
+  ```cpp
+  auto name = entt::type_id<my_type>().name();
+  ```
+
+  This is also an alias for the following:
+
+  ```cpp
+  auto name = entt::type_name<std::remove_cv_t<std::remove_reference_t<a_type>>>::value();
+  ```
+
+Where all accessed features are available at compile-time, the `type_info` class
+is also fully `constexpr`. However, this cannot be guaranteed in advance and
+depends mainly on the compiler in use and any specializations of the classes
+described above.
+
+### Almost unique identifiers
+
+Since the default non-standard, compile-time implementation of `type_hash` makes
+use of hashed strings, it may happen that two types are assigned the same hash
+value.<br/>
+In fact, although this is quite rare, it's not entirely excluded.
+
+Another case where two types are assigned the same identifier is when classes
+from different contexts (for example two or more libraries loaded at runtime)
+have the same fully qualified name. In this case, also `type_name` will return
+the same value for the two types.<br/>
+Fortunately, there are several easy ways to deal with this:
+
+* The most trivial one is to define the `ENTT_STANDARD_CPP` macro. Runtime
+  identifiers don't suffer from the same problem in fact. However, this solution
+  doesn't work well with a plugin system, where the libraries aren't linked.
+
+* Another possibility is to specialize the `type_name` class for one of the
+  conflicting types, in order to assign it a custom identifier. This is probably
+  the easiest solution that also preserves the feature of the tool.
+
+* A fully customized identifier generation policy (based for example on enum
+  classes or preprocessing steps) may represent yet another option.
+
+These are just some examples of possible approaches to the problem but there are
+many others. As already mentioned above, since users have full control over
+their types, this problem is in any case easy to solve and should not worry too
+much.<br/>
+In all likelihood, it will never happen to run into a conflict anyway.
+
+## Type traits
+
+A handful of utilities and traits not present in the standard template library
+but which can be useful in everyday life.<br/>
+This list **is not** exhaustive and contains only some of the most useful
+classes. Refer to the inline documentation for more information on the features
+offered by this module.
+
+### Size of
+
+The standard operator `sizeof` complains when users provide it for example with
+function or incomplete types. On the other hand, it's guaranteed that its result
+is always nonzero, even if applied to an empty class type.<br/>
+This small class combines the two and offers an alternative to `sizeof` that
+works under all circumstances, returning zero if the type isn't supported:
+
+```cpp
+const auto size = entt::size_of_v<void>;
+```
+
+### Is applicable
+
+The standard library offers the great `std::is_invocable` trait in several
+forms. This takes a function type and a series of arguments and returns true if
+the condition is satisfied.<br/>
+Moreover, users are also provided with `std::apply`, a tool for combining
+invocable elements and tuples of arguments.
+
+It would therefore be a good idea to have a variant of `std::is_invocable` that
+also accepts its arguments in the form of a tuple-like type, so as to complete
+the offer:
+
+```cpp
+constexpr bool result = entt::is_applicable<Func, std::tuple<a_type, another_type>>;
+```
+
+This trait is built on top of `std::is_invocable` and does nothing but unpack a
+tuple-like type and simplify the code at the call site.
+
+### Constness as
+
+An utility to easily transfer the constness of a type to another type:
+
+```cpp
+// type is const dst_type because of the constness of src_type
+using type = entt::constness_as_t<dst_type, const src_type>;
+```
+
+The trait is subject to the rules of the language. Therefore, for example,
+transferring constness between references won't give the desired effect.
+
+### Member class type
+
+The `auto` template parameter introduced with C++17 made it possible to simplify
+many class templates and template functions but also made the class type opaque
+when members are passed as template arguments.<br/>
+The purpose of this utility is to extract the class type in a few lines of code:
+
+```cpp
+template<typename Member>
+using clazz = entt::member_class_t<Member>;
+```
+
+### Integral constant
+
+Since `std::integral_constant` may be annoying because of its form that requires
+to specify both a type and a value of that type, there is a more user-friendly
+shortcut for the creation of integral constants.<br/>
+This shortcut is the alias template `entt::integral_constant`:
+
+```cpp
+constexpr auto constant = entt::integral_constant<42>;
+```
+
+Among the other uses, when combined with a hashed string it helps to define tags
+as human-readable _names_ where actual types would be required otherwise:
+
+```cpp
+constexpr auto enemy_tag = entt::integral_constant<"enemy"_hs>;
+registry.emplace<enemy_tag>(entity);
+```
+
+### Tag
+
+Since `id_type` is very important and widely used in `EnTT`, there is a more
+user-friendly shortcut for the creation of integral constants based on it.<br/>
+This shortcut is the alias template `entt::tag`.
+
+If used in combination with hashed strings, it helps to use human-readable names
+where types would be required otherwise. As an example:
+
+```cpp
+registry.emplace<entt::tag<"enemy"_hs>>(entity);
+```
+
+However, this isn't the only permitted use. Literally any value convertible to
+`id_type` is a good candidate, such as the named constants of an unscoped enum.
+
+### Type list and value list
+
+There is no respectable library where the much desired _type list_ can be
+missing.<br/>
+`EnTT` is no exception and provides (making extensive use of it internally) the
+`type_list` type, in addition to its `value_list` counterpart dedicated to
+non-type template parameters.
+
+Here is a (possibly incomplete) list of the functionalities that come with a
+type list:
+
+* `type_list_element[_t]` to get the N-th element of a type list.
+* `type_list_cat[_t]` and a handy `operator+` to concatenate type lists.
+* `type_list_unique[_t]` to remove duplicate types from a type list.
+* `type_list_contains[_v]` to know if a type list contains a given type.
+* `type_list_diff[_t]` to remove types from type lists.
+
+I'm also pretty sure that more and more utilities will be added over time as
+needs become apparent.<br/>
+Many of these functionalities also exist in their version dedicated to value
+lists. We therefore have `value_list_element[_v]` as well as
+`value_list_cat[_t]`and so on.
+
+# Unique sequential identifiers
+
+Sometimes it's useful to be able to give unique, sequential numeric identifiers
+to types either at compile-time or runtime.<br/>
+There are plenty of different solutions for this out there and I could have used
+one of them. However, I decided to spend my time to define a couple of tools
+that fully embraces what the modern C++ has to offer.
+
+## Compile-time generator
+
+To generate sequential numeric identifiers at compile-time, `EnTT` offers the
+`identifier` class template:
+
+```cpp
+// defines the identifiers for the given types
+using id = entt::identifier<a_type, another_type>;
+
+// ...
+
+switch(a_type_identifier) {
+case id::type<a_type>:
+    // ...
+    break;
+case id::type<another_type>:
+    // ...
+    break;
+default:
+    // ...
+}
+```
+
+This is all what this class template has to offer: a `type` inline variable that
+contains a numeric identifier for the given type. It can be used in any context
+where constant expressions are required.
+
+As long as the list remains unchanged, identifiers are also guaranteed to be
+stable across different runs. In case they have been used in a production
+environment and a type has to be removed, one can just use a placeholder to left
+the other identifiers unchanged:
+
+```cpp
+template<typename> struct ignore_type {};
+
+using id = entt::identifier<
+    a_type_still_valid,
+    ignore_type<a_type_no_longer_valid>,
+    another_type_still_valid
+>;
+```
+
+Perhaps a bit ugly to see in a codebase but it gets the job done at least.
+
+## Runtime generator
+
+To generate sequential numeric identifiers at runtime, `EnTT` offers the
+`family` class template:
+
+```cpp
+// defines a custom generator
+using id = entt::family<struct my_tag>;
+
+// ...
+
+const auto a_type_id = id::type<a_type>;
+const auto another_type_id = id::type<another_type>;
+```
+
+This is all what a _family_ has to offer: a `type` inline variable that contains
+a numeric identifier for the given type.<br/>
+The generator is customizable, so as to get different _sequences_ for different
+purposes if needed.
+
+Please, note that identifiers aren't guaranteed to be stable across different
+runs. Indeed it mostly depends on the flow of execution.
+
+# Utilities
+
+It's not possible to escape the temptation to add utilities of some kind to a
+library. In fact, `EnTT` also provides a handful of tools to simplify the
+life of developers:
+
+* `entt::identity`: the identity function object that will be available with
+  C++20. It returns its argument unchanged and nothing more. It's useful as a
+  sort of _do nothing_ function in template programming.
+
+* `entt::overload`: a tool to disambiguate different overloads from their
+  function type. It works with both free and member functions.<br/>
+  Consider the following definition:
+
+  ```cpp
+  struct clazz {
+      void bar(int) {}
+      void bar() {}
+  };
+  ```
+
+  This utility can be used to get the _right_ overload as:
+
+  ```cpp
+  auto *member = entt::overload<void(int)>(&clazz::bar);
+  ```
+
+  The line above is literally equivalent to:
+
+  ```cpp
+  auto *member = static_cast<void(clazz:: *)(int)>(&clazz::bar);
+  ```
+
+  Just easier to read and shorter to type.
+
+* `entt::overloaded`: a small class template used to create a new type with an
+  overloaded `operator()` from a bunch of lambdas or functors.<br/>
+  As an example:
+
+  ```cpp
+  entt::overloaded func{
+      [](int value) { /* ... */ },
+      [](char value) { /* ... */ }
+  };
+
+  func(42);
+  func('c');
+  ```
+
+  Rather useful when doing metaprogramming and having to pass to a function a
+  callable object that supports multiple types at once.
+
+* `entt::y_combinator`: this is a C++ implementation of **the** _y-combinator_.
+  If it's not clear what it is, there is probably no need for this utility.<br/>
+  Below is a small example to show its use:
+
+  ```cpp
+  entt::y_combinator gauss([](const auto &self, auto value) -> unsigned int {
+      return value ? (value + self(value-1u)) : 0;
+  });
+
+  const auto result = gauss(3u);
+  ```
+
+  Maybe convoluted at a first glance but certainly effective. Unfortunately,
+  the language doesn't make it possible to do much better.
+
+This is a rundown of the (actually few) utilities made available by `EnTT`. The
+list will probably grow over time but the size of each will remain rather small,
+as has been the case so far.

docs/md/faq.md

@@ -0,0 +1,211 @@
+# Frequently Asked Questions
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [FAQ](#faq)
+  * [Why is my debug build on Windows so slow?](#why-is-my-debug-build-on-windows-so-slow)
+  * [How can I represent hierarchies with my components?](#how-can-i-represent-hierarchies-with-my-components)
+  * [Custom entity identifiers: yay or nay?](#custom-entity-identifiers-yay-or-nay)
+  * [Warning C4307: integral constant overflow](#warning-C4307-integral-constant-overflow)
+  * [Warning C4003: the min, the max and the macro](#warning-C4003-the-min-the-max-and-the-macro)
+  * [The standard and the non-copyable types](#the-standard-and-the-non-copyable-types)
+  * [Which functions trigger which signals](#which-functions-trigger-which-signals)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+This is a constantly updated section where I'll try to put the answers to the
+most frequently asked questions.<br/>
+If you don't find your answer here, there are two cases: nobody has done it yet
+or this section needs updating. In both cases, try to
+[open a new issue](https://github.com/skypjack/entt/issues/new) or enter the
+[gitter channel](https://gitter.im/skypjack/entt) and ask your question.
+Probably someone already has an answer for you and we can then integrate this
+part of the documentation.
+
+# FAQ
+
+## Why is my debug build on Windows so slow?
+
+`EnTT` is an experimental project that I also use to keep me up-to-date with the
+latest revision of the language and the standard library. For this reason, it's
+likely that some classes you're working with are using standard containers under
+the hood.<br/>
+Unfortunately, it's known that the standard containers aren't particularly
+performing in debugging (the reasons for this go beyond this document) and are
+even less so on Windows apparently. Fortunately this can also be mitigated a
+lot, achieving good results in many cases.
+
+First of all, there are two things to do in a Windows project:
+
+* Disable the [`/JMC`](https://docs.microsoft.com/cpp/build/reference/jmc)
+  option (_Just My Code_ debugging), available starting in Visual Studio 2017
+  version 15.8.
+
+* Set the [`_ITERATOR_DEBUG_LEVEL`](https://docs.microsoft.com/cpp/standard-library/iterator-debug-level)
+  macro to 0. This will disable checked iterators and iterator debugging.
+
+Moreover, the macro `ENTT_ASSERT` should be redefined to disable internal checks
+made by `EnTT` in debug:
+
+```cpp
+#define ENTT_ASSERT(...) ((void)0)
+```
+
+These asserts are introduced to help the users but they require to access to the
+underlying containers and therefore risk ruining the performance in some cases.
+
+With these changes, debug performance should increase enough for most cases. If
+you want something more, you can can also switch to an optimization level `O0`
+or preferably `O1`.
+
+## How can I represent hierarchies with my components?
+
+This is one of the first questions that anyone makes when starting to work with
+the entity-component-system architectural pattern.<br/>
+There are several approaches to the problem and what’s the best one depends
+mainly on the real problem one is facing. In all cases, how to do it doesn't
+strictly depend on the library in use, but the latter can certainly allow or
+not different techniques depending on how the data are laid out.
+
+I tried to describe some of the techniques that fit well with the model of
+`EnTT`. [Here](https://skypjack.github.io/2019-06-25-ecs-baf-part-4/) is the
+first post of a series that tries to explore the problem. More will probably
+come in future.<br/>
+In addition, `EnTT` also offers the possibility to create stable storage types
+and therefore have pointer stability for one, all or some components. This is by
+far the most convenient solution when it comes to creating hierarchies and
+whatnot. See the documentation for the ECS part of the library and in particular
+what concerns the `component_traits` class for further details.
+
+## Custom entity identifiers: yay or nay?
+
+Custom entity identifiers are definitely a good idea in two cases at least:
+
+* If `std::uint32_t` isn't large enough for your purposes, since this is the
+  underlying type of `entt::entity`.
+* If you want to avoid conflicts when using multiple registries.
+
+Identifiers can be defined through enum classes and class types that define an
+`entity_type` member of type `std::uint32_t` or `std::uint64_t`.<br/>
+In fact, this is a definition equivalent to that of `entt::entity`:
+
+```cpp
+enum class entity: std::uint32_t {};
+```
+
+There is no limit to the number of identifiers that can be defined.
+
+## Warning C4307: integral constant overflow
+
+According to [this](https://github.com/skypjack/entt/issues/121) issue, using a
+hashed string under VS could generate a warning.<br/>
+First of all, I want to reassure you: it's expected and harmless. However, it
+can be annoying.
+
+To suppress it and if you don't want to suppress all the other warnings as well,
+here is a workaround in the form of a macro:
+
+```cpp
+#if defined(_MSC_VER)
+#define HS(str) __pragma(warning(suppress:4307)) entt::hashed_string{str}
+#else
+#define HS(str) entt::hashed_string{str}
+#endif
+```
+
+With an example of use included:
+
+```cpp
+constexpr auto identifier = HS("my/resource/identifier");
+```
+
+Thanks to [huwpascoe](https://github.com/huwpascoe) for the courtesy.
+
+## Warning C4003: the min, the max and the macro
+
+On Windows, a header file defines two macros `min` and `max` which may result in
+conflicts with their counterparts in the standard library and therefore in
+errors during compilation.
+
+It's a pretty big problem but fortunately it's not a problem of `EnTT` and there
+is a fairly simple solution to it.<br/>
+It consists in defining the `NOMINMAX` macro before to include any other header
+so as to get rid of the extra definitions:
+
+```cpp
+#define NOMINMAX
+```
+
+Please refer to [this](https://github.com/skypjack/entt/issues/96) issue for
+more details.
+
+## The standard and the non-copyable types
+
+`EnTT` uses internally the trait `std::is_copy_constructible_v` to check if a
+component is actually copyable. However, this trait doesn't really check whether
+a type is actually copyable. Instead, it just checks that a suitable copy
+constructor and copy operator exist.<br/>
+This can lead to surprising results due to some idiosyncrasies of the standard.
+
+For example, `std::vector` defines a copy constructor that is conditionally
+enabled depending on whether the value type is copyable or not. As a result,
+`std::is_copy_constructible_v` returns true for the following specialization:
+
+```cpp
+struct type {
+    std::vector<std::unique_ptr<action>> vec;
+};
+```
+
+However, the copy constructor is effectively disabled upon specialization.
+Therefore, trying to assign an instance of this type to an entity may trigger a
+compilation error.<br/>
+As a workaround, users can mark the type explicitly as non-copyable. This also
+suppresses the implicit generation of the move constructor and operator, which
+will therefore have to be defaulted accordingly:
+
+```cpp
+struct type {
+    type(const type &) = delete;
+    type(type &&) = default;
+
+    type & operator=(const type &) = delete;
+    type & operator=(type &&) = default;
+
+    std::vector<std::unique_ptr<action>> vec;
+};
+```
+
+Note that aggregate initialization is also disabled as a consequence.<br/>
+Fortunately, this type of trick is quite rare. The bad news is that there is no
+way to deal with it at the library level, this being due to the design of the
+language. On the other hand, the fact that the language itself also offers a way
+to mitigate the problem makes it manageable.
+
+## Which functions trigger which signals
+
+The `registry` class offers three signals that are emitted following specific
+operations. Maybe not everyone knows what these operations are, though.<br/>
+If this isn't clear, below you can find a _vademecum_ for this purpose:
+
+* `on_created` is invoked when a component is first added (neither modified nor 
+  replaced) to an entity.
+* `on_update` is called whenever an existing component is modified or replaced.
+* `on_destroyed` is called when a component is explicitly or implicitly removed 
+  from an entity.
+
+Among the most controversial functions can be found `emplace_or_replace` and
+`destroy`. However, following the above rules, it's quite simple to know what 
+will happen.<br/>
+In the first case, `on_created` is invoked if the entity has not the component,
+otherwise the latter is replaced and therefore `on_update` is triggered. As for
+the second case, components are removed from their entities and thus freed when
+they are recycled. It means that `on_destroyed` is triggered for every component 
+owned by the entity that is destroyed.

docs/md/lib.md

@@ -0,0 +1,110 @@
+# Push EnTT across boundaries
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Working across boundaries](#working-across-boundaries)
+  * [Smooth until proven otherwise](#smooth-until-proven-otherwise)
+  * [Meta context](#meta-context)
+  * [Memory management](#memory-management)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Working across boundaries
+
+`EnTT` has historically had a limit when used across boundaries on Windows in
+general and on GNU/Linux when default visibility was set to hidden. The
+limitation was mainly due to a custom utility used to assign unique, sequential
+identifiers with different types.<br/>
+Fortunately, nowadays using `EnTT` across boundaries is much easier.
+
+## Smooth until proven otherwise
+
+Many classes in `EnTT` make extensive use of type erasure for their purposes.
+This isn't a problem on itself (in fact, it's the basis of an API so convenient
+to use). However, a way is needed to recognize the objects whose type has been
+erased on the other side of a boundary.<br/>
+The `type_hash` class template is how identifiers are generated and thus made
+available to the rest of the library. In general, this class doesn't arouse much
+interest. The only exception is when a conflict between identifiers occurs
+(definitely uncommon though) or when the default solution proposed by `EnTT`
+isn't suitable for the user's purposes.<br/>
+The section dedicated to `type_info` contains all the details to get around the
+issue in a concise and elegant way. Please refer to the specific documentation.
+
+When working with linked libraries, compile definitions `ENTT_API_EXPORT` and
+`ENTT_API_IMPORT` can be used where there is a need to import or export symbols,
+so as to make everything work nicely across boundaries.<br/>
+On the other hand, everything should run smoothly when working with plugins or
+shared libraries that don't export any symbols.
+
+For anyone who needs more details, the test suite contains multiple examples
+covering the most common cases (see the `lib` directory for all details).<br/>
+It goes without saying that it's impossible to cover **all** possible cases.
+However, what is offered should hopefully serve as a basis for all of them.
+
+## Meta context
+
+The runtime reflection system deserves a special mention when it comes to using
+it across boundaries.<br/>
+Since it's linked already to a static context to which the visible components
+are attached and different contexts don't relate to each other, they must be
+_shared_ to allow the use of meta types across boundaries.
+
+Sharing a context is trivial though. First of all, the local one must be
+acquired in the main space:
+
+```cpp
+entt::meta_ctx ctx{};
+```
+
+Then, it must passed to the receiving space that will set it as its global
+context, thus releasing the local one that remains available but is no longer
+referred to by the runtime reflection system:
+
+```cpp
+entt::meta_ctx::bind(ctx);
+```
+
+From now on, both spaces will refer to the same context and on it will be
+attached the new visible meta types, no matter where they are created.<br/>
+A context can also be reset and then associated again locally as:
+
+```cpp
+entt::meta_ctx::bind(entt::meta_ctx{});
+```
+
+This is allowed because local and global contexts are separated. Therefore, it's
+always possible to make the local context the current one again.
+
+Before to release a context, all locally registered types should be reset to
+avoid dangling references. Otherwise, if a type is accessed from another space
+by name, there could be an attempt to address its parts that are no longer
+available.
+
+## Memory Management
+
+There is another subtle problem due to memory management that can lead to
+headaches.<br/>
+It can occur where there are pools of objects (such as components or events)
+dynamically created on demand. This is usually not a problem when working with
+linked libraries that rely on the same dynamic runtime. However, it can occur in
+the case of plugins or statically linked runtimes.
+
+As an example, imagine creating an instance of `registry` in the main executable
+and sharing it with a plugin. If the latter starts working with a component that
+is unknown to the former, a dedicated pool is created within the registry on
+first use.<br/>
+As one can guess, this pool is instantiated on a different side of the boundary
+from the `registry`. Therefore, the instance is now managing memory from
+different spaces and this can quickly lead to crashes if not properly addressed.
+
+To overcome the risk, it's recommended to use well-defined interfaces that make
+fundamental types pass through the boundaries, isolating the instances of the
+`EnTT` classes from time to time and as appropriate.<br/>
+Refer to the test suite for some examples, read the documentation available
+online about this type of issues or consult someone who has already had such
+experiences to avoid problems.

docs/md/links.md

@@ -0,0 +1,251 @@
+# EnTT in Action
+
+`EnTT` is widely used in private and commercial applications. I cannot even
+mention most of them because of some signatures I put on some documents time
+ago. Fortunately, there are also people who took the time to implement open
+source projects based on `EnTT` and didn't hold back when it came to documenting
+them.
+
+Below an incomplete list of games, applications and articles that can be used as
+a reference. Where I put the word _apparently_ means that the use of `EnTT` is
+documented but the authors didn't make explicit announcements or contacted me
+directly.
+
+I hope this list can grow much more in the future:
+
+* Games:
+  * [Minecraft](https://minecraft.net/en-us/attribution/) by
+    [Mojang](https://mojang.com/): of course, **that** Minecraft, see the
+    open source attributions page for more details.
+  * [Minecraft Earth](https://www.minecraft.net/en-us/about-earth) by
+    [Mojang](https://mojang.com/): an augmented reality game for mobile, that
+    lets users bring Minecraft into the real world.
+  * [Ember Sword](https://embersword.com/): a modern Free-to-Play MMORPG with a
+    player-driven economy, a classless combat system, and scarce, tradable
+    cosmetic collectibles.
+  * Apparently [Diablo II: Resurrected](https://diablo2.blizzard.com/) by
+    [Blizzard](https://www.blizzard.com/): monsters, heroes, items, spells, all
+    resurrected. Thanks unknown insider.
+  * [Apparently](https://www.youtube.com/watch?v=P8xvOA3ikrQ&t=1105s)
+    [Call of Duty: Vanguard](https://www.callofduty.com/vanguard) by
+    [Sledgehammer Games](https://www.sledgehammergames.com/): I can neither
+    confirm nor deny but there is a license I know in the credits.
+  * Apparently [D&D Dark Alliance](https://darkalliance.wizards.com) by
+    [Wizards of the Coast](https://company.wizards.com): your party, their
+    funeral.
+  * [TiltedOnline](https://github.com/tiltedphoques/TiltedOnline) by
+    [Tilted Phoques](https://github.com/tiltedphoques): Skyrim and Fallout 4 mod
+    to play online.
+  * [Antkeeper](https://github.com/antkeeper/antkeeper-source): an ant colony
+    simulation [game](https://antkeeper.com/).
+  * [Openblack](https://github.com/openblack/openblack): open source
+    reimplementation of the game _Black & White_ (2001).
+  * [Land of the Rair](https://github.com/LandOfTheRair/core2): the new backend
+    of [a retro-style MUD](https://rair.land/) for the new age.
+  * [Face Smash](https://play.google.com/store/apps/details?id=com.gamee.facesmash):
+    a game to play with your face.
+  * [EnTT Pacman](https://github.com/Kerndog73/EnTT-Pacman): an example of how
+    to make Pacman with `EnTT`.
+  * [Wacman](https://github.com/carlfindahl/wacman): a pacman clone with OpenGL.
+  * [Classic Tower Defence](https://github.com/kerndog73/Classic-Tower-Defence):
+    a tiny little tower defence game featuring a homemade font.
+    [Check it out](https://indi-kernick.itch.io/classic-tower-defence).
+  * [The Machine](https://github.com/Kerndog73/The-Machine): a box pushing
+    puzzler with logic gates and other cool stuff.
+    [Check it out](https://indi-kernick.itch.io/the-machine-web-version).
+  * [EnTTPong](https://github.com/DomRe/EnttPong): a basic game made to showcase
+    different parts of EnTT and C++17.
+  * [Randballs](https://github.com/gale93/randballs): simple `SFML` and `EnTT`
+    playground.
+  * [EnTT Tower Defense](https://github.com/Daivuk/tddod): a data oriented tower
+    defense example.
+  * [EnTT Breakout](https://github.com/vblanco20-1/entt-breakout): simple
+    example of a breakout game, using `SDL` and `EnTT`.
+  * [Arcade puzzle game with EnTT](https://github.com/MasonRG/ArcadePuzzleGame):
+    arcade puzzle game made in C++ using the `SDL2` and `EnTT` libraries.
+  * [Snake with EnTT](https://github.com/MasonRG/SnakeGame): simple snake game
+    made in C++ with the `SDL2` and `EnTT` libraries.
+  * [Mirrors lasers and robots](https://github.com/guillaume-haerinck/imac-tower-defense):
+    a small tower defense game based on mirror orientation.
+  * [PopHead](https://github.com/SPC-Some-Polish-Coders/PopHead/): 2D, Zombie,
+    RPG game made from scratch in C++.
+  * [Robotligan](https://github.com/Trisslotten/robotligan): multiplayer
+    football game.
+  * [DungeonSlayer](https://github.com/alohaeee/DungeonSlayer): 2D game made
+    from scratch in C++.
+  * [3DGame](https://github.com/kwarkGorny/3DGame): 2.5D top-down space shooter.
+  * [Pulcher](https://github.com/AODQ/pulcher): 2D cross-platform game inspired
+    by Quake.
+  * [Destroid](https://github.com/tyrannicaltoucan/destroid): _one-bazillionth_
+    arcade game about shooting dirty rocks in space, inspired by Asteroids.
+  * [Wanderer](https://github.com/albin-johansson/wanderer): a 2D exploration
+    based indie game.
+  * [Spelunky® Classic remake](https://github.com/dbeef/spelunky-psp): a truly
+    multiplatform experience with a rewrite from scratch.
+  * [CubbyTower](https://github.com/utilForever/CubbyTower): a simple tower
+    defense game using C++ with Entity Component System (ECS).
+  * [Runeterra](https://github.com/utilForever/Runeterra): Legends of Runeterra
+    simulator using C++ with some reinforcement learning.
+  * [Black Sun](https://store.steampowered.com/app/1670930/Black_Sun/): fly your
+    space ship through a large 2D open world.
+  * [PokeMaster](https://github.com/utilForever/PokeMaster): Pokemon Battle
+    simulator using C++ with some reinforcement learning.
+  * [HomeHearth](https://youtu.be/GrEWl8npL9Y): choose your hero, protect the
+    town, before it's too late.
+  * [City Builder Game](https://github.com/PhiGei2000/CityBuilderGame): a simple
+    city-building game using C++ and OpenGL.
+
+* Engines and the like:
+  * [Aether Engine](https://hadean.com/spatial-simulation/)
+    [v1.1+](https://docs.hadean.com/v1.1/Licenses/) by
+    [Hadean](https://hadean.com/): a library designed for spatially partitioning
+    agent-based simulations.
+  * [Fling Engine](https://github.com/flingengine/FlingEngine): a Vulkan game
+    engine with a focus on data oriented design.
+  * [NovusCore](https://github.com/novuscore/NovusCore): a modern take on World
+    of Warcraft emulation.
+  * [Chrysalis](https://github.com/ivanhawkes/Chrysalis): action RPG SDK for
+    CRYENGINE games.
+  * [LM-Engine](https://github.com/Lawrencemm/LM-Engine): the Vim of game
+    engines.
+  * [Edyn](https://github.com/xissburg/edyn): a real-time physics engine
+    organized as an ECS.
+  * [MushMachine](https://github.com/MadeOfJelly/MushMachine): engine...
+    vrooooommm.
+  * [Antara Gaming SDK](https://github.com/KomodoPlatform/antara-gaming-sdk):
+    the Komodo Gaming Software Development Kit.
+  * [XVP](https://ravingbots.com/xvp-expansive-vehicle-physics-for-unreal-engine/):
+    [_eXpansive Vehicle Physics_](https://github.com/raving-bots/xvp/wiki/Plugin-integration-guide)
+    plugin for Unreal Engine.
+  * [Apparently](https://teamwisp.github.io/credits/)
+    [Wisp](https://teamwisp.github.io/product/) by
+    [Team Wisp](https://teamwisp.github.io/): an advanced real-time ray tracing
+    renderer built for the demands of video game artists.
+  * [shiva](https://github.com/Milerius/shiva): modern C++ engine with
+    modularity.
+  * [ImGui/EnTT editor](https://github.com/Green-Sky/imgui_entt_entity_editor):
+    a drop-in, single-file entity editor for `EnTT` that uses `ImGui` as
+    graphical backend (with
+    [demo code](https://github.com/Green-Sky/imgui_entt_entity_editor_demo)).
+  * [SgOgl](https://github.com/stwe/SgOgl): a game engine library for OpenGL
+    developed for educational purposes.
+  * [Lumos](https://github.com/jmorton06/Lumos): game engine written in C++
+    using OpenGL and Vulkan.
+  * [Silvanus](https://github.com/hobbyistmaker/silvanus): Silvanus Fusion 360
+    Box Generator.
+  * [Lina Engine](https://github.com/inanevin/LinaEngine): an open-source,
+    modular, tiny and fast C++ game engine, aimed to develop 3D desktop games.
+  * [Spike](https://github.com/FahimFuad/Spike): a powerful game engine which
+    can run on a toaster.
+  * [Helena Framework](https://github.com/NIKEA-SOFT/HelenaFramework): a modern
+    framework in C++17 for backend development.
+  * [Unity/EnTT](https://github.com/TongTungGiang/unity-entt): tech demo of a
+    native simulation layer using `EnTT` and `Unity` as a rendering engine.
+  * [OverEngine](https://github.com/OverShifted/OverEngine): an over-engineered
+    game engine.
+  * [Electro](https://github.com/Electro-Technologies/Electro): high performance
+    3D game engine with a high emphasis on rendering.
+  * [Kawaii](https://github.com/Mathieu-Lala/Kawaii_Engine): a modern data
+    oriented game engine.
+  * [Becketron](https://github.com/Doctor-Foxling/Becketron): a game engine
+    written mostly in C++.
+  * [Spatial Engine](https://github.com/luizgabriel/Spatial.Engine): a
+    cross-platform engine created on top of google's filament rendering engine.
+  * [Kaguya](https://github.com/KaiH0717/Kaguya): D3D12 Rendering Engine.
+  * [OpenAWE](https://github.com/OpenAWE-Project/OpenAWE): open implementation
+    of the Alan Wake Engine.
+  * [Nazara Engine](https://github.com/DigitalPulseSoftware/NazaraEngine): fast,
+    cross-platform, object-oriented API to help in daily developer life.
+
+* Articles, videos and blog posts:
+  * [Some posts](https://skypjack.github.io/tags/#entt) on my personal
+    [blog](https://skypjack.github.io/) are about `EnTT`, for those who want to
+    know **more** on this project.
+  * [Game Engine series](https://www.youtube.com/c/TheChernoProject/videos) by
+    [The Cherno](https://github.com/TheCherno) (not only about `EnTT` but also
+    on the use of an ECS in general):
+    - [Intro to EnTT](https://www.youtube.com/watch?v=D4hz0wEB978).
+    - [Entities and Components](https://www.youtube.com/watch?v=-B1iu4QJTUc).
+    - [The ENTITY Class](https://www.youtube.com/watch?v=GfSzeAcsBb0).
+    - [Camera Systems](https://www.youtube.com/watch?v=ubZn7BlrnTU).
+    - [Scene Camera](https://www.youtube.com/watch?v=UKVFRRufKzo).
+    - [Native Scripting](https://www.youtube.com/watch?v=iIUhg88MK5M).
+    - [Native Scripting (now with virtual functions!)](https://www.youtube.com/watch?v=1cHEcrIn8IQ).
+    - [Scene Hierarchy Panel](https://www.youtube.com/watch?v=wziDnE8guvI).
+    - [Properties Panel](https://www.youtube.com/watch?v=NBpB0qscF3E).
+    - [Camera Component UI](https://www.youtube.com/watch?v=RIMt_6agUiU).
+    - [Drawing Component UI](https://www.youtube.com/watch?v=u3yq8s3KuSE).
+    - [Transform Component UI](https://www.youtube.com/watch?v=8JqcXYbzPJc).
+    - [Adding/Removing Entities and Components UI](https://www.youtube.com/watch?v=PsyGmsIgp9M).
+    - [Saving and Loading Scenes](https://www.youtube.com/watch?v=IEiOP7Y-Mbc).
+    - ... And so on.
+      [Check out](https://www.youtube.com/channel/UCQ-W1KE9EYfdxhL6S4twUNw) the
+      _Game Engine Series_ by The Cherno for more videos.
+  * [Space Battle: Huge edition](http://victor.madtriangles.com/code%20experiment/2018/06/11/post-ecs-battle-huge.html):
+    huge space battle built entirely from scratch.
+  * [Space Battle](https://github.com/vblanco20-1/ECS_SpaceBattle): huge space
+    battle built on `UE4`.
+  * [Experimenting with ECS in UE4](http://victor.madtriangles.com/code%20experiment/2018/03/25/post-ue4-ecs-battle.html):
+    interesting article about `UE4` and `EnTT`.
+  * [Implementing ECS architecture in UE4](https://forums.unrealengine.com/development-discussion/c-gameplay-programming/1449913-implementing-ecs-architecture-in-ue4-giant-space-battle):
+    giant space battle.
+  * [Conan Adventures (SFML and EnTT in C++)](https://leinnan.github.io/blog/conan-adventuressfml-and-entt-in-c.html):
+    create projects in modern C++ using `SFML`, `EnTT`, `Conan` and `CMake`.
+  * [Adding EnTT ECS to Chrysalis](https://www.tauradius.com/post/adding-an-ecs-to-chrysalis/):
+    a blog entry (and its 
+    [follow-up](https://www.tauradius.com/post/chrysalis-update-2020-08-02/)) 
+    about the integration of `EnTT` into `Chrysalis`, an action RPG SDK for
+    CRYENGINE games.
+  * [Creating Minecraft in One Week with C++ and Vulkan](https://vazgriz.com/189/creating-minecraft-in-one-week-with-c-and-vulkan/):
+    a crack at recreating Minecraft in one week using a custom C++ engine and
+    Vulkan ([code included](https://github.com/vazgriz/VoxelGame)).
+  * [Ability Creator](https://www.erichildebrand.net/blog/ability-creator-project-retrospect):
+    project retrospect by [Eric Hildebrand](https://www.erichildebrand.net/).
+  * [EnTT Entity Component System Gaming Library](https://gamefromscratch.com/entt-entity-component-system-gaming-library/):
+    `EnTT` on GameFromScratch.com.
+
+* Any Other Business:
+  * [ArcGIS Runtime SDKs](https://developers.arcgis.com/arcgis-runtime/) by
+    [Esri](https://www.esri.com/): they use `EnTT` for the internal ECS and the
+    cross platform C++ rendering engine. The SDKs are utilized by a lot of
+    enterprise custom apps, as well as by Esri for its own public applications
+    such as
+    [Explorer](https://play.google.com/store/apps/details?id=com.esri.explorer),
+    [Collector](https://play.google.com/store/apps/details?id=com.esri.arcgis.collector)
+    and
+    [Navigator](https://play.google.com/store/apps/details?id=com.esri.navigator).
+  * [FASTSUITE Edition 2](https://www.fastsuite.com/en_EN/fastsuite/fastsuite-edition-2.html)
+    by [Cenit](http://www.cenit.com/en_EN/about-us/overview.html): they use
+    `EnTT` to drive their simulation, that is, the communication between robot
+    controller emulator and renderer.
+  * [Ragdoll](https://ragdolldynamics.com/): real-time physics for Autodesk Maya
+    2020.
+  * [Project Lagrange](https://github.com/adobe/lagrange): a robust geometry
+    processing library by [Adobe](https://github.com/adobe).
+  * [AtomicDEX](https://github.com/KomodoPlatform/atomicDEX-Desktop): a secure
+    wallet and non-custodial decentralized exchange rolled into one application.
+  * [Apparently](https://www.linkedin.com/in/skypjack/)
+    [NIO](https://www.nio.io/): there was a collaboration to make some changes
+    to `EnTT`, at the time used for internal projects.
+  * [Apparently](https://www.linkedin.com/jobs/view/architekt-c%2B%2B-at-tieto-1219512333/)
+    [Tieto](https://www.tieto.com/): they published a job post where `EnTT` was
+    listed on their software stack.
+  * [Sequentity](https://github.com/alanjfs/sequentity): A MIDI-like
+    sequencer/tracker for C++ and `ImGui` (with `Magnum` and `EnTT`).
+  * [EnTT meets Sol2](https://github.com/skaarj1989/entt-meets-sol2): freely
+    available examples of how to combine `EnTT` and `Sol2`.
+  * [Godot meets EnTT](https://github.com/portaloffreedom/godot_entt_example/):
+    a simple example on how to use `EnTT` within
+    [`Godot`](https://godotengine.org/).
+  * [Godot and GameNetworkingSockets meet EnTT](https://github.com/portaloffreedom/godot_entt_net_example):
+    a simple example on how to use `EnTT` and
+    [`GameNetworkingSockets`](https://github.com/ValveSoftware/GameNetworkingSockets)
+    within [`Godot`](https://godotengine.org/).
+  * [MatchOneEntt](https://github.com/mhaemmerle/MatchOneEntt): port of
+    [Match One](https://github.com/sschmid/Match-One) for `Entitas-CSharp`.
+  * GitHub contains also
+    [many other examples](https://github.com/search?o=desc&q=%22skypjack%2Fentt%22&s=indexed&type=Code)
+    of use of `EnTT` from which to take inspiration if interested.
+
+If you know of other resources out there that are about `EnTT`, feel free to
+open an issue or a PR and I'll be glad to add them to this page.

docs/md/locator.md

@@ -0,0 +1,56 @@
+# Crash Course: service locator
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [Service locator](#service-locator)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+Usually service locators are tightly bound to the services they expose and it's
+hard to define a general purpose solution.<br/>
+This tiny class tries to fill the gap and to get rid of the burden of defining a
+different specific locator for each application.
+
+# Service locator
+
+The service locator API tries to mimic that of `std::optional` and adds some
+extra functionalities on top of it such as allocator support.<br/>
+There are a couple of functions to set up a service, namely `emplace` and
+`allocate_emplace`:
+
+```cpp
+entt::locator<interface>::emplace<service>(argument);
+entt::locator<interface>::allocate_emplace<service>(allocator, argument);
+```
+
+The difference is that the latter expects an allocator as the first argument and
+uses it to allocate the service itself.<br/>
+Once a service has been set up, it's retrieved using the value function:
+
+```cpp
+interface &service = entt::locator<interface>::value();
+```
+
+Since the service may not be set (and therefore this function may result in an
+undefined behavior), the `has_value` and `value_or` functions are also available
+to test a service locator and to get a fallback service in case there is none:
+
+```cpp
+if(entt::locator<interface>::has_value()) {
+    // ...
+}
+
+interface &service = entt::locator<interface>::value_or<fallback_impl>(argument);
+```
+
+All arguments are used only if necessary, that is, if a service doesn't already
+exist and therefore the fallback service is constructed and returned. In all
+other cases, they are discarded.<br/>
+Finally, to reset a service, use the `reset` function.

docs/md/meta.md

@@ -0,0 +1,978 @@
+# Crash Course: runtime reflection system
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [Names and identifiers](#names-and-identifiers)
+* [Reflection in a nutshell](#reflection-in-a-nutshell)
+  * [Any to the rescue](#any-to-the-rescue)
+  * [Enjoy the runtime](#enjoy-the-runtime)
+  * [Container support](#container-support)
+  * [Pointer-like types](#pointer-like-types)
+  * [Template information](#template-information)
+  * [Automatic conversions](#automatic-conversions)
+  * [Implicitly generated default constructor](#implicitly-generated-default-constructor)
+  * [Policies: the more, the less](#policies-the-more-the-less)
+  * [Named constants and enums](#named-constants-and-enums)
+  * [Properties and meta objects](#properties-and-meta-objects)
+  * [Unregister types](#unregister-types)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+Reflection (or rather, its lack) is a trending topic in the C++ world and a tool
+that can unlock a lot of interesting feature in the specific case of `EnTT`. I
+looked for a third-party library that met my needs on the subject, but I always
+came across some details that I didn't like: macros, being intrusive, too many
+allocations, and so on.<br/>
+I finally decided to write a built-in, non-intrusive and macro-free runtime
+reflection system for `EnTT`. Maybe I didn't do better than others or maybe yes,
+time will tell me, but at least I can model this tool around the library to
+which it belongs and not the opposite.
+
+# Names and identifiers
+
+The meta system doesn't force users to rely on the tools provided by the library
+when it comes to working with names and identifiers. It does this by offering an
+API that works with opaque identifiers that may or may not be generated by means
+of a hashed string.<br/>
+This means that users can assign any type of identifier to the meta objects, as
+long as they are numeric. It doesn't matter if they are generated at runtime, at
+compile-time or with custom functions.
+
+That being said, the examples in the following sections are all based on the
+`hashed_string` class as provided by this library. Therefore, where an
+identifier is required, it's likely that an user defined literal is used as
+follows:
+
+```cpp
+auto factory = entt::meta<my_type>().type("reflected_type"_hs);
+```
+
+For what it's worth, this is likely completely equivalent to:
+
+```cpp
+auto factory = entt::meta<my_type>().type(42);
+```
+
+Obviously, human-readable identifiers are more convenient to use and highly
+recommended.
+
+# Reflection in a nutshell
+
+Reflection always starts from real types (users cannot reflect imaginary types
+and it would not make much sense, we wouldn't be talking about reflection
+anymore).<br/>
+To create a meta node, the library provides the `meta` function that accepts a
+type to reflect as a template parameter:
+
+```cpp
+auto factory = entt::meta<my_type>();
+```
+
+This isn't enough to _export_ the given type and make it visible though.<br/>
+The returned value is a factory object to use to continue building the meta
+type. In order to make the type _visible_, users can assign it an identifier:
+
+```cpp
+auto factory = entt::meta<my_type>().type("reflected_type"_hs);
+```
+
+Or use the default one, that is, the built-in identifier for the given type:
+
+```cpp
+auto factory = entt::meta<my_type>().type();
+```
+
+Identifiers are important because users can retrieve meta types at runtime by
+searching for them by _name_ other than by type.<br/>
+On the other hand, there are cases in which users can be interested in adding
+features to a reflected type so that the reflection system can use it correctly
+under the hood, but they don't want to also make the type _searchable_. In this
+case, it's sufficient not to invoke `type`.
+
+A factory is such that all its member functions return the factory itself or a
+decorated version of it. This object can be used to add the following:
+
+* _Constructors_. Actual constructors can be assigned to a reflected type by
+  specifying their list of arguments. Free functions (namely, factories) can be
+  used as well, as long as the return type is the expected one. From a client's
+  point of view, nothing changes if a constructor is a free function or an
+  actual constructor.<br/>
+  Use the `ctor` member function for this purpose:
+
+  ```cpp
+  entt::meta<my_type>().ctor<int, char>().ctor<&factory>();
+  ```
+
+* _Destructors_. Free functions and member functions can be used as destructors
+  of reflected types. The purpose is to give users the ability to free up
+  resources that require special treatment before an object is actually
+  destroyed.<br/>
+  Use the `dtor` member function for this purpose:
+
+  ```cpp
+  entt::meta<my_type>().dtor<&destroy>();
+  ```
+
+  A function should neither delete nor explicitly invoke the destructor of a
+  given instance.
+
+* _Data members_. Both real data members of the underlying type and static and
+  global variables, as well as constants of any kind, can be attached to a meta
+  type. From the point of view of the client, all the variables associated with
+  the reflected type will appear as if they were part of the type itself.<br/>
+  Use the `data` member function for this purpose:
+
+  ```cpp
+  entt::meta<my_type>()
+      .data<&my_type::static_variable>("static"_hs)
+      .data<&my_type::data_member>("member"_hs)
+      .data<&global_variable>("global"_hs);
+  ```
+
+  The function requires as an argument the identifier to give to the meta data
+  once created. Users can then access meta data at runtime by searching for them
+  by _name_.<br/>
+  Data members can also be defined by means of a setter and getter pair. Setters
+  and getters can be either free functions, class members or a mix of them, as
+  long as they respect the required signatures. This approach is also convenient
+  to create a read-only variable from a non-const data member:
+
+  ```cpp
+  entt::meta<my_type>().data<nullptr, &my_type::data_member>("member"_hs);
+  ```
+
+  Multiple setters are also supported by means of a `value_list` object:
+
+  ```cpp
+  entt::meta<my_type>().data<entt::value_list<&from_int, &from_string>, &my_type::data_member>("member"_hs);
+  ```
+
+  Refer to the inline documentation for all the details.
+
+* _Member functions_. Both real member functions of the underlying type and free
+  functions can be attached to a meta type. From the point of view of the
+  client, all the functions associated with the reflected type will appear as if
+  they were part of the type itself.<br/>
+  Use the `func` member function for this purpose:
+
+  ```cpp
+  entt::meta<my_type>()
+      .func<&my_type::static_function>("static"_hs)
+      .func<&my_type::member_function>("member"_hs)
+      .func<&free_function>("free"_hs);
+  ```
+
+  The function requires as an argument the identifier to give to the meta
+  function once created. Users can then access meta functions at runtime by
+  searching for them by _name_.<br/>
+  Overloading of meta functions is supported. Overloaded functions are resolved
+  at runtime by the reflection system according to the types of the arguments.
+
+* _Base classes_. A base class is such that the underlying type is actually
+  derived from it. In this case, the reflection system tracks the relationship
+  and allows for implicit casts at runtime when required.<br/>
+  Use the `base` member function for this purpose:
+
+  ```cpp
+  entt::meta<derived_type>().base<base_type>();
+  ```
+
+  From now on, wherever a `base_type` is required, an instance of `derived_type`
+  will also be accepted.
+
+* _Conversion functions_. Actual types can be converted, this is a fact. Just
+  think of the relationship between a `double` and an `int` to see it. Similar
+  to bases, conversion functions allow users to define conversions that will be
+  implicitly performed by the reflection system when required.<br/>
+  Use the `conv` member function for this purpose:
+
+  ```cpp
+  entt::meta<double>().conv<int>();
+  ```
+
+That's all, everything users need to create meta types and enjoy the reflection
+system. At first glance it may not seem that much, but users usually learn to
+appreciate it over time.<br/>
+Also, do not forget what these few lines hide under the hood: a built-in,
+non-intrusive and macro-free system for reflection in C++. Features that are
+definitely worth the price, at least for me.
+
+## Any to the rescue
+
+The reflection system offers a kind of _extended version_ of the `entt::any`
+class (see the core module for more details).<br/>
+The purpose is to add some feature on top of those already present, so as to
+integrate it with the meta type system without having to duplicate the code.
+
+The API is very similar to that of the `any` type. The class `meta_any` _wraps_
+many of the feature to infer a meta node, before forwarding some or all of the
+arguments to the underlying storage.<br/>
+Among the few relevant differences, `meta_any` adds support for containers and
+pointer-like types (see the following sections for more details), while `any`
+does not.<br/>
+Similar to `any`, this class can also be used to create _aliases_ for unmanaged
+objects either with `forward_as_meta` or using the `std::in_place_type<T &>`
+disambiguation tag, as well as from an existing object by means of the `as_ref`
+member function. However, unlike `any`, `meta_any` treats an empty instance and
+one initialized with `void` differently:
+
+```cpp
+entt::meta_any empty{};
+entt::meta_any other{std::in_place_type<void>};
+```
+
+While `any` considers both as empty, `meta_any` treats objects initialized with
+`void` as if they were _valid_ ones. This allows to differentiate between failed
+function calls and function calls that are successful but return nothing.<br/>
+Finally, the member functions `try_cast`, `cast` and `allow_cast` are used to
+cast the underlying object to a given type (either a reference or a value type)
+or to _convert_ a `meta_any` in such a way that a cast becomes viable for the
+resulting object. There is in fact no `any_cast` equivalent for `meta_any`.
+
+## Enjoy the runtime
+
+Once the web of reflected types has been constructed, it's a matter of using it
+at runtime where required.<br/>
+All this has the great merit that the reflection system stands in fact as a
+non-intrusive tool for the runtime, unlike the vast majority of the things
+offered by this library and closely linked to the compile-time.
+
+To search for a reflected type there are a few options:
+
+```cpp
+// direct access to a reflected type
+auto by_type = entt::resolve<my_type>();
+
+// look up a reflected type by identifier
+auto by_id = entt::resolve("reflected_type"_hs);
+
+// look up a reflected type by type info
+auto by_type_id = entt::resolve(entt::type_id<my_type>());
+```
+
+There exits also an overload of the `resolve` function to use to iterate all the
+reflected types at once. It returns an iterable object that can be used in a
+range-for loop:
+
+```cpp
+for(auto type: entt::resolve()) {
+    // ...
+}
+```
+
+In all cases, the returned value is an instance of `meta_type`. This kind of
+objects offer an API to know their _runtime identifiers_, to iterate all the
+meta objects associated with them and even to build instances of the underlying
+type.<br/>
+Refer to the inline documentation for all the details.
+
+The meta objects that compose a meta type are accessed in the following ways:
+
+* _Meta data_. They are accessed by _name_:
+
+  ```cpp
+  auto data = entt::resolve<my_type>().data("member"_hs);
+  ```
+
+  The returned type is `meta_data` and may be invalid if there is no meta data
+  object associated with the given identifier.<br/>
+  A meta data object offers an API to query the underlying type (for example, to
+  know if it's a const or a static one), to get the meta type of the variable
+  and to set or get the contained value.
+
+* _Meta functions_. They are accessed by _name_:
+
+  ```cpp
+  auto func = entt::resolve<my_type>().func("member"_hs);
+  ```
+
+  The returned type is `meta_func` and may be invalid if there is no meta
+  function object associated with the given identifier.<br/>
+  A meta function object offers an API to query the underlying type (for
+  example, to know if it's a const or a static function), to know the number of
+  arguments, the meta return type and the meta types of the parameters. In
+  addition, a meta function object can be used to invoke the underlying function
+  and then get the return value in the form of a `meta_any` object.
+
+* _Meta bases_. They are accessed through the _name_ of the base types:
+
+  ```cpp
+  auto base = entt::resolve<derived_type>().base("base"_hs);
+  ```
+
+  The returned type is `meta_type` and may be invalid if there is no meta base
+  object associated with the given identifier.
+
+All the objects thus obtained as well as the meta types can be explicitly
+converted to a boolean value to check if they are valid:
+
+```cpp
+if(auto func = entt::resolve<my_type>().func("member"_hs); func) {
+    // ...
+}
+```
+
+Furthermore, all them are also returned by specific overloads that provide the
+caller with iterable ranges of top-level elements. As an example:
+
+```cpp
+for(auto data: entt::resolve<my_type>().data()) {
+    // ...
+}
+```
+
+A meta type can be used to `construct` actual instances of the underlying
+type.<br/>
+In particular, the `construct` member function accepts a variable number of
+arguments and searches for a match. It then returns a `meta_any` object that may
+or may not be initialized, depending on whether a suitable constructor has been
+found or not.
+
+There is no object that wraps the destructor of a meta type nor a `destroy`
+member function in its API. Destructors are invoked implicitly by `meta_any`
+behind the scenes and users have not to deal with them explicitly. Furthermore,
+they have no name, cannot be searched and wouldn't have member functions to
+expose anyway.<br/>
+Similarly, conversion functions aren't directly accessible. They are used
+internally by `meta_any` and the meta objects when needed.
+
+Meta types and meta objects in general contain much more than what is said: a
+plethora of functions in addition to those listed whose purposes and uses go
+unfortunately beyond the scope of this document.<br/>
+I invite anyone interested in the subject to look at the code, experiment and
+read the inline documentation to get the best out of this powerful tool.
+
+## Container support
+
+The runtime reflection system also supports containers of all types.<br/>
+Moreover, _containers_ doesn't necessarily mean those offered by the C++
+standard library. In fact, user defined data structures can also work with the
+meta system in many cases.
+
+To make a container be recognized as such by the meta system, users are required
+to provide specializations for either the `meta_sequence_container_traits` class
+or the `meta_associative_container_traits` class, according with the actual type
+of the container.<br/>
+`EnTT` already exports the specializations for some common classes. In
+particular:
+
+* `std::vector` and `std::array` are exported as _sequence containers_.
+* `std::map`, `std::set` and their unordered counterparts are exported as
+  _associative containers_.
+
+It's important to include the header file `container.hpp` to make these
+specializations available to the compiler when needed.<br/>
+The same file also contains many examples for the users that are interested in
+making their own containers available to the meta system.
+
+When a specialization of the `meta_sequence_container_traits` class exists, the
+meta system treats the wrapped type as a sequence container. In a similar way,
+a type is treated as an associative container if a specialization of the
+`meta_associative_container_traits` class is found for it.<br/>
+Proxy objects are returned by dedicated members of the `meta_any` class. The
+following is a deliberately verbose example of how users can access a proxy
+object for a sequence container:
+
+```cpp
+std::vector<int> vec{1, 2, 3};
+entt::meta_any any = entt::forward_as_meta(vec);
+
+if(any.type().is_sequence_container()) {
+    if(auto view = any.as_sequence_container(); view) {
+        // ...
+    }
+}
+```
+
+The method to use to get a proxy object for associative containers is
+`as_associative_container` instead.<br/>
+It goes without saying that it's not necessary to perform a double check.
+Instead, it's sufficient to query the meta type or verify that the proxy object
+is valid. In fact, proxies are contextually convertible to bool to know if they
+are valid. For example, invalid proxies are returned when the wrapped object
+isn't a container.<br/>
+In all cases, users aren't expected to _reflect_ containers explicitly. It's
+sufficient to assign a container for which a specialization of the traits
+classes exists to a `meta_any` object to be able to get its proxy object.
+
+The interface of the `meta_sequence_container` proxy object is the same for all
+types of sequence containers, although the available features differ from case
+to case. In particular:
+
+* The `value_type` member function returns the meta type of the elements.
+
+* The `size` member function returns the number of elements in the container as
+  an unsigned integer value:
+
+  ```cpp
+  const auto size = view.size();
+  ```
+
+* The `resize` member function allows to resize the wrapped container and
+  returns true in case of success:
+
+  ```cpp
+  const bool ok = view.resize(3u);
+  ```
+
+  For example, it's not possible to resize fixed size containers.
+
+* The `clear` member function allows to clear the wrapped container and returns
+  true in case of success:
+
+  ```cpp
+  const bool ok = view.clear();
+  ```
+
+  For example, it's not possible to clear fixed size containers.
+
+* The `begin` and `end` member functions return opaque iterators that can be
+  used to iterate the container directly:
+
+  ```cpp
+  for(entt::meta_any element: view) {
+      // ...
+  }
+  ```
+
+  In all cases, given an underlying container of type `C`, the returned element
+  contains an object of type `C::value_type` which therefore depends on the
+  actual container.<br/>
+  All meta iterators are input iterators and don't offer an indirection operator
+  on purpose.
+
+* The `insert` member function can be used to add elements to the container. It
+  accepts a meta iterator and the element to insert:
+
+  ```cpp
+  auto last = view.end();
+  // appends an integer to the container
+  view.insert(last, 42);
+  ```
+
+  This function returns a meta iterator pointing to the inserted element and a
+  boolean value to indicate whether the operation was successful or not. Note
+  that a call to `insert` may silently fail in case of fixed size containers or
+  whether the arguments aren't at least convertible to the required types.<br/>
+  Since the meta iterators are contextually convertible to bool, users can rely
+  on them to know if the operation has failed on the actual container or
+  upstream, for example for an argument conversion problem.
+
+* The `erase` member function can be used to remove elements from the container.
+  It accepts a meta iterator to the element to remove:
+
+  ```cpp
+  auto first = view.begin();
+  // removes the first element from the container
+  view.erase(first);
+  ```
+
+  This function returns a meta iterator following the last removed element and a
+  boolean value to indicate whether the operation was successful or not. Note
+  that a call to `erase` may silently fail in case of fixed size containers.
+
+* The `operator[]` can be used to access elements in a container. It accepts a
+  single argument, that is the position of the element to return:
+
+  ```cpp
+  for(std::size_t pos{}, last = view.size(); pos < last; ++pos) {
+      entt::meta_any value = view[pos];
+      // ...
+  }
+  ```
+
+  The function returns instances of `meta_any` that directly refer to the actual
+  elements. Modifying the returned object will then directly modify the element
+  inside the container.
+
+Similarly, also the interface of the `meta_associative_container` proxy object
+is the same for all types of associative containers. However, there are some
+differences in behavior in the case of key-only containers. In particular:
+
+* The `key_only` member function returns true if the wrapped container is a
+  key-only one.
+
+* The `key_type` member function returns the meta type of the keys.
+
+* The `mapped_type` member function returns an invalid meta type for key-only
+  containers and the meta type of the mapped values for all other types of
+  containers.
+
+* The `value_type` member function returns the meta type of the elements.<br/>
+  For example, it returns the meta type of `int` for `std::set<int>` while it
+  returns the meta type of `std::pair<const int, char>` for
+  `std::map<int, char>`.
+
+* The `size` member function returns the number of elements in the container as
+  an unsigned integer value:
+
+  ```cpp
+  const auto size = view.size();
+  ```
+
+* The `clear` member function allows to clear the wrapped container and returns
+  true in case of success:
+
+  ```cpp
+  const bool ok = view.clear();
+  ```
+
+* The `begin` and `end` member functions return opaque iterators that can be
+  used to iterate the container directly:
+
+  ```cpp
+  for(std::pair<entt::meta_any, entt::meta_any> element: view) {
+      // ...
+  }
+  ```
+
+  In all cases, given an underlying container of type `C`, the returned element
+  is a key-value pair where the key has type `C::key_type` and the value has
+  type `C::mapped_type`. Since key-only containers don't have a mapped type,
+  their _value_ is nothing more than an invalid `meta_any` object.<br/>
+  All meta iterators are input iterators and don't offer an indirection operator
+  on purpose.
+
+  While the accessed key is usually constant in the associative containers and
+  is therefore returned by copy, the value (if any) is wrapped by an instance of
+  `meta_any` that directly refers to the actual element. Modifying it will then
+  directly modify the element inside the container.
+
+* The `insert` member function can be used to add elements to the container. It
+  accepts two arguments, respectively the key and the value to be inserted:
+
+  ```cpp
+  auto last = view.end();
+  // appends an integer to the container
+  view.insert(last.handle(), 42, 'c');
+  ```
+
+  This function returns a boolean value to indicate whether the operation was
+  successful or not. Note that a call to `insert` may fail when the arguments
+  aren't at least convertible to the required types.
+
+* The `erase` member function can be used to remove elements from the container.
+  It accepts a single argument, that is the key to be removed:
+
+  ```cpp
+  view.erase(42);
+  ```
+
+  This function returns a boolean value to indicate whether the operation was
+  successful or not. Note that a call to `erase` may fail when the argument
+  isn't at least convertible to the required type.
+
+* The `operator[]` can be used to access elements in a container. It accepts a
+  single argument, that is the key of the element to return:
+
+  ```cpp
+  entt::meta_any value = view[42];
+  ```
+
+  The function returns instances of `meta_any` that directly refer to the actual
+  elements. Modifying the returned object will then directly modify the element
+  inside the container.
+
+Container support is minimal but likely sufficient to satisfy all needs.
+
+## Pointer-like types
+
+As with containers, it's also possible to communicate to the meta system which
+types to consider _pointers_. This will allow to dereference instances of
+`meta_any`, thus obtaining light _references_ to the pointed objects that are
+also correctly associated with their meta types.<br/>
+To make the meta system recognize a type as _pointer-like_, users can specialize
+the `is_meta_pointer_like` class. `EnTT` already exports the specializations for
+some common classes. In particular:
+
+* All types of raw pointers.
+* `std::unique_ptr` and `std::shared_ptr`.
+
+It's important to include the header file `pointer.hpp` to make these
+specializations available to the compiler when needed.<br/>
+The same file also contains many examples for the users that are interested in
+making their own pointer-like types available to the meta system.
+
+When a type is recognized as a pointer-like one by the meta system, it's
+possible to dereference the instances of `meta_any` that contain these objects.
+The following is a deliberately verbose example to show how to use this feature:
+
+```cpp
+int value = 42;
+// meta type equivalent to that of int *
+entt::meta_any any{&value};
+
+if(any.type().is_pointer_like()) {
+    // meta type equivalent to that of int
+    if(entt::meta_any ref = *any; ref) {
+        // ...
+    }
+}
+```
+
+Of course, it's not necessary to perform a double check. Instead, it's enough to
+query the meta type or verify that the returned object is valid. For example,
+invalid instances are returned when the wrapped object isn't a pointer-like
+type.<br/>
+Note that dereferencing a pointer-like object returns an instance of `meta_any`
+which refers to the pointed object and allows users to modify it directly
+(unless the returned element is const, of course).
+
+In general, _dereferencing_ a pointer-like type boils down to a `*ptr`. However,
+`EnTT` also supports classes that don't offer an `operator*`. In particular:
+
+* It's possible to exploit a solution based on ADL lookup by offering a function
+  (also a template one) named `dereference_meta_pointer_like`:
+
+  ```cpp
+  template<typename Type>
+  Type & dereference_meta_pointer_like(const custom_pointer_type<Type> &ptr) {
+      return ptr.deref();
+  }
+  ```
+
+* When not in control of the type's namespace, it's possible to inject into the
+  `entt` namespace a specialization of the `adl_meta_pointer_like` class
+  template to bypass the adl lookup as a whole:
+
+  ```cpp
+  template<typename Type>
+  struct entt::adl_meta_pointer_like<custom_pointer_type<Type>> {
+      static decltype(auto) dereference(const custom_pointer_type<Type> &ptr) {
+          return ptr.deref();
+      }
+  };
+  ```
+
+In all other cases, that is, when dereferencing a pointer works as expected and
+regardless of the pointed type, no user intervention is required.
+
+## Template information
+
+Meta types also provide a minimal set of information about the nature of the
+original type in case it's a class template.<br/>
+By default, this works out of the box and requires no user action. However, it's
+important to include the header file `template.hpp` to make these information
+available to the compiler when needed.
+
+Meta template information are easily found:
+
+```cpp
+// this method returns true if the type is recognized as a class template specialization
+if(auto type = entt::resolve<std::shared_ptr<my_type>>(); type.is_template_specialization()) {
+    // meta type of the class template conveniently wrapped by entt::meta_class_template_tag
+    auto class_type = type.template_type();
+
+    // number of template arguments
+    std::size_t arity = type.template_arity();
+
+    // meta type of the i-th argument
+    auto arg_type = type.template_arg(0u);
+}
+```
+
+Typically, when template information for a type are required, what the library
+provides is sufficient. However, there are some cases where a user may want more
+details or a different set of information.<br/>
+Consider the case of a class template that is meant to wrap function types:
+
+```cpp
+template<typename>
+struct function_type;
+
+template<typename Ret, typename... Args>
+struct function_type<Ret(Args...)> {};
+```
+
+In this case, rather than the function type, the user might want the return type
+and unpacked arguments as if they were different template parameters for the
+original class template.<br/>
+To achieve this, users must enter the library internals and provide their own
+specialization for the class template `entt::meta_template_traits`, such as:
+
+```cpp
+template<typename Ret, typename... Args>
+struct entt::meta_template_traits<function_type<Ret(Args...)>> {
+    using class_type = meta_class_template_tag<function_type>;
+    using args_type = type_list<Ret, Args...>;
+};
+```
+
+The reflection system doesn't verify the accuracy of the information nor infer a
+correspondence between real types and meta types.<br/>
+Therefore, the specialization will be used as is and the information it contains
+will be associated with the appropriate type when required.
+
+## Automatic conversions
+
+In C++, there are a number of conversions allowed between arithmetic types that
+make it convenient to work with this kind of data.<br/>
+If this were to be translated into explicit registrations with the reflection
+system, it would result in a long series of instructions such as the following:
+
+```cpp
+entt::meta<int>()
+    .conv<bool>()
+    .conv<char>()
+    // ...
+    .conv<double>();
+```
+
+Repeated for each type eligible to undergo this type of conversions. This is
+both error prone and repetitive.<br/>
+Similarly, the language allows users to silently convert unscoped enums to their
+underlying types and offers what it takes to do the same for scoped enums. It
+would result in the following if it were to be done explicitly:
+
+```cpp
+entt::meta<my_enum>()
+    .conv<std::underlying_type_t<my_enum>>();
+```
+
+Fortunately, all of this can also be avoided. `EnTT` offers implicit support for
+these types of conversions:
+
+```cpp
+entt::meta_any any{42};
+any.allow_cast<double>();
+double value = any.cast<double>();
+```
+
+With no need for registration, the conversion takes place automatically under
+the hood. The same goes for a call to `allow_cast` involving a meta type:
+
+```cpp
+entt::meta_type type = entt::resolve<int>();
+entt::meta_any any{my_enum::a_value};
+any.allow_cast(type);
+int value = any.cast<int>();
+```
+
+This should make working with arithmetic types and scoped or unscoped enums as
+easy as it is in C++.<br/>
+It's also worth noting that it's still possible to set up conversion functions
+manually and these will always be preferred over the automatic ones.
+
+## Implicitly generated default constructor
+
+In many cases, it's useful to be able to create objects of default constructible
+types through the reflection system, while not having to explicitly register the
+meta type or the default constructor.<br/>
+For example, in the case of primitive types like `int` or `char`, but not just
+them.
+
+For this reason and only for default constructible types, default constructors
+are automatically defined and associated with their meta types, whether they are
+explicitly or implicitly generated.<br/>
+Therefore, this is all is needed to construct an integer from its meta type:
+
+```cpp
+entt::resolve<int>().construct();
+```
+
+Where the meta type can be for example the one returned from a meta container,
+useful for building keys without knowing or having to register the actual types.
+
+In all cases, when users register default constructors, they are preferred both
+during searches and when the `construct` member function is invoked.
+
+## Policies: the more, the less
+
+Policies are a kind of compile-time directives that can be used when registering
+reflection information.<br/>
+Their purpose is to require slightly different behavior than the default in some
+specific cases. For example, when reading a given data member, its value is
+returned wrapped in a `meta_any` object which, by default, makes a copy of it.
+For large objects or if the caller wants to access the original instance, this
+behavior isn't desirable. Policies are there to offer a solution to this and
+other problems.
+
+There are a few alternatives available at the moment:
+
+* The _as-is_ policy, associated with the type `entt::as_is_t`.<br/>
+  This is the default policy. In general, it should never be used explicitly,
+  since it's implicitly selected if no other policy is specified.<br/>
+  In this case, the return values of the functions as well as the properties
+  exposed as data members are always returned by copy in a dedicated wrapper and
+  therefore associated with their original meta types.
+
+* The _as-void_ policy, associated with the type `entt::as_void_t`.<br/>
+  Its purpose is to discard the return value of a meta object, whatever it is,
+  thus making it appear as if its type were `void`:
+
+  ```cpp
+  entt::meta<my_type>().func<&my_type::member_function, entt::as_void_t>("member"_hs);
+  ```
+
+  If the use with functions is obvious, it must be said that it's also possible
+  to use this policy with constructors and data members. In the first case, the
+  constructor will be invoked but the returned wrapper will actually be empty.
+  In the second case, instead, the property will not be accessible for reading.
+
+* The _as-ref_ and _as-cref_ policies, associated with the types
+  `entt::as_ref_t` and `entt::as_cref_t`.<br/>
+  They allow to build wrappers that act as references to unmanaged objects.
+  Accessing the object contained in the wrapper for which the _reference_ was
+  requested will make it possible to directly access the instance used to
+  initialize the wrapper itself:
+
+  ```cpp
+  entt::meta<my_type>().data<&my_type::data_member, entt::as_ref_t>("member"_hs);
+  ```
+
+  These policies work with constructors (for example, when objects are taken
+  from an external container rather than created on demand), data members and
+  functions in general.<br/>
+  If on the one hand `as_cref_t` always forces the return type to be const,
+  `as_ref_t` _adapts_ to the constness of the passed object and to that of the
+  return type if any.
+
+Some uses are rather trivial, but it's useful to note that there are some less
+obvious corner cases that can in turn be solved with the use of policies.
+
+## Named constants and enums
+
+A special mention should be made for constant values and enums. It wouldn't be
+necessary, but it will help distracted readers.
+
+As mentioned, the `data` member function can be used to reflect constants of any
+type among the other things.<br/>
+This allows users to create meta types for enums that will work exactly like any
+other meta type built from a class. Similarly, arithmetic types can be enriched
+with constants of special meaning where required.<br/>
+Personally, I find it very useful not to export what is the difference between
+enums and classes in C++ directly in the space of the reflected types.
+
+All the values thus exported will appear to users as if they were constant data
+members of the reflected types.
+
+Exporting constant values or elements from an enum is as simple as ever:
+
+```cpp
+entt::meta<my_enum>()
+    .data<my_enum::a_value>("a_value"_hs)
+    .data<my_enum::another_value>("another_value"_hs);
+
+entt::meta<int>().data<2048>("max_int"_hs);
+```
+
+It goes without saying that accessing them is trivial as well. It's a matter of
+doing the following, as with any other data member of a meta type:
+
+```cpp
+auto value = entt::resolve<my_enum>().data("a_value"_hs).get({}).cast<my_enum>();
+auto max = entt::resolve<int>().data("max_int"_hs).get({}).cast<int>();
+```
+
+As a side note, remember that all this happens behind the scenes without any
+allocation because of the small object optimization performed by the `meta_any`
+class.
+
+## Properties and meta objects
+
+Sometimes (for example, when it comes to creating an editor) it might be useful
+to attach properties to the meta objects created. Fortunately, this is possible
+for most of them.<br/>
+For the meta objects that support properties, the member functions of the
+factory used for registering them will return a decorated version of the factory
+itself. The latter can be used to attach properties to the last created meta
+object.<br/>
+Apparently, it's more difficult to say than to do:
+
+```cpp
+entt::meta<my_type>().type("reflected_type"_hs).prop("tooltip"_hs, "message");
+```
+
+Properties are always in the key/value form. There are no restrictions on the
+type of the key or value, as long as they are copy constructible objects.<br/>
+Multiple formats are supported when it comes to defining a property:
+
+* Properties as key/value pairs:
+
+  ```cpp
+  entt::meta<my_type>().type("reflected_type"_hs).prop("tooltip"_hs, "message");
+  ```
+
+* Properties as `std::pair`s:
+
+  ```cpp
+  entt::meta<my_type>().type("reflected_type"_hs).prop(std::make_pair("tooltip"_hs, "message"));
+  ```
+
+* Key only properties:
+
+  ```cpp
+  entt::meta<my_type>().type("reflected_type"_hs).prop(my_enum::key_only);
+  ```
+
+* Properties as `std::tuple`s:
+
+  ```cpp
+  entt::meta<my_type>().type("reflected_type"_hs).prop(std::make_tuple(std::make_pair("tooltip"_hs, "message"), my_enum::key_only));
+  ```
+
+  A tuple contains one or more properties. All of them are treated individually.
+
+Note that it's not possible to invoke `prop` multiple times for the same meta
+object and trying to do that will result in a compilation error.<br/>
+However, the `props` function is available to associate several properties at
+once. In this case, properties in the key/value form aren't allowed, since they
+would be interpreted as two different properties rather than a single one.
+
+The meta objects for which properties are supported are currently meta types,
+meta data and meta functions.<br/>
+These types also offer a couple of member functions named `prop` to iterate all
+properties at once or to search a specific property by key:
+
+```cpp
+// iterate all properties of a meta type
+for(auto prop: entt::resolve<my_type>().prop()) {
+    // ...
+}
+
+// search for a given property by name
+auto prop = entt::resolve<my_type>().prop("tooltip"_hs);
+```
+
+Meta properties are objects having a fairly poor interface, all in all. They
+only provide the `key` and the `value` member functions to be used to retrieve
+the key and the value contained in the form of `meta_any` objects, respectively.
+
+## Unregister types
+
+A type registered with the reflection system can also be unregistered. This
+means unregistering all its data members, member functions, conversion functions
+and so on. However, base classes aren't unregistered as well, since they don't
+necessarily depend on it. Similarly, implicitly generated types (as an example,
+the meta types implicitly generated for function parameters when needed) aren't
+unregistered.<br/>
+Roughly speaking, unregistering a type means disconnecting all associated meta
+objects from it and making its identifier no longer visible. The underlying node
+will remain available though, as if it were implicitly generated:
+
+```cpp
+entt::meta_reset<my_type>();
+```
+
+It's also possible to reset types by their unique identifiers if required:
+
+```cpp
+entt::meta_reset("my_type"_hs);
+```
+
+Finally, there exists a non-template overload of the `meta_reset` function that
+doesn't accept argument and resets all searchable types (that is, all types that
+were assigned an unique identifier):
+
+```cpp
+entt::meta_reset();
+```
+
+All types can be re-registered later with a completely different name and form.

docs/md/poly.md

@@ -0,0 +1,359 @@
+# Crash Course: poly
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+  * [Other libraries](#other-libraries)
+* [Concept and implementation](#concept-and-implementation)
+  * [Deduced interface](#deduced-interface)
+  * [Defined interface](#defined-interface)
+  * [Fulfill a concept](#fulfill-a-concept)
+* [Inheritance](#inheritance)
+* [Static polymorphism in the wild](#static-polymorphism-in-the-wild)
+* [Storage size and alignment requirement](#storage-size-and-alignment-requirement)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+Static polymorphism is a very powerful tool in C++, albeit sometimes cumbersome
+to obtain.<br/>
+This module aims to make it simple and easy to use.
+
+The library allows to define _concepts_ as interfaces to fulfill with concrete
+classes without having to inherit from a common base.<br/>
+This is, among others, one of the advantages of static polymorphism in general
+and of a generic wrapper like that offered by the `poly` class template in
+particular.<br/>
+What users get is an object that can be passed around as such and not through a
+reference or a pointer, as happens when it comes to working with dynamic
+polymorphism.
+
+Since the `poly` class template makes use of `entt::any` internally, it also
+supports most of its feature. Among the most important, the possibility to
+create aliases to existing and thus unmanaged objects. This allows users to
+exploit the static polymorphism while maintaining ownership of objects.<br/>
+Likewise, the `poly` class template also benefits from the small buffer
+optimization offered by the `entt::any` class and therefore minimizes the number
+of allocations, avoiding them altogether where possible.
+
+## Other libraries
+
+There are some very interesting libraries regarding static polymorphism.<br/>
+Among all, the two that I prefer are:
+
+* [`dyno`](https://github.com/ldionne/dyno): runtime polymorphism done right.
+* [`Poly`](https://github.com/facebook/folly/blob/master/folly/docs/Poly.md):
+  a class template that makes it easy to define a type-erasing polymorphic
+  object wrapper.
+
+The former is admittedly an experimental library, with many interesting ideas.
+I've some doubts about the usefulness of some feature in real world projects,
+but perhaps my lack of experience comes into play here. In my opinion, its only
+flaw is the API which I find slightly more cumbersome than other solutions.<br/>
+The latter was undoubtedly a source of inspiration for this module, although I
+opted for different choices in the implementation of both the final API and some
+feature.
+
+Either way, the authors are gurus of the C++ community, people I only have to
+learn from.
+
+# Concept and implementation
+
+The first thing to do to create a _type-erasing polymorphic object wrapper_ (to
+use the terminology introduced by Eric Niebler) is to define a _concept_ that
+types will have to adhere to.<br/>
+For this purpose, the library offers a single class that supports both deduced
+and fully defined interfaces. Although having interfaces deduced automatically
+is convenient and allows users to write less code in most cases, this has some
+limitations and it's therefore useful to be able to get around the deduction by
+providing a custom definition for the static virtual table.
+
+Once the interface is defined, it will be sufficient to provide a generic
+implementation to fulfill the concept.<br/>
+Also in this case, the library allows customizations based on types or families
+of types, so as to be able to go beyond the generic case where necessary.
+
+## Deduced interface
+
+This is how a concept with a deduced interface is introduced:
+
+```cpp
+struct Drawable: entt::type_list<> {
+    template<typename Base>
+    struct type: Base {
+        void draw() { this->template invoke<0>(*this); }
+    };
+
+    // ...
+};
+```
+
+It's recognizable by the fact that it inherits from an empty type list.<br/>
+Functions can also be const, accept any number of parameters and return a type
+other than `void`:
+
+```cpp
+struct Drawable: entt::type_list<> {
+    template<typename Base>
+    struct type: Base {
+        bool draw(int pt) const { return this->template invoke<0>(*this, pt); }
+    };
+
+    // ...
+};
+```
+
+In this case, all parameters must be passed to `invoke` after the reference to
+`this` and the return value is whatever the internal call returns.<br/>
+As for `invoke`, this is a name that is injected into the _concept_ through
+`Base`, from which one must necessarily inherit. Since it's also a dependent
+name, the `this-> template` form is unfortunately necessary due to the rules of
+the language. However, there exists also an alternative that goes through an
+external call:
+
+```cpp
+struct Drawable: entt::type_list<> {
+    template<typename Base>
+    struct type: Base {
+        void draw() const { entt::poly_call<0>(*this); }
+    };
+
+    // ...
+};
+```
+
+Once the _concept_ is defined, users must provide a generic implementation of it
+in order to tell the system how any type can satisfy its requirements. This is
+done via an alias template within the concept itself.<br/>
+The index passed as a template parameter to either `invoke` or `poly_call`
+refers to how this alias is defined.
+
+## Defined interface
+
+A fully defined concept is no different to one for which the interface is
+deduced, with the only difference that the list of types is not empty this time:
+
+```cpp
+struct Drawable: entt::type_list<void()> {
+    template<typename Base>
+    struct type: Base {
+        void draw() { entt::poly_call<0>(*this); }
+    };
+
+    // ...
+};
+```
+
+Again, parameters and return values other than `void` are allowed. Also, the
+function type must be const when the method to bind to it is const:
+
+```cpp
+struct Drawable: entt::type_list<bool(int) const> {
+    template<typename Base>
+    struct type: Base {
+        bool draw(int pt) const { return entt::poly_call<0>(*this, pt); }
+    };
+
+    // ...
+};
+```
+
+Why should a user fully define a concept if the function types are the same as
+the deduced ones?<br>
+Because, in fact, this is exactly the limitation that can be worked around by
+manually defining the static virtual table.
+
+When things are deduced, there is an implicit constraint.<br/>
+If the concept exposes a member function called `draw` with function type
+`void()`, a concept can be satisfied:
+
+* Either by a class that exposes a member function with the same name and the
+  same signature.
+
+* Or through a lambda that makes use of existing member functions from the
+  interface itself.
+
+In other words, it's not possible to make use of functions not belonging to the
+interface, even if they are present in the types that fulfill the concept.<br/>
+Similarly, it's not possible to deduce a function in the static virtual table
+with a function type different from that of the associated member function in
+the interface itself.
+
+Explicitly defining a static virtual table suppresses the deduction step and
+allows maximum flexibility when providing the implementation for a concept.
+
+## Fulfill a concept
+
+The `impl` alias template of a concept is used to define how it's fulfilled:
+
+```cpp
+struct Drawable: entt::type_list<> {
+    // ...
+
+    template<typename Type>
+    using impl = entt::value_list<&Type::draw>;
+};
+```
+
+In this case, it's stated that the `draw` method of a generic type will be
+enough to satisfy the requirements of the `Drawable` concept.<br/>
+Both member functions and free functions are supported to fulfill concepts:
+
+```cpp
+template<typename Type>
+void print(Type &self) { self.print(); }
+
+struct Drawable: entt::type_list<void()> {
+    // ...
+
+    template<typename Type>
+    using impl = entt::value_list<&print<Type>>;
+};
+```
+
+Likewise, as long as the parameter types and return type support conversions to
+and from those of the function type referenced in the static virtual table, the
+actual implementation may differ in its function type since it's erased
+internally.<br/>
+Moreover, the `self` parameter isn't strictly required by the system and can be
+left out for free functions if not required.
+
+Refer to the inline documentation for more details.
+
+# Inheritance
+
+_Concept inheritance_ is straightforward due to how poly looks like in `EnTT`.
+Therefore, it's quite easy to build hierarchies of concepts if necessary.<br/>
+The only constraint is that all concepts in a hierarchy must belong to the same
+_family_, that is, they must be either all deduced or all defined.
+
+For a deduced concept, inheritance is achieved in a few steps:
+
+```cpp
+struct DrawableAndErasable: entt::type_list<> {
+    template<typename Base>
+    struct type: typename Drawable::template type<Base> {
+        static constexpr auto base = std::tuple_size_v<typename entt::poly_vtable<Drawable>::type>;
+        void erase() { entt::poly_call<base + 0>(*this); }
+    };
+
+    template<typename Type>
+    using impl = entt::value_list_cat_t<
+        typename Drawable::impl<Type>,
+        entt::value_list<&Type::erase>
+    >;
+};
+```
+
+The static virtual table is empty and must remain so.<br/>
+On the other hand, `type` no longer inherits from `Base` and instead forwards
+its template parameter to the type exposed by the _base class_. Internally, the
+size of the static virtual table of the base class is used as an offset for the
+local indexes.<br/>
+Finally, by means of the `value_list_cat_t` utility, the implementation consists
+in appending the new functions to the previous list.
+
+As for a defined concept instead, also the list of types must be extended, in a
+similar way to what is shown for the implementation of the above concept.<br/>
+To do this, it's useful to declare a function that allows to convert a _concept_
+into its underlying `type_list` object:
+
+```cpp
+template<typename... Type>
+entt::type_list<Type...> as_type_list(const entt::type_list<Type...> &);
+```
+
+The definition isn't strictly required, since the function will only be used
+through a `decltype` as it follows:
+
+```cpp
+struct DrawableAndErasable: entt::type_list_cat_t<
+    decltype(as_type_list(std::declval<Drawable>())),
+    entt::type_list<void()>
+> {
+    // ...
+};
+```
+
+Similar to above, `type_list_cat_t` is used to concatenate the underlying static
+virtual table with the new function types.<br/>
+Everything else is the same as already shown instead.
+
+# Static polymorphism in the wild
+
+Once the _concept_ and implementation have been introduced, it will be possible
+to use the `poly` class template to contain instances that meet the
+requirements:
+
+```cpp
+using drawable = entt::poly<Drawable>;
+
+struct circle {
+    void draw() { /* ... */ }
+};
+
+struct square {
+    void draw() { /* ... */ }
+};
+
+// ...
+
+drawable instance{circle{}};
+instance->draw();
+
+instance = square{};
+instance->draw();
+```
+
+The `poly` class template offers a wide range of constructors, from the default
+one (which will return an uninitialized `poly` object) to the copy and move
+constructors, as well as the ability to create objects in-place.<br/>
+Among others, there is also a constructor that allows users to wrap unmanaged
+objects in a `poly` instance (either const or non-const ones):
+
+```cpp
+circle shape;
+drawable instance{std::in_place_type<circle &>, shape};
+```
+
+Similarly, it's possible to create non-owning copies of `poly` from an existing
+object:
+
+```cpp
+drawable other = instance.as_ref();
+```
+
+In both cases, although the interface of the `poly` object doesn't change, it
+won't construct any element or take care of destroying the referenced objects.
+
+Note also how the underlying concept is accessed via a call to `operator->` and
+not directly as `instance.draw()`.<br/>
+This allows users to decouple the API of the wrapper from that of the concept.
+Therefore, where `instance.data()` will invoke the `data` member function of the
+poly object, `instance->data()` will map directly to the functionality exposed
+by the underlying concept.
+
+# Storage size and alignment requirement
+
+Under the hood, the `poly` class template makes use of `entt::any`. Therefore,
+it can take advantage of the possibility of defining at compile-time the size of
+the storage suitable for the small buffer optimization as well as the alignment
+requirements:
+
+```cpp
+entt::basic_poly<Drawable, sizeof(double[4]), alignof(double[4])>
+```
+
+The default size is `sizeof(double[2])`, which seems like a good compromise
+between a buffer that is too large and one unable to hold anything larger than
+an integer. The alignment requirement is optional instead and by default such
+that it's the most stringent (the largest) for any object whose size is at most
+equal to the one provided.<br/>
+It's worth noting that providing a size of 0 (which is an accepted value in all
+respects) will force the system to dynamically allocate the contained objects in
+all cases.

docs/md/process.md

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

docs/md/reference.md

@@ -0,0 +1,75 @@
+# Similar projects
+
+There are many projects similar to `EnTT`, both open source and not.<br/>
+Some even borrowed some ideas from this library and expressed them in different
+languages.<br/>
+Others developed different architectures from scratch and therefore offer
+alternative solutions with their pros and cons.
+
+Below an incomplete list of those that I've come across so far.<br/>
+If some terms or designs aren't clear, I recommend referring to the
+[_ECS Back and Forth_](https://skypjack.github.io/tags/#ecs) series for all the
+details.
+
+I hope this list can grow much more in the future:
+
+* C:
+  * [destral_ecs](https://github.com/roig/destral_ecs): a single-file ECS based
+    on sparse sets.
+  * [Diana](https://github.com/discoloda/Diana): an ECS that uses sparse sets to
+    keep track of entities in systems.
+  * [Flecs](https://github.com/SanderMertens/flecs): a multithreaded archetype
+    ECS based on semi-contiguous arrays rather than chunks.
+  * [lent](https://github.com/nem0/lent): the Donald Trump of the ECS libraries.
+
+* C++:
+  * [decs](https://github.com/vblanco20-1/decs): a chunk based archetype ECS.
+  * [ecst](https://github.com/SuperV1234/ecst): a multithreaded compile-time
+    ECS that uses sparse sets to keep track of entities in systems.
+  * [EntityX](https://github.com/alecthomas/entityx): a bitset based ECS that
+    uses a single large matrix of components indexed with entities.
+  * [Gaia-ECS](https://github.com/richardbiely/gaia-ecs): a chunk based
+    archetype ECS.
+  * [Polypropylene](https://github.com/pmbittner/Polypropylene): a hybrid
+    solution between an ECS and dynamic mixins.
+
+* C#
+  * [Entitas](https://github.com/sschmid/Entitas-CSharp): the ECS framework for
+    C# and Unity, where _reactive systems_ were invented.
+  * [LeoECS](https://github.com/Leopotam/ecs): simple lightweight C# Entity
+    Component System framework.
+  * [Svelto.ECS](https://github.com/sebas77/Svelto.ECS): a very interesting
+    platform agnostic and table based ECS framework.
+
+* Go:
+  * [gecs](https://github.com/tutumagi/gecs): a sparse sets based ECS inspired 
+    by `EnTT`.
+
+* Javascript:
+  * [\@javelin/ecs](https://github.com/3mcd/javelin/tree/master/packages/ecs):
+    an archetype ECS in TypeScript.
+  * [ecsy](https://github.com/MozillaReality/ecsy): I haven't had the time to
+    investigate the underlying design of `ecsy` but it looks cool anyway.
+
+* Perl:
+  * [Game::Entities](https://gitlab.com/jjatria/perl-game-entities): a simple
+    entity registry for ECS designs inspired by `EnTT`.
+
+* Raku:
+  * [Game::Entities](https://gitlab.com/jjatria/raku-game-entities): a simple
+    entity registry for ECS designs inspired by `EnTT`.
+
+* Rust:
+  * [Legion](https://github.com/TomGillen/legion): a chunk based archetype ECS.
+  * [Shipyard](https://github.com/leudz/shipyard): it borrows some ideas from
+    `EnTT` and offers a sparse sets based ECS with grouping functionalities.
+  * [Sparsey](https://github.com/LechintanTudor/sparsey): sparse set based ECS
+    written in Rust.
+  * [Specs](https://github.com/amethyst/specs): a parallel ECS based mainly on
+    hierarchical bitsets that allows different types of storage as needed.
+
+* Zig
+  * [zig-ecs](https://github.com/prime31/zig-ecs): a _zig-ification_ of `EnTT`.
+
+If you know of other resources out there that can be of interest for the reader,
+feel free to open an issue or a PR and I'll be glad to add them to this page.

docs/md/resource.md

@@ -0,0 +1,192 @@
+# Crash Course: resource management
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [The resource, the loader and the cache](#the-resource-the-loader-and-the-cache)
+  * [Resource handle](#resource-handle)
+  * [Loaders](#loader)
+  * [The cache class](#the-cache)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+Resource management is usually one of the most critical part of a software like
+a game. Solutions are often tuned to the particular application. There exist
+several approaches and all of them are perfectly fine as long as they fit the
+requirements of the piece of software in which they are used.<br/>
+Examples are loading everything on start, loading on request, predictive
+loading, and so on.
+
+`EnTT` doesn't pretend to offer a _one-fits-all_ solution for the different
+cases.<br/>
+Instead, the library offers a minimal, general purpose resource cache that might
+be useful in many cases.
+
+# The resource, the loader and the cache
+
+Resource, loader and cache are the three main actors for the purpose.<br/>
+The _resource_ is an image, an audio, a video or any other type:
+
+```cpp
+struct my_resource { const int value; };
+```
+
+The _loader_ is a callable type the aim of which is to load a specific resource:
+
+```cpp
+struct my_loader final {
+    using result_type = std::shared_ptr<my_resource>;
+
+    result_type operator()(int value) const {
+        // ...
+        return std::make_shared<my_resource>(value);
+    }
+};
+```
+
+Its function operator can accept any arguments and should return a value of the
+declared result type (`std::shared_ptr<my_resource>` in the example).<br/>
+A loader can also overload its function call operator to make it possible to
+construct the same or another resource from different lists of arguments.
+
+Finally, a cache is a specialization of a class template tailored to a specific
+resource and (optionally) a loader:
+
+```cpp
+using my_cache = entt::resource_cache<my_resource, my_loader>;
+
+// ...
+
+my_cache cache{};
+```
+
+The cache is meant to be used to create different caches for different types of
+resources and to manage each one independently in the most appropriate way.<br/>
+As a (very) trivial example, audio tracks can survive in most of the scenes of
+an application while meshes can be associated with a single scene only, then
+discarded when a player leaves it.
+
+## Resource handle
+
+Resources aren't returned directly to the caller. Instead, they are wrapped in a
+_resource handle_ identified by the `entt::resource` class template.<br/>
+For those who know the _flyweight design pattern_ already, that's exactly what
+it is. To all others, this is the time to brush up on some notions instead.
+
+A shared pointer could have been used as a resource handle. In fact, the default
+handle mostly maps the interface of its standard counterpart and only adds a few
+things to it.<br/>
+However, the handle in `EnTT` is designed as a standalone class template named
+`resource`. It boils down to the fact that specializing a class in the standard
+is often undefined behavior while having the ability to specialize the handle
+for one, more or all resource types could help over time.
+
+## Loaders
+
+A loader is a class that is responsible for _loading_ the resources.<br/>
+By default, it's just a callable object which forwards its arguments to the
+resource itself. That is, a _passthrough type_. All the work is demanded to the
+constructor(s) of the resource itself.<br/>
+Loaders also are fully customizable as expected.
+
+A custom loader is a class with at least one function call operator and a member
+type named `result_type`.<br/>
+The loader isn't required to return a resource handle. As long as `return_type`
+is suitable for constructing a handle, that's fine.
+
+When using the default handle, it expects a resource type which is convertible
+to or suitable for constructing an `std::shared_ptr<Type>` (where `Type` is the
+actual resource type).<br/>
+In other terms, the loader should return shared pointers to the given resource
+type. However, it isn't mandatory. Users can easily get around this constraint
+by specializing both the handle and the loader.
+
+A cache forwards all its arguments to the loader if required. This means that
+loaders can also support tag dispatching to offer different loading policies:
+
+```cpp
+struct my_loader {
+    using result_type = std::shared_ptr<my_resource>;
+
+    struct from_disk_tag{};
+    struct from_network_tag{};
+
+    template<typename Args>
+    result_type operator()(from_disk_tag, Args&&... args) {
+        // ...
+        return std::make_shared<my_resource>(std::forward<Args>(args)...);
+    }
+
+    template<typename Args>
+    result_type operator()(from_network_tag, Args&&... args) {
+        // ...
+        return std::make_shared<my_resource>(std::forward<Args>(args)...);
+    }
+}
+```
+
+This makes the whole loading logic quite flexible and easy to extend over time.
+
+## The cache class
+
+The cache is the class that is asked to _connect the dots_.<br/>
+It loads the resources, store them aside and returns handles as needed:
+
+```cpp
+entt::resource_cache<my_resource, my_loader> cache{};
+```
+
+Under the hood, a cache is nothing more than a map where the key value has type
+`entt::id_type` while the mapped value is whatever type its loader returns.<br/>
+For this reason, it offers most of the functionality a user would expect from a
+map, such as `empty` or `size` and so on. Similarly, it's an iterable type that
+also supports indexing by resource id:
+
+```cpp
+for(entt::resource<my_resource> curr: cache) {
+    // ...
+}
+
+if(entt::resource<my_resource> res = cache["resource/id"_hs]; res) {
+    // ...
+}
+```
+
+Please, refer to the inline documentation for all the details about the other
+functions (for example `contains` or `erase`).
+
+Set aside the part of the API that this class shares with a map, it also adds
+something on top of it in order to address the most common requirements of a
+resource cache.<br/>
+In particular, it doesn't have an `emplace` member function which is replaced by
+`load` and `force_load` instead (where the former loads a new resource only if
+not present while the second triggers a forced loading in any case):
+
+```cpp
+auto ret = cache.load("resource/id"_hs);
+
+// true only if the resource was not already present
+const bool loaded = ret.second;
+
+// takes the resource handle pointed to by the returned iterator
+entt::resource<my_resource> res = *ret.first;
+```
+
+Note that the hashed string is used for convenience in the example above.<br/>
+Resource identifiers are nothing more than integral values. Therefore, plain
+numbers as well as non-class enum value are accepted.
+
+Moreover, it's worth mentioning that both the iterators of a cache and its
+indexing operators return resource handles rather than instances of the mapped
+type.<br/>
+Since the cache has no control over the loader and a resource isn't required to
+also be convertible to bool, these handles can be invalid. This usually means an
+error in the user logic but it may also be an _expected_ event.<br/>
+It's therefore recommended to verify handles validity with a check in debug (for
+example, when loading) or an appropriate logic in retail.

docs/md/signal.md

@@ -0,0 +1,597 @@
+# Crash Course: events, signals and everything in between
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Introduction](#introduction)
+* [Delegate](#delegate)
+  * [Runtime arguments](#runtime-arguments)
+  * [Lambda support](#lambda-support)
+* [Signals](#signals)
+* [Event dispatcher](#event-dispatcher)
+  * [Named queues](#named-queues)
+* [Event emitter](#event-emitter)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+# Introduction
+
+Signals are usually a core part of games and software architectures in
+general.<br/>
+Roughly speaking, they help to decouple the various parts of a system while
+allowing them to communicate with each other somehow.
+
+The so called _modern C++_ comes with a tool that can be useful in these terms,
+the `std::function`. As an example, it can be used to create delegates.<br/>
+However, there is no guarantee that an `std::function` does not perform
+allocations under the hood and this could be problematic sometimes. Furthermore,
+it solves a problem but may not adapt well to other requirements that may arise
+from time to time.
+
+In case that the flexibility and power of an `std::function` isn't required or
+if the price to pay for them is too high,` EnTT` offers a complete set of
+lightweight classes to solve the same and many other problems.
+
+# Delegate
+
+A delegate can be used as a general purpose invoker with no memory overhead for
+free functions and members provided along with an instance on which to invoke
+them.<br/>
+It doesn't claim to be a drop-in replacement for an `std::function`, so don't
+expect to use it whenever an `std::function` fits well. That said, it's most
+likely even a better fit than an `std::function` in a lot of cases, so expect to
+use it quite a lot anyway.
+
+The interface is trivial. It offers a default constructor to create empty
+delegates:
+
+```cpp
+entt::delegate<int(int)> delegate{};
+```
+
+All what is needed to create an instance is to specify the type of the function
+the delegate will _contain_, that is the signature of the free function or the
+member one wants to assign to it.
+
+Attempting to use an empty delegate by invoking its function call operator
+results in undefined behavior or most likely a crash. Before to use a delegate,
+it must be initialized.<br/>
+There exists a bunch of overloads of the `connect` member function to do that.
+As an example of use:
+
+```cpp
+int f(int i) { return i; }
+
+struct my_struct {
+    int f(const int &i) const { return i; }
+};
+
+// bind a free function to the delegate
+delegate.connect<&f>();
+
+// bind a member function to the delegate
+my_struct instance;
+delegate.connect<&my_struct::f>(instance);
+```
+
+The delegate class accepts also data members, if needed. In this case, the
+function type of the delegate is such that the parameter list is empty and the
+value of the data member is at least convertible to the return type.
+
+Free functions having type equivalent to `void(T &, args...)` are accepted as
+well. The first argument `T &` is considered a payload and the function will
+receive it back every time it's invoked. In other terms, this works just fine
+with the above definition:
+
+```cpp
+void g(const char &c, int i) { /* ... */ }
+const char c = 'c';
+
+delegate.connect<&g>(c);
+delegate(42);
+```
+
+The function `g` will be invoked with a reference to `c` and `42`. However, the
+function type of the delegate is still `void(int)`. This is also the signature
+of its function call operator.
+
+Another interesting aspect of the delegate class is that it accepts also
+functions with a list of parameters that is shorter than that of the function
+type used to specialize the delegate itself.<br/>
+The following code is therefore perfectly valid:
+
+```cpp
+void g() { /* ... */ }
+delegate.connect<&g>();
+delegate(42);
+```
+
+Where the function type of the delegate is `void(int)` as above. It goes without
+saying that the extra arguments are silently discarded internally.<br/>
+This is a nice-to-have feature in a lot of cases, as an example when the
+`delegate` class is used as a building block of a signal-slot system.
+
+To create and initialize a delegate at once, there are a few specialized
+constructors. Because of the rules of the language, the listener is provided by
+means of the `entt::connect_arg` variable template:
+
+```cpp
+entt::delegate<int(int)> func{entt::connect_arg<&f>};
+```
+
+Aside `connect`, a `disconnect` counterpart isn't provided. Instead, there
+exists a `reset` member function to use to clear a delegate.<br/>
+To know if a delegate is empty, it can be used explicitly in every conditional
+statement:
+
+```cpp
+if(delegate) {
+    // ...
+}
+```
+
+Finally, to invoke a delegate, the function call operator is the way to go as
+already shown in the examples above:
+
+```cpp
+auto ret = delegate(42);
+```
+
+In all cases, the listeners don't have to strictly follow the signature of the
+delegate. As long as a listener can be invoked with the given arguments to yield
+a result that is convertible to the given result type, everything works just
+fine.
+
+As a side note, members of classes may or may not be associated with instances.
+If they are not, the first argument of the function type must be that of the
+class on which the members operate and an instance of this class must obviously
+be passed when invoking the delegate:
+
+```cpp
+entt::delegate<void(my_struct &, int)> delegate;
+delegate.connect<&my_struct::f>();
+
+my_struct instance;
+delegate(instance, 42);
+```
+
+In this case, it's not possible to deduce the function type since the first
+argument doesn't necessarily have to be a reference (for example, it can be a
+pointer, as well as a const reference).<br/>
+Therefore, the function type must be declared explicitly for unbound members.
+
+## Runtime arguments
+
+The `delegate` class is meant to be used primarily with template arguments.
+However, as a consequence of its design, it can also offer minimal support for
+runtime arguments.<br/>
+When used in this modality, some feature aren't supported though. In particular:
+
+* Curried functions aren't accepted.
+* Functions with an argument list that differs from that of the delegate aren't
+  supported.
+* Return type and types of arguments **must** coincide with those of the
+  delegate and _being at least convertible_ isn't enough anymore.
+
+Moreover, for a given function type `Ret(Args...)`, the signature of the
+functions connected at runtime must necessarily be `Ret(const void *, Args...)`.
+
+Runtime arguments can be passed both to the constructor of a delegate and to the
+`connect` member function. An optional parameter is also accepted in both cases.
+This argument is used to pass arbitrary user data back and forth as a
+`const void *` upon invocation.<br/>
+To connect a function to a delegate _in the hard way_:
+
+```cpp
+int func(const void *ptr, int i) { return *static_cast<const int *>(ptr) * i; }
+const int value = 42;
+
+// use the constructor ...
+entt::delegate delegate{&func, &value};
+
+// ... or the connect member function
+delegate.connect(&func, &value);
+```
+
+The type of the delegate is deduced from the function if possible. In this case,
+since the first argument is an implementation detail, the deduced function type
+is `int(int)`.<br/>
+Invoking a delegate built in this way follows the same rules as previously
+explained.
+
+## Lambda support
+
+In general, the `delegate` class doesn't fully support lambda functions in all
+their nuances. The reason is pretty simple: a `delegate` isn't a drop-in
+replacement for an `std::function`. Instead, it tries to overcome the problems
+with the latter.<br/>
+That being said, non-capturing lambda functions are supported, even though some
+feature aren't available in this case.
+
+This is a logical consequence of the support for connecting functions at
+runtime. Therefore, lambda functions undergo the same rules and
+limitations.<br/>
+In fact, since non-capturing lambda functions decay to pointers to functions,
+they can be used with a `delegate` as if they were _normal functions_ with
+optional payload:
+
+```cpp
+my_struct instance;
+
+// use the constructor ...
+entt::delegate delegate{+[](const void *ptr, int value) {
+    return static_cast<const my_struct *>(ptr)->f(value);
+}, &instance};
+
+// ... or the connect member function
+delegate.connect([](const void *ptr, int value) {
+    return static_cast<const my_struct *>(ptr)->f(value);
+}, &instance);
+```
+
+As above, the first parameter (`const void *`) isn't part of the function type
+of the delegate and is used to dispatch arbitrary user data back and forth. In
+other terms, the function type of the delegate above is `int(int)`.
+
+# Signals
+
+Signal handlers work with references to classes, function pointers and pointers
+to members. Listeners can be any kind of objects and users are in charge of
+connecting and disconnecting them from a signal to avoid crashes due to
+different lifetimes. On the other side, performance shouldn't be affected that
+much by the presence of such a signal handler.<br/>
+Signals make use of delegates internally and therefore they undergo the same
+rules and offer similar functionalities. It may be a good idea to consult the
+documentation of the `delegate` class for further information.
+
+A signal handler can be used as a private data member without exposing any
+_publish_ functionality to the clients of a class. The basic idea is to impose a
+clear separation between the signal itself and the `sink` class, that is a tool
+to be used to connect and disconnect listeners on the fly.
+
+The API of a signal handler is straightforward. If a collector is supplied to
+the signal when something is published, all the values returned by the listeners
+can be literally _collected_ and used later by the caller. Otherwise, the class
+works just like a plain signal that emits events from time to time.<br/>
+To create instances of signal handlers it is sufficient to provide the type of
+function to which they refer:
+
+```cpp
+entt::sigh<void(int, char)> signal;
+```
+
+Signals offer all the basic functionalities required to know how many listeners
+they contain (`size`) or if they contain at least a listener (`empty`), as well
+as a function to use to swap handlers (`swap`).
+
+Besides them, there are member functions to use both to connect and disconnect
+listeners in all their forms by means of a sink:
+
+```cpp
+void foo(int, char) { /* ... */ }
+
+struct listener {
+    void bar(const int &, char) { /* ... */ }
+};
+
+// ...
+
+entt::sink sink{signal};
+listener instance;
+
+sink.connect<&foo>();
+sink.connect<&listener::bar>(instance);
+
+// ...
+
+// disconnects a free function
+sink.disconnect<&foo>();
+
+// disconnect a member function of an instance
+sink.disconnect<&listener::bar>(instance);
+
+// disconnect all member functions of an instance, if any
+sink.disconnect(instance);
+
+// discards all listeners at once
+sink.disconnect();
+```
+
+As shown above, the listeners don't have to strictly follow the signature of the
+signal. As long as a listener can be invoked with the given arguments to yield a
+result that is convertible to the given return type, everything works just
+fine.<br/>
+It's also possible to connect a listener before other listeners already
+contained by the signal. The `before` function returns a `sink` object correctly
+initialized for the purpose that can be used to connect one or more listeners in
+order and in the desired position:
+
+```cpp
+sink.before<&foo>().connect<&listener::bar>(instance);
+```
+
+In all cases, the `connect` member function returns by default a `connection`
+object to be used as an alternative to break a connection by means of its
+`release` member function. A `scoped_connection` can also be created from a
+connection. In this case, the link is broken automatically as soon as the object
+goes out of scope.
+
+Once listeners are attached (or even if there are no listeners at all), events
+and data in general can be published through a signal by means of the `publish`
+member function:
+
+```cpp
+signal.publish(42, 'c');
+```
+
+To collect data, the `collect` member function should be used instead. Below is
+a minimal example to show how to use it:
+
+```cpp
+int f() { return 0; }
+int g() { return 1; }
+
+// ...
+
+entt::sigh<int()> signal;
+entt::sink sink{signal};
+
+sink.connect<&f>();
+sink.connect<&g>();
+
+std::vector<int> vec{};
+signal.collect([&vec](int value) { vec.push_back(value); });
+
+assert(vec[0] == 0);
+assert(vec[1] == 1);
+```
+
+A collector must expose a function operator that accepts as an argument a type
+to which the return type of the listeners can be converted. Moreover, it can
+optionally return a boolean value that is true to stop collecting data, false
+otherwise. This way one can avoid calling all the listeners in case it isn't
+necessary.<br/>
+Functors can also be used in place of a lambda. Since the collector is copied
+when invoking the `collect` member function, `std::ref` is the way to go in this
+case:
+
+```cpp
+struct my_collector {
+    std::vector<int> vec{};
+
+    bool operator()(int v) {
+        vec.push_back(v);
+        return true;
+    }
+};
+
+// ...
+
+my_collector collector;
+signal.collect(std::ref(collector));
+```
+
+# Event dispatcher
+
+The event dispatcher class allows users to trigger immediate events or to queue
+and publish them all together later.<br/>
+This class lazily instantiates its queues. Therefore, it's not necessary to
+_announce_ the event types in advance:
+
+```cpp
+// define a general purpose dispatcher
+entt::dispatcher dispatcher{};
+```
+
+A listener registered with a dispatcher is such that its type offers one or more
+member functions that take arguments of type `Event &` for any type of event,
+regardless of the return value.<br/>
+These functions are linked directly via `connect` to a _sink_:
+
+```cpp
+struct an_event { int value; };
+struct another_event {};
+
+struct listener {
+    void receive(const an_event &) { /* ... */ }
+    void method(const another_event &) { /* ... */ }
+};
+
+// ...
+
+listener listener;
+dispatcher.sink<an_event>().connect<&listener::receive>(listener);
+dispatcher.sink<another_event>().connect<&listener::method>(listener);
+```
+
+The `disconnect` member function is used to remove one listener at a time or all
+of them at once:
+
+```cpp
+dispatcher.sink<an_event>().disconnect<&listener::receive>(listener);
+dispatcher.sink<another_event>().disconnect(listener);
+```
+
+The `trigger` member function serves the purpose of sending an immediate event
+to all the listeners registered so far:
+
+```cpp
+dispatcher.trigger(an_event{42});
+dispatcher.trigger<another_event>();
+```
+
+Listeners are invoked immediately, order of execution isn't guaranteed. This
+method can be used to push around urgent messages like an _is terminating_
+notification on a mobile app.
+
+On the other hand, the `enqueue` member function queues messages together and
+helps to maintain control over the moment they are sent to listeners:
+
+```cpp
+dispatcher.enqueue<an_event>(42);
+dispatcher.enqueue(another_event{});
+```
+
+Events are stored aside until the `update` member function is invoked:
+
+```cpp
+// emits all the events of the given type at once
+dispatcher.update<an_event>();
+
+// emits all the events queued so far at once
+dispatcher.update();
+```
+
+This way users can embed the dispatcher in a loop and literally dispatch events
+once per tick to their systems.
+
+## Named queues
+
+All queues within a dispatcher are associated by default with an event type and
+then retrieved from it.<br/>
+However, it's possible to create queues with different _names_ (and therefore
+also multiple queues for a single type). In fact, more or less all functions
+also take an additional parameter. As an example:
+
+```cpp
+dispatcher.sink<an_event>("custom"_hs).connect<&listener::receive>(listener);
+```
+
+In this case, the term _name_ is misused as these are actual numeric identifiers
+of type `id_type`.<br/>
+An exception to this rule is the `enqueue` function. There is no additional
+parameter for it but rather a different function:
+
+```cpp
+dispatcher.enqueue_hint<an_event>("custom"_hs, 42);
+```
+
+This is mainly due to the template argument deduction rules and unfortunately
+there is no real (elegant) way to avoid it.
+
+# Event emitter
+
+A general purpose event emitter thought mainly for those cases where it comes to
+working with asynchronous stuff.<br/>
+Originally designed to fit the requirements of
+[`uvw`](https://github.com/skypjack/uvw) (a wrapper for `libuv` written in
+modern C++), it was adapted later to be included in this library.
+
+To create a custom emitter type, derived classes must inherit directly from the
+base class as:
+
+```cpp
+struct my_emitter: emitter<my_emitter> {
+    // ...
+}
+```
+
+The full list of accepted types of events isn't required. Handlers are created
+internally on the fly and thus each type of event is accepted by default.
+
+Whenever an event is published, an emitter provides the listeners with a
+reference to itself along with a reference to the event. Therefore listeners
+have an handy way to work with it without incurring in the need of capturing a
+reference to the emitter itself.<br/>
+In addition, an opaque object is returned each time a connection is established
+between an emitter and a listener, allowing the caller to disconnect them at a
+later time.<br/>
+The opaque object used to handle connections is both movable and copyable. On
+the other side, an event emitter is movable but not copyable by default.
+
+To create new instances of an emitter, no arguments are required:
+
+```cpp
+my_emitter emitter{};
+```
+
+Listeners must be movable and callable objects (free functions, lambdas,
+functors, `std::function`s, whatever) whose function type is compatible with:
+
+```cpp
+void(Event &, my_emitter &)
+```
+
+Where `Event` is the type of event they want to listen.<br/>
+There are two ways to attach a listener to an event emitter that differ
+slightly from each other:
+
+* To register a long-lived listener, use the `on` member function. It is meant
+  to register a listener designed to be invoked more than once for the given
+  event type.<br/>
+  As an example:
+
+  ```cpp
+  auto conn = emitter.on<my_event>([](const my_event &event, my_emitter &emitter) {
+      // ...
+  });
+  ```
+
+  The connection object can be freely discarded. Otherwise, it can be used later
+  to disconnect the listener if required.
+
+* To register a short-lived listener, use the `once` member function. It is
+  meant to register a listener designed to be invoked only once for the given
+  event type. The listener is automatically disconnected after the first
+  invocation.<br/>
+  As an example:
+
+  ```cpp
+  auto conn = emitter.once<my_event>([](const my_event &event, my_emitter &emitter) {
+      // ...
+  });
+  ```
+
+  The connection object can be freely discarded. Otherwise, it can be used later
+  to disconnect the listener if required.
+
+In both cases, the connection object can be used with the `erase` member
+function:
+
+```cpp
+emitter.erase(conn);
+```
+
+There are also two member functions to use either to disconnect all the
+listeners for a given type of event or to clear the emitter:
+
+```cpp
+// removes all the listener for the specific event
+emitter.clear<my_event>();
+
+// removes all the listeners registered so far
+emitter.clear();
+```
+
+To send an event to all the listeners that are interested in it, the `publish`
+member function offers a convenient approach that relieves users from having to
+create the event:
+
+```cpp
+struct my_event { int i; };
+
+// ...
+
+emitter.publish<my_event>(42);
+```
+
+Finally, the `empty` member function tests if there exists at least either a
+listener registered with the event emitter or to a given type of event:
+
+```cpp
+bool empty;
+
+// checks if there is any listener registered for the specific event
+empty = emitter.empty<my_event>();
+
+// checks it there are listeners registered with the event emitter
+empty = emitter.empty();
+```
+
+In general, the event emitter is a handy tool when the derived classes _wrap_
+asynchronous operations, because it introduces a _nice-to-have_ model based on
+events and listeners that kindly hides the complexity behind the scenes. However
+it is not limited to such uses.

docs/md/unreal.md

@@ -0,0 +1,107 @@
+# EnTT and Unreal Engine
+
+<!--
+@cond TURN_OFF_DOXYGEN
+-->
+# Table of Contents
+
+* [Enable Cpp17](#enable-cpp17)
+* [EnTT as a third party module](#entt-as-a-third-party-module)
+* [Include EnTT](#include-entt)
+<!--
+@endcond TURN_OFF_DOXYGEN
+-->
+
+## Enable Cpp17
+
+As of writing (Unreal Engine v4.25), the default C++ standard of Unreal Engine
+is C++14.<br/>
+On the other hand, note that `EnTT` requires C++17 to compile. To enable it, in
+the main module of the project there should be a `<Game Name>.Build.cs` file,
+the constructor of which must contain the following lines:
+
+```cs
+PCHUsage = PCHUsageMode.NoSharedPCHs;
+PrivatePCHHeaderFile = "<PCH filename>.h";
+CppStandard = CppStandardVersion.Cpp17;
+```
+
+Replace `<PCH filename>.h` with the name of the already existing PCH header
+file, if any.<br/>
+In case the project doesn't already contain a file of this type, it's possible
+to create one with the following content:
+
+```cpp
+#pragma once
+#include "CoreMinimal.h"
+```
+
+Remember to remove any old `PCHUsage = <...>` line that was previously there. At
+this point, C++17 support should be in place.<br/>
+Try to compile the project to ensure it works as expected before following
+further steps.
+
+Note that updating a *project* to C++17 doesn't necessarily mean that the IDE in
+use will also start to recognize its syntax.<br/>
+If the plan is to use C++17 in the project too, check the specific instructions
+for the IDE in use.
+
+## EnTT as a third party module
+
+Once this point is reached, the `Source` directory should look like this:
+
+```
+Source
+|  MyGame.Target.cs
+|  MyGameEditor.Target.cs
+|
++---MyGame
+|  |  MyGame.Build.cs
+|  |  MyGame.h (PCH Header file)
+|
+\---ThirdParty
+   \---EnTT
+      |   EnTT.Build.cs
+      |
+      \---entt (GitHub repository content inside)
+```
+
+To make this happen, create the folder `ThirdParty` under `Source` if it doesn't
+exist already. Then, add an `EnTT` folder under `ThirdParty`.<br/>
+Within the latter, create a new file `EnTT.Build.cs` with the following content:
+
+```cs
+using System.IO;
+using UnrealBuildTool;
+
+public class EnTT: ModuleRules {
+    public EnTT(ReadOnlyTargetRules Target) : base(Target) {
+        Type = ModuleType.External;
+        PublicIncludePaths.Add(Path.Combine(ModuleDirectory, "entt", "src", "entt"));
+    }
+}
+```
+
+The last line indicates that the actual files will be found in the directory
+`EnTT/entt/src/entt`.<br/>
+Download the repository for `EnTT` and place it next to `EnTT.Build.cs` or
+update the path above accordingly.
+
+Finally, open the `<Game Name>.Build.cs` file and add `EnTT` as a dependency at
+the end of the list:
+
+```cs
+PublicDependencyModuleNames.AddRange(new[] {
+    "Core", "CoreUObject", "Engine", "InputCore", [...], "EnTT"
+});
+```
+
+Note that some IDEs might require a restart to start recognizing the new module
+for code-highlighting features and such.
+
+## Include EnTT
+
+In any source file of the project, add `#include "entt.hpp"` or any other path
+to the file from `EnTT` to use it.<br/>
+Try to create a registry as `entt::registry registry;` to make sure everything
+compiles fine.

natvis/entt/config.natvis

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+</AutoVisualizer>

natvis/entt/container.natvis

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+	<Type Name="entt::dense_map&lt;*&gt;">
+		<Intrinsic Name="size" Expression="packed.first_base::value.size()"/>
+		<Intrinsic Name="bucket_count" Expression="sparse.first_base::value.size()"/>
+		<DisplayString>{{ size={ size() } }}</DisplayString>
+		<Expand>
+			<Item Name="[capacity]" ExcludeView="simple">packed.first_base::value.capacity()</Item>
+			<Item Name="[bucket_count]" ExcludeView="simple">bucket_count()</Item>
+			<Item Name="[load_factor]" ExcludeView="simple">(float)size() / (float)bucket_count()</Item>
+			<Item Name="[max_load_factor]" ExcludeView="simple">threshold</Item>
+			<IndexListItems>
+				<Size>size()</Size>
+				<ValueNode>packed.first_base::value[$i].element</ValueNode>
+			</IndexListItems>
+		</Expand>
+	</Type>
+	<Type Name="entt::dense_set&lt;*&gt;">
+		<Intrinsic Name="size" Expression="packed.first_base::value.size()"/>
+		<Intrinsic Name="bucket_count" Expression="sparse.first_base::value.size()"/>
+		<DisplayString>{{ size={ size() } }}</DisplayString>
+		<Expand>
+			<Item Name="[capacity]" ExcludeView="simple">packed.first_base::value.capacity()</Item>
+			<Item Name="[bucket_count]" ExcludeView="simple">bucket_count()</Item>
+			<Item Name="[load_factor]" ExcludeView="simple">(float)size() / (float)bucket_count()</Item>
+			<Item Name="[max_load_factor]" ExcludeView="simple">threshold</Item>
+			<IndexListItems>
+				<Size>size()</Size>
+				<ValueNode>packed.first_base::value[$i].second</ValueNode>
+			</IndexListItems>
+		</Expand>
+	</Type>
+</AutoVisualizer>

natvis/entt/core.natvis

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+    <Type Name="entt::basic_any&lt;*&gt;">
+		<DisplayString>{{ type={ info->alias,na }, policy={ mode,en } }}</DisplayString>
+    </Type>
+	<Type Name="entt::compressed_pair&lt;*&gt;">
+		<Intrinsic Name="first" Optional="true" Expression="((first_base*)this)->value"/>
+		<Intrinsic Name="first" Optional="true" Expression="*(first_base::base_type*)this"/>
+		<Intrinsic Name="second" Optional="true" Expression="((second_base*)this)->value"/>
+		<Intrinsic Name="second" Optional="true" Expression="*(second_base::base_type*)this"/>
+		<DisplayString >({ first() }, { second() })</DisplayString>
+		<Expand>
+			<Item Name="[first]">first()</Item>
+			<Item Name="[second]">second()</Item>
+		</Expand>
+	</Type>
+	<Type Name="entt::basic_hashed_string&lt;*&gt;">
+		<DisplayString Condition="base_type::repr != nullptr">{{ hash={ base_type::hash } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<Item Name="[data]">base_type::repr,na</Item>
+			<Item Name="[length]">base_type::length</Item>
+		</Expand>
+	</Type>
+	<Type Name="entt::type_info">
+		<DisplayString Condition="seq != 0u">{{ name={ alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<Item Name="[hash]">identifier</Item>
+			<Item Name="[index]">seq</Item>
+		</Expand>
+	</Type>
+</AutoVisualizer>

natvis/entt/entity.natvis

@@ -0,0 +1,145 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+	<Type Name="entt::basic_registry&lt;*&gt;">
+		<Intrinsic Name="pools_size" Expression="pools.packed.first_base::value.size()"/>
+		<Intrinsic Name="vars_size" Expression="vars.data.packed.first_base::value.size()"/>
+		<Intrinsic Name="to_entity" Expression="*((entity_traits::entity_type *)&amp;entity) &amp; entity_traits::entity_mask">
+			<Parameter Name="entity" Type="entity_traits::value_type &amp;"/>
+		</Intrinsic>
+		<DisplayString>{{ size={ entities.size() } }}</DisplayString>
+		<Expand>
+			<Item IncludeView="simple" Name="[entities]">entities,view(simple)nr</Item>
+			<Synthetic Name="[entities]" ExcludeView="simple">
+				<DisplayString>{ entities.size() }</DisplayString>
+				<Expand>
+					<CustomListItems>
+						<Variable Name="pos" InitialValue="0" />
+						<Variable Name="last" InitialValue="entities.size()"/>
+						<Loop>
+							<Break Condition="pos == last"/>
+							<If Condition="to_entity(entities[pos]) == pos">
+								<Item Name="[{ pos }]">entities[pos]</Item>
+							</If>
+							<Exec>++pos</Exec>
+						</Loop>
+					</CustomListItems>
+				</Expand>
+			</Synthetic>
+			<Synthetic Name="[destroyed]" ExcludeView="simple">
+				<DisplayString>{ to_entity(free_list) != entity_traits::entity_mask }</DisplayString>
+				<Expand>
+					<CustomListItems>
+						<Variable Name="it" InitialValue="to_entity(free_list)" />
+						<Loop>
+							<Break Condition="it == entity_traits::entity_mask"/>
+							<Item Name="[{ it }]">entities[it]</Item>
+							<Exec>it = to_entity(entities[it])</Exec>
+						</Loop>
+					</CustomListItems>
+				</Expand>
+			</Synthetic>
+			<Synthetic Name="[pools]">
+				<DisplayString>{ pools_size() }</DisplayString>
+				<Expand>
+					<IndexListItems ExcludeView="simple">
+						<Size>pools_size()</Size>
+						<ValueNode>*pools.packed.first_base::value[$i].element.second</ValueNode>
+					</IndexListItems>
+					<IndexListItems IncludeView="simple">
+						<Size>pools_size()</Size>
+						<ValueNode>*pools.packed.first_base::value[$i].element.second,view(simple)</ValueNode>
+					</IndexListItems>
+				</Expand>
+			</Synthetic>
+			<Item Name="[groups]" ExcludeView="simple">groups.size()</Item>
+			<Synthetic Name="[vars]">
+				<DisplayString>{ vars_size() }</DisplayString>
+				<Expand>
+					<IndexListItems>
+						<Size>vars_size()</Size>
+						<ValueNode>vars.data.packed.first_base::value[$i].element.second</ValueNode>
+					</IndexListItems>
+				</Expand>
+			</Synthetic>
+		</Expand>
+	</Type>
+	<Type Name="entt::basic_sparse_set&lt;*&gt;">
+		<DisplayString>{{ size={ packed.size() }, type={ info->alias,na } }}</DisplayString>
+		<Expand>
+			<Item Name="[capacity]" ExcludeView="simple">packed.capacity()</Item>
+			<Item Name="[policy]">mode,en</Item>
+			<Synthetic Name="[sparse]">
+				<DisplayString>{ sparse.size() * entity_traits::page_size }</DisplayString>
+				<Expand>
+					<ExpandedItem IncludeView="simple">sparse,view(simple)</ExpandedItem>
+					<CustomListItems ExcludeView="simple">
+						<Variable Name="pos" InitialValue="0"/>
+						<Variable Name="page" InitialValue="0"/>
+						<Variable Name="offset" InitialValue="0"/>
+						<Variable Name="last" InitialValue="sparse.size() * entity_traits::page_size"/>
+						<Loop>
+							<Break Condition="pos == last"/>
+							<Exec>page = pos / entity_traits::page_size</Exec>
+							<Exec>offset = pos &amp; (entity_traits::page_size - 1)</Exec>
+							<If Condition="sparse[page] &amp;&amp; (*((entity_traits::entity_type *)&amp;sparse[page][offset]) &lt; ~entity_traits::entity_mask)">
+								<Item Name="[{ pos }]">*((entity_traits::entity_type *)&amp;sparse[page][offset]) &amp; entity_traits::entity_mask</Item>
+							</If>
+							<Exec>++pos</Exec>
+						</Loop>
+					</CustomListItems>
+				</Expand>
+			</Synthetic>
+			<Synthetic Name="[packed]">
+				<DisplayString>{ packed.size() }</DisplayString>
+				<Expand>
+					<ExpandedItem IncludeView="simple">packed,view(simple)</ExpandedItem>
+					<CustomListItems ExcludeView="simple">
+						<Variable Name="pos" InitialValue="0"/>
+						<Variable Name="last" InitialValue="packed.size()"/>
+						<Loop>
+							<Break Condition="pos == last"/>
+							<If Condition="*((entity_traits::entity_type *)&amp;packed[pos]) &lt; ~entity_traits::entity_mask">
+								<Item Name="[{ pos }]">packed[pos]</Item>
+							</If>
+							<Exec>++pos</Exec>
+						</Loop>
+					</CustomListItems>
+				</Expand>
+			</Synthetic>
+		</Expand>
+	</Type>
+	<Type Name="entt::basic_storage&lt;*&gt;">
+		<DisplayString>{{ size={ base_type::packed.size() }, type={ base_type::info->alias,na } }}</DisplayString>
+		<Expand>
+			<Item Name="[capacity]" Optional="true" ExcludeView="simple">packed.first_base::value.capacity() * comp_traits::page_size</Item>
+			<Item Name="[page size]" Optional="true" ExcludeView="simple">comp_traits::page_size</Item>
+			<Item Name="[base]" ExcludeView="simple">(base_type*)this,nand</Item>
+			<Item Name="[base]" IncludeView="simple">(base_type*)this,view(simple)nand</Item>
+			<!-- having SFINAE-like techniques in natvis is priceless :) -->
+			<CustomListItems Condition="packed.first_base::value.size() != 0" Optional="true">
+				<Variable Name="pos" InitialValue="0" />
+				<Variable Name="last" InitialValue="base_type::packed.size()"/>
+				<Loop>
+					<Break Condition="pos == last"/>
+					<If Condition="*((base_type::entity_traits::entity_type *)&amp;base_type::packed[pos]) &lt; ~base_type::entity_traits::entity_mask">
+						<Item Name="[{ pos }]">packed.first_base::value[pos / comp_traits::page_size][pos &amp; (comp_traits::page_size - 1)]</Item>
+					</If>
+					<Exec>++pos</Exec>
+				</Loop>
+			</CustomListItems>
+		</Expand>
+	</Type>
+	<Type Name="entt::basic_view&lt;*&gt;">
+		<DisplayString>{{ size_hint={ view->packed.size() } }}</DisplayString>
+		<Expand>
+			<Item Name="[pools]">pools,na</Item>
+			<Item Name="[filter]">filter,na</Item>
+		</Expand>
+	</Type>
+	<Type Name="entt::null_t">
+		<DisplayString>&lt;null&gt;</DisplayString>
+	</Type>
+	<Type Name="entt::tombstone_t">
+		<DisplayString>&lt;tombstone&gt;</DisplayString>
+	</Type>
+</AutoVisualizer>

natvis/entt/locator.natvis

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+</AutoVisualizer>

natvis/entt/meta.natvis

@@ -0,0 +1,197 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+	<Type Name="entt::meta_any">
+		<DisplayString Condition="node != nullptr">{{ type={ node->info->alias,na }, policy={ storage.mode,en } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<ExpandedItem Condition="node != nullptr">*node</ExpandedItem>
+		</Expand>
+	</Type>
+	<Type Name="entt::meta_associative_container">
+		<DisplayString Condition="mapped_type_node != nullptr">{{ key_type={ key_type_node->info->alias,na }, mapped_type={ mapped_type_node->info->alias,na } }}</DisplayString>
+		<DisplayString Condition="key_type_node != nullptr">{{ key_type={ key_type_node->info->alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+	</Type>
+	<Type Name="entt::internal::meta_base_node">
+		<DisplayString Condition="type != nullptr">{{ type={ type->info->alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+	</Type>
+	<Type Name="entt::internal::meta_conv_node">
+		<DisplayString Condition="type != nullptr">{{ type={ type->info->alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+	</Type>
+	<Type Name="entt::internal::meta_ctor_node">
+		<DisplayString Condition="arg != nullptr">{{ arity={ arity } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+	</Type>
+	<Type Name="entt::internal::meta_data_node">
+		<Intrinsic Name="has_property" Expression="!!(traits &amp; property)">
+			<Parameter Name="property" Type="int"/>
+		</Intrinsic>
+		<DisplayString Condition="type != nullptr">{{ type={ type->info->alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<Item Name="[id]">id</Item>
+			<Item Name="[arity]">arity</Item>
+			<Item Name="[is_const]">has_property(entt::internal::meta_traits::is_const)</Item>
+			<Item Name="[is_static]">has_property(entt::internal::meta_traits::is_static)</Item>
+			<Synthetic Name="[prop]" Condition="prop != nullptr">
+				<Expand>
+					<LinkedListItems>
+						<HeadPointer>prop</HeadPointer>
+						<NextPointer>next</NextPointer>
+						<ValueNode>*this</ValueNode>
+					</LinkedListItems>
+				</Expand>
+			</Synthetic>
+		</Expand>
+	</Type>
+	<Type Name="entt::meta_data">
+		<DisplayString Condition="node != nullptr">{ *node }</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<ExpandedItem Condition="node != nullptr">node</ExpandedItem>
+		</Expand>
+	</Type>
+	<Type Name="entt::internal::meta_func_node"	>
+		<Intrinsic Name="has_property" Expression="!!(traits &amp; property)">
+			<Parameter Name="property" Type="int"/>
+		</Intrinsic>
+		<DisplayString Condition="ret != nullptr">{{ arity={ arity }, ret={ ret->info->alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<Item Name="[id]">id</Item>
+			<Item Name="[is_const]">has_property(entt::internal::meta_traits::is_const)</Item>
+			<Item Name="[is_static]">has_property(entt::internal::meta_traits::is_static)</Item>
+			<Synthetic Name="[prop]" Condition="prop != nullptr">
+				<Expand>
+					<LinkedListItems>
+						<HeadPointer>prop</HeadPointer>
+						<NextPointer>next</NextPointer>
+						<ValueNode>*this</ValueNode>
+					</LinkedListItems>
+				</Expand>
+			</Synthetic>
+		</Expand>
+	</Type>
+	<Type Name="entt::meta_func">
+		<DisplayString Condition="node != nullptr">{ *node }</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<ExpandedItem Condition="node != nullptr">node</ExpandedItem>
+		</Expand>
+	</Type>
+	<Type Name="entt::meta_handle">
+		<DisplayString>{ any }</DisplayString>
+	</Type>
+	<Type Name="entt::internal::meta_prop_node">
+		<DisplayString Condition="value.node != nullptr">{{ key_type={ id.node->info->alias,na }, mapped_type={ value.node->info->alias,na } }}</DisplayString>
+		<DisplayString Condition="id.node != nullptr">{{ key_type={ id.node->info->alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<Item Name="[key]">id</Item>
+			<Item Name="[value]">value</Item>
+		</Expand>
+	</Type>
+	<Type Name="entt::meta_prop">
+		<DisplayString Condition="node != nullptr">{ *node }</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<ExpandedItem Condition="node != nullptr">node</ExpandedItem>
+		</Expand>
+	</Type>
+	<Type Name="entt::meta_sequence_container">
+		<DisplayString Condition="value_type_node != nullptr">{{ value_type={ value_type_node->info->alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+	</Type>
+	<Type Name="entt::internal::meta_template_node">
+		<DisplayString Condition="type != nullptr">{{ type={ type->info->alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<Item Name="[arity]">arity</Item>
+		</Expand>
+	</Type>
+	<Type Name="entt::internal::meta_type_node">
+		<Intrinsic Name="has_property" Expression="!!(traits &amp; property)">
+			<Parameter Name="property" Type="int"/>
+		</Intrinsic>
+		<DisplayString Condition="info != nullptr">{{ type={ info->alias,na } }}</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<Item Name="[id]">id</Item>
+			<Item Name="[sizeof]">size_of</Item>
+			<Item Name="[is_arithmetic]">has_property(entt::internal::meta_traits::is_arithmetic)</Item>
+			<Item Name="[is_array]">has_property(entt::internal::meta_traits::is_array)</Item>
+			<Item Name="[is_enum]">has_property(entt::internal::meta_traits::is_enum)</Item>
+			<Item Name="[is_class]">has_property(entt::internal::meta_traits::is_class)</Item>
+			<Item Name="[is_pointer]">has_property(entt::internal::meta_traits::is_pointer)</Item>
+			<Item Name="[is_meta_pointer_like]">has_property(entt::internal::meta_traits::is_meta_pointer_like)</Item>
+			<Item Name="[is_meta_sequence_container]">has_property(entt::internal::meta_traits::is_meta_sequence_container)</Item>
+			<Item Name="[is_meta_associative_container]">has_property(entt::internal::meta_traits::is_meta_associative_container)</Item>
+			<Item Name="[default_constructor]">default_constructor != nullptr</Item>
+			<Item Name="[conversion_helper]">conversion_helper != nullptr</Item>
+			<Item Name="[template_info]" Condition="templ != nullptr">*templ</Item>
+			<Synthetic Name="[ctor]" Condition="ctor != nullptr">
+				<Expand>
+					<LinkedListItems>
+						<HeadPointer>ctor</HeadPointer>
+						<NextPointer>next</NextPointer>
+						<ValueNode>*this</ValueNode>
+					</LinkedListItems>
+				</Expand>
+			</Synthetic>
+			<Synthetic Name="[base]" Condition="base != nullptr">
+				<Expand>
+					<LinkedListItems>
+						<HeadPointer>base</HeadPointer>
+						<NextPointer>next</NextPointer>
+						<ValueNode>*this</ValueNode>
+					</LinkedListItems>
+				</Expand>
+			</Synthetic>
+			<Synthetic Name="[conv]" Condition="conv != nullptr">
+				<Expand>
+					<LinkedListItems>
+						<HeadPointer>conv</HeadPointer>
+						<NextPointer>next</NextPointer>
+						<ValueNode>*this</ValueNode>
+					</LinkedListItems>
+				</Expand>
+			</Synthetic>
+			<Synthetic Name="[data]" Condition="data != nullptr">
+				<Expand>
+					<LinkedListItems>
+						<HeadPointer>data</HeadPointer>
+						<NextPointer>next</NextPointer>
+						<ValueNode>*this</ValueNode>
+					</LinkedListItems>
+				</Expand>
+			</Synthetic>
+			<Synthetic Name="[func]" Condition="func != nullptr">
+				<Expand>
+					<LinkedListItems>
+						<HeadPointer>func</HeadPointer>
+						<NextPointer>next</NextPointer>
+						<ValueNode>*this</ValueNode>
+					</LinkedListItems>
+				</Expand>
+			</Synthetic>
+			<Synthetic Name="[prop]" Condition="prop != nullptr">
+				<Expand>
+					<LinkedListItems>
+						<HeadPointer>prop</HeadPointer>
+						<NextPointer>next</NextPointer>
+						<ValueNode>*this</ValueNode>
+					</LinkedListItems>
+				</Expand>
+			</Synthetic>
+		</Expand>
+	</Type>
+	<Type Name="entt::meta_type">
+		<DisplayString Condition="node != nullptr">{ *node }</DisplayString>
+		<DisplayString>{{}}</DisplayString>
+		<Expand>
+			<ExpandedItem Condition="node != nullptr">node</ExpandedItem>
+		</Expand>
+	</Type>
+</AutoVisualizer>

natvis/entt/platform.natvis

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+</AutoVisualizer>

natvis/entt/poly.natvis

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+	<Type Name="entt::basic_poly&lt;*&gt;">
+		<DisplayString>{ storage }</DisplayString>
+	</Type>
+</AutoVisualizer>

natvis/entt/process.natvis

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+</AutoVisualizer>

natvis/entt/resource.natvis

@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+	<Type Name="entt::resource&lt;*&gt;">
+		<DisplayString>{ value }</DisplayString>
+		<Expand>
+			<ExpandedItem>value</ExpandedItem>
+		</Expand>
+	</Type>
+	<Type Name="entt::resource_cache&lt;*&gt;">
+		<DisplayString>{ pool.first_base::value }</DisplayString>
+		<Expand>
+			<ExpandedItem>pool.first_base::value</ExpandedItem>
+		</Expand>
+	</Type>
+</AutoVisualizer>

natvis/entt/signal.natvis

@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="utf-8"?>
+<AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
+	<Type Name="entt::connection">
+		<DisplayString>{{ bound={ signal != nullptr } }}</DisplayString>
+	</Type>
+	<Type Name="entt::delegate&lt;*&gt;">
+		<DisplayString>{{ type={ "$T1" } }}</DisplayString>
+		<Expand>
+			<Item Name="[empty]">fn == nullptr</Item>
+			<Item Name="[data]">instance</Item>
+		</Expand>
+	</Type>
+	<Type Name="entt::dispatcher">
+		<DisplayString>{{ size={ pools.size() } }}</DisplayString>
+		<Expand>
+			<Synthetic Name="[pools]">
+				<DisplayString>{ pools.size() }</DisplayString>
+				<Expand>
+					<IndexListItems>
+						<Size>pools.size()</Size>
+						<ValueNode>*pools.packed.first_base::value[$i].element.second</ValueNode>
+					</IndexListItems>
+				</Expand>
+			</Synthetic>
+		</Expand>
+	</Type>
+	<Type Name="entt::internal::dispatcher_handler&lt;*&gt;">
+		<DisplayString>{{ size={ events.size() }, event={ "$T1" } }}</DisplayString>
+		<Expand>
+			<Item Name="[signal]">signal</Item>
+		</Expand>
+	</Type>
+	<Type Name="entt::scoped_connection">
+		<DisplayString>{ conn }</DisplayString>
+	</Type>
+	<Type Name="entt::sigh&lt;*&gt;">
+		<DisplayString>{{ size={ calls.size() }, type={ "$T1" } }}</DisplayString>
+		<Expand>
+			<IndexListItems>
+				<Size>calls.size()</Size>
+				<ValueNode>calls[$i]</ValueNode>
+			</IndexListItems>
+		</Expand>
+	</Type>
+	<Type Name="entt::sink&lt;*&gt;">
+		<DisplayString>{{ type={ "$T1" } }}</DisplayString>
+		<Expand>
+			<Item Name="[signal]">signal,na</Item>
+			<Item Name="[offset]">offset</Item>
+		</Expand>
+	</Type>
+</AutoVisualizer>

scripts/amalgamate.py

@@ -0,0 +1,299 @@
+#!/usr/bin/env python
+# coding=utf-8
+
+# amalgamate.py - Amalgamate C source and header files.
+# Copyright (c) 2012, Erik Edlund <erik.edlund@32767.se>
+# 
+# Redistribution and use in source and binary forms, with or without modification,
+# are permitted provided that the following conditions are met:
+# 
+#  * Redistributions of source code must retain the above copyright notice,
+#  this list of conditions and the following disclaimer.
+# 
+#  * Redistributions in binary form must reproduce the above copyright notice,
+#  this list of conditions and the following disclaimer in the documentation
+#  and/or other materials provided with the distribution.
+# 
+#  * Neither the name of Erik Edlund, nor the names of its contributors may
+#  be used to endorse or promote products derived from this software without
+#  specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+from __future__ import division
+from __future__ import print_function
+from __future__ import unicode_literals
+
+import argparse
+import datetime
+import json
+import os
+import re
+
+
+class Amalgamation(object):
+
+    # Prepends self.source_path to file_path if needed.
+    def actual_path(self, file_path):
+        if not os.path.isabs(file_path):
+            file_path = os.path.join(self.source_path, file_path)
+        return file_path
+
+    # Search included file_path in self.include_paths and
+    # in source_dir if specified.
+    def find_included_file(self, file_path, source_dir):
+        search_dirs = self.include_paths[:]
+        if source_dir:
+            search_dirs.insert(0, source_dir)
+
+        for search_dir in search_dirs:
+            search_path = os.path.join(search_dir, file_path)
+            if os.path.isfile(self.actual_path(search_path)):
+                return search_path
+        return None
+
+    def __init__(self, args):
+        with open(args.config, 'r') as f:
+            config = json.loads(f.read())
+            for key in config:
+                setattr(self, key, config[key])
+
+            self.verbose = args.verbose == "yes"
+            self.prologue = args.prologue
+            self.source_path = args.source_path
+            self.included_files = []
+
+    # Generate the amalgamation and write it to the target file.
+    def generate(self):
+        amalgamation = ""
+
+        if self.prologue:
+            with open(self.prologue, 'r') as f:
+                amalgamation += datetime.datetime.now().strftime(f.read())
+
+        if self.verbose:
+            print("Config:")
+            print(" target        = {0}".format(self.target))
+            print(" working_dir   = {0}".format(os.getcwd()))
+            print(" include_paths = {0}".format(self.include_paths))
+        print("Creating amalgamation:")
+        for file_path in self.sources:
+            # Do not check the include paths while processing the source
+            # list, all given source paths must be correct.
+            # actual_path = self.actual_path(file_path)
+            print(" - processing \"{0}\"".format(file_path))
+            t = TranslationUnit(file_path, self, True)
+            amalgamation += t.content
+
+        with open(self.target, 'w') as f:
+            f.write(amalgamation)
+
+        print("...done!\n")
+        if self.verbose:
+            print("Files processed: {0}".format(self.sources))
+            print("Files included: {0}".format(self.included_files))
+        print("")
+
+
+def _is_within(match, matches):
+    for m in matches:
+        if match.start() > m.start() and \
+                match.end() < m.end():
+            return True
+    return False
+
+
+class TranslationUnit(object):
+    # // C++ comment.
+    cpp_comment_pattern = re.compile(r"//.*?\n")
+
+    # /* C comment. */
+    c_comment_pattern = re.compile(r"/\*.*?\*/", re.S)
+
+    # "complex \"stri\\\ng\" value".
+    string_pattern = re.compile("[^']" r'".*?(?<=[^\\])"', re.S)
+
+    # Handle simple include directives. Support for advanced
+    # directives where macros and defines needs to expanded is
+    # not a concern right now.
+    include_pattern = re.compile(
+        r'#\s*include\s+(<|")(?P<path>.*?)("|>)', re.S)
+
+    # #pragma once
+    pragma_once_pattern = re.compile(r'#\s*pragma\s+once', re.S)
+
+    # Search for pattern in self.content, add the match to
+    # contexts if found and update the index accordingly.
+    def _search_content(self, index, pattern, contexts):
+        match = pattern.search(self.content, index)
+        if match:
+            contexts.append(match)
+            return match.end()
+        return index + 2
+
+    # Return all the skippable contexts, i.e., comments and strings
+    def _find_skippable_contexts(self):
+        # Find contexts in the content in which a found include
+        # directive should not be processed.
+        skippable_contexts = []
+
+        # Walk through the content char by char, and try to grab
+        # skippable contexts using regular expressions when found.
+        i = 1
+        content_len = len(self.content)
+        while i < content_len:
+            j = i - 1
+            current = self.content[i]
+            previous = self.content[j]
+
+            if current == '"':
+                # String value.
+                i = self._search_content(j, self.string_pattern,
+                                         skippable_contexts)
+            elif current == '*' and previous == '/':
+                # C style comment.
+                i = self._search_content(j, self.c_comment_pattern,
+                                         skippable_contexts)
+            elif current == '/' and previous == '/':
+                # C++ style comment.
+                i = self._search_content(j, self.cpp_comment_pattern,
+                                         skippable_contexts)
+            else:
+                # Skip to the next char.
+                i += 1
+
+        return skippable_contexts
+
+    # Returns True if the match is within list of other matches
+
+    # Removes pragma once from content
+    def _process_pragma_once(self):
+        content_len = len(self.content)
+        if content_len < len("#include <x>"):
+            return 0
+
+        # Find contexts in the content in which a found include
+        # directive should not be processed.
+        skippable_contexts = self._find_skippable_contexts()
+
+        pragmas = []
+        pragma_once_match = self.pragma_once_pattern.search(self.content)
+        while pragma_once_match:
+            if not _is_within(pragma_once_match, skippable_contexts):
+                pragmas.append(pragma_once_match)
+
+            pragma_once_match = self.pragma_once_pattern.search(self.content,
+                                                                pragma_once_match.end())
+
+        # Handle all collected pragma once directives.
+        prev_end = 0
+        tmp_content = ''
+        for pragma_match in pragmas:
+            tmp_content += self.content[prev_end:pragma_match.start()]
+            prev_end = pragma_match.end()
+        tmp_content += self.content[prev_end:]
+        self.content = tmp_content
+
+    # Include all trivial #include directives into self.content.
+    def _process_includes(self):
+        content_len = len(self.content)
+        if content_len < len("#include <x>"):
+            return 0
+
+        # Find contexts in the content in which a found include
+        # directive should not be processed.
+        skippable_contexts = self._find_skippable_contexts()
+
+        # Search for include directives in the content, collect those
+        # which should be included into the content.
+        includes = []
+        include_match = self.include_pattern.search(self.content)
+        while include_match:
+            if not _is_within(include_match, skippable_contexts):
+                include_path = include_match.group("path")
+                search_same_dir = include_match.group(1) == '"'
+                found_included_path = self.amalgamation.find_included_file(
+                    include_path, self.file_dir if search_same_dir else None)
+                if found_included_path:
+                    includes.append((include_match, found_included_path))
+
+            include_match = self.include_pattern.search(self.content,
+                                                        include_match.end())
+
+        # Handle all collected include directives.
+        prev_end = 0
+        tmp_content = ''
+        for include in includes:
+            include_match, found_included_path = include
+            tmp_content += self.content[prev_end:include_match.start()]
+            tmp_content += "// {0}\n".format(include_match.group(0))
+            if found_included_path not in self.amalgamation.included_files:
+                t = TranslationUnit(found_included_path, self.amalgamation, False)
+                tmp_content += t.content
+            prev_end = include_match.end()
+        tmp_content += self.content[prev_end:]
+        self.content = tmp_content
+
+        return len(includes)
+
+    # Make all content processing
+    def _process(self):
+        if not self.is_root:
+            self._process_pragma_once()
+        self._process_includes()
+
+    def __init__(self, file_path, amalgamation, is_root):
+        self.file_path = file_path
+        self.file_dir = os.path.dirname(file_path)
+        self.amalgamation = amalgamation
+        self.is_root = is_root
+
+        self.amalgamation.included_files.append(self.file_path)
+
+        actual_path = self.amalgamation.actual_path(file_path)
+        if not os.path.isfile(actual_path):
+            raise IOError("File not found: \"{0}\"".format(file_path))
+        with open(actual_path, 'r') as f:
+            self.content = f.read()
+            self._process()
+
+
+def main():
+    description = "Amalgamate C source and header files."
+    usage = " ".join([
+        "amalgamate.py",
+        "[-v]",
+        "-c path/to/config.json",
+        "-s path/to/source/dir",
+        "[-p path/to/prologue.(c|h)]"
+    ])
+    argsparser = argparse.ArgumentParser(
+        description=description, usage=usage)
+
+    argsparser.add_argument("-v", "--verbose", dest="verbose",
+                            choices=["yes", "no"], metavar="", help="be verbose")
+
+    argsparser.add_argument("-c", "--config", dest="config",
+                            required=True, metavar="", help="path to a JSON config file")
+
+    argsparser.add_argument("-s", "--source", dest="source_path",
+                            required=True, metavar="", help="source code path")
+
+    argsparser.add_argument("-p", "--prologue", dest="prologue",
+                            required=False, metavar="", help="path to a C prologue file")
+
+    amalgamation = Amalgamation(argsparser.parse_args())
+    amalgamation.generate()
+
+
+if __name__ == "__main__":
+    main()

scripts/config.json

@@ -0,0 +1,8 @@
+{
+	"project": "entt",
+	"target": "single_include/entt/entt.hpp",
+	"sources": [
+		"src/entt/entt.hpp"
+	],
+	"include_paths": ["src"]
+}

scripts/update_homebrew.sh

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

src/entt/config/config.h

@@ -0,0 +1,76 @@
+#ifndef ENTT_CONFIG_CONFIG_H
+#define ENTT_CONFIG_CONFIG_H
+
+#include "version.h"
+
+#if defined(__cpp_exceptions) && !defined(ENTT_NOEXCEPTION)
+#    define ENTT_NOEXCEPT noexcept
+#    define ENTT_NOEXCEPT_IF(expr) noexcept(expr)
+#    define ENTT_THROW throw
+#    define ENTT_TRY try
+#    define ENTT_CATCH catch(...)
+#else
+#    define ENTT_NOEXCEPT
+#    define ENTT_NOEXCEPT_IF(...)
+#    define ENTT_THROW
+#    define ENTT_TRY if(true)
+#    define ENTT_CATCH if(false)
+#endif
+
+#ifdef ENTT_USE_ATOMIC
+#    include <atomic>
+#    define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
+#else
+#    define ENTT_MAYBE_ATOMIC(Type) Type
+#endif
+
+#ifndef ENTT_ID_TYPE
+#    include <cstdint>
+#    define ENTT_ID_TYPE std::uint32_t
+#endif
+
+#ifndef ENTT_SPARSE_PAGE
+#    define ENTT_SPARSE_PAGE 4096
+#endif
+
+#ifndef ENTT_PACKED_PAGE
+#    define ENTT_PACKED_PAGE 1024
+#endif
+
+#ifdef ENTT_DISABLE_ASSERT
+#    undef ENTT_ASSERT
+#    define ENTT_ASSERT(...) (void(0))
+#elif !defined ENTT_ASSERT
+#    include <cassert>
+#    define ENTT_ASSERT(condition, ...) assert(condition)
+#endif
+
+#ifdef ENTT_NO_ETO
+#    define ENTT_IGNORE_IF_EMPTY false
+#else
+#    define ENTT_IGNORE_IF_EMPTY true
+#endif
+
+#ifdef ENTT_STANDARD_CPP
+#    define ENTT_NONSTD false
+#else
+#    define ENTT_NONSTD true
+#    if defined __clang__ || defined __GNUC__
+#        define ENTT_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#        define ENTT_PRETTY_FUNCTION_PREFIX '='
+#        define ENTT_PRETTY_FUNCTION_SUFFIX ']'
+#    elif defined _MSC_VER
+#        define ENTT_PRETTY_FUNCTION __FUNCSIG__
+#        define ENTT_PRETTY_FUNCTION_PREFIX '<'
+#        define ENTT_PRETTY_FUNCTION_SUFFIX '>'
+#    endif
+#endif
+
+#if defined _MSC_VER
+#    pragma detect_mismatch("entt.version", ENTT_VERSION)
+#    pragma detect_mismatch("entt.noexcept", ENTT_XSTR(ENTT_TRY))
+#    pragma detect_mismatch("entt.id", ENTT_XSTR(ENTT_ID_TYPE))
+#    pragma detect_mismatch("entt.nonstd", ENTT_XSTR(ENTT_NONSTD))
+#endif
+
+#endif

src/entt/config/macro.h

@@ -0,0 +1,7 @@
+#ifndef ENTT_CONFIG_MACRO_H
+#define ENTT_CONFIG_MACRO_H
+
+#define ENTT_STR(arg) #arg
+#define ENTT_XSTR(arg) ENTT_STR(arg)
+
+#endif

src/entt/config/version.h

@@ -0,0 +1,14 @@
+#ifndef ENTT_CONFIG_VERSION_H
+#define ENTT_CONFIG_VERSION_H
+
+#include "macro.h"
+
+#define ENTT_VERSION_MAJOR 3
+#define ENTT_VERSION_MINOR 10
+#define ENTT_VERSION_PATCH 0
+
+#define ENTT_VERSION \
+    ENTT_XSTR(ENTT_VERSION_MAJOR) \
+    "." ENTT_XSTR(ENTT_VERSION_MINOR) "." ENTT_XSTR(ENTT_VERSION_PATCH)
+
+#endif

src/entt/container/dense_map.hpp

@@ -0,0 +1,988 @@
+#ifndef ENTT_CONTAINER_DENSE_MAP_HPP
+#define ENTT_CONTAINER_DENSE_MAP_HPP
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "../config/config.h"
+#include "../core/compressed_pair.hpp"
+#include "../core/iterator.hpp"
+#include "../core/memory.hpp"
+#include "../core/type_traits.hpp"
+#include "fwd.hpp"
+
+namespace entt {
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename Key, typename Type>
+struct dense_map_node final {
+    using value_type = std::pair<Key, Type>;
+
+    template<typename... Args>
+    dense_map_node(const std::size_t pos, Args &&...args)
+        : next{pos},
+          element{std::forward<Args>(args)...} {}
+
+    template<typename Allocator, typename... Args>
+    dense_map_node(std::allocator_arg_t, const Allocator &allocator, const std::size_t pos, Args &&...args)
+        : next{pos},
+          element{entt::make_obj_using_allocator<value_type>(allocator, std::forward<Args>(args)...)} {}
+
+    template<typename Allocator>
+    dense_map_node(std::allocator_arg_t, const Allocator &allocator, const dense_map_node &other)
+        : next{other.next},
+          element{entt::make_obj_using_allocator<value_type>(allocator, other.element)} {}
+
+    template<typename Allocator>
+    dense_map_node(std::allocator_arg_t, const Allocator &allocator, dense_map_node &&other)
+        : next{other.next},
+          element{entt::make_obj_using_allocator<value_type>(allocator, std::move(other.element))} {}
+
+    std::size_t next;
+    value_type element;
+};
+
+template<typename It>
+class dense_map_iterator final {
+    template<typename>
+    friend class dense_map_iterator;
+
+    using first_type = decltype(std::as_const(std::declval<It>()->element.first));
+    using second_type = decltype((std::declval<It>()->element.second));
+
+public:
+    using value_type = std::pair<first_type, second_type>;
+    using pointer = input_iterator_pointer<value_type>;
+    using reference = value_type;
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::input_iterator_tag;
+
+    dense_map_iterator() ENTT_NOEXCEPT
+        : it{} {}
+
+    dense_map_iterator(const It iter) ENTT_NOEXCEPT
+        : it{iter} {}
+
+    template<typename Other, typename = std::enable_if_t<!std::is_same_v<It, Other> && std::is_constructible_v<It, Other>>>
+    dense_map_iterator(const dense_map_iterator<Other> &other) ENTT_NOEXCEPT
+        : it{other.it} {}
+
+    dense_map_iterator &operator++() ENTT_NOEXCEPT {
+        return ++it, *this;
+    }
+
+    dense_map_iterator operator++(int) ENTT_NOEXCEPT {
+        dense_map_iterator orig = *this;
+        return ++(*this), orig;
+    }
+
+    dense_map_iterator &operator--() ENTT_NOEXCEPT {
+        return --it, *this;
+    }
+
+    dense_map_iterator operator--(int) ENTT_NOEXCEPT {
+        dense_map_iterator orig = *this;
+        return operator--(), orig;
+    }
+
+    dense_map_iterator &operator+=(const difference_type value) ENTT_NOEXCEPT {
+        it += value;
+        return *this;
+    }
+
+    dense_map_iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
+        dense_map_iterator copy = *this;
+        return (copy += value);
+    }
+
+    dense_map_iterator &operator-=(const difference_type value) ENTT_NOEXCEPT {
+        return (*this += -value);
+    }
+
+    dense_map_iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
+        return (*this + -value);
+    }
+
+    [[nodiscard]] reference operator[](const difference_type value) const ENTT_NOEXCEPT {
+        return {it[value].element.first, it[value].element.second};
+    }
+
+    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
+        return operator*();
+    }
+
+    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
+        return {it->element.first, it->element.second};
+    }
+
+    template<typename ILhs, typename IRhs>
+    friend std::ptrdiff_t operator-(const dense_map_iterator<ILhs> &, const dense_map_iterator<IRhs> &) ENTT_NOEXCEPT;
+
+    template<typename ILhs, typename IRhs>
+    friend bool operator==(const dense_map_iterator<ILhs> &, const dense_map_iterator<IRhs> &) ENTT_NOEXCEPT;
+
+    template<typename ILhs, typename IRhs>
+    friend bool operator<(const dense_map_iterator<ILhs> &, const dense_map_iterator<IRhs> &) ENTT_NOEXCEPT;
+
+private:
+    It it;
+};
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] std::ptrdiff_t operator-(const dense_map_iterator<ILhs> &lhs, const dense_map_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.it - rhs.it;
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator==(const dense_map_iterator<ILhs> &lhs, const dense_map_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.it == rhs.it;
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator!=(const dense_map_iterator<ILhs> &lhs, const dense_map_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator<(const dense_map_iterator<ILhs> &lhs, const dense_map_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.it < rhs.it;
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator>(const dense_map_iterator<ILhs> &lhs, const dense_map_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return rhs < lhs;
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator<=(const dense_map_iterator<ILhs> &lhs, const dense_map_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs > rhs);
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator>=(const dense_map_iterator<ILhs> &lhs, const dense_map_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs < rhs);
+}
+
+template<typename It>
+class dense_map_local_iterator final {
+    template<typename>
+    friend class dense_map_local_iterator;
+
+    using first_type = decltype(std::as_const(std::declval<It>()->element.first));
+    using second_type = decltype((std::declval<It>()->element.second));
+
+public:
+    using value_type = std::pair<first_type, second_type>;
+    using pointer = input_iterator_pointer<value_type>;
+    using reference = value_type;
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::input_iterator_tag;
+
+    dense_map_local_iterator() ENTT_NOEXCEPT
+        : it{},
+          offset{} {}
+
+    dense_map_local_iterator(It iter, const std::size_t pos) ENTT_NOEXCEPT
+        : it{iter},
+          offset{pos} {}
+
+    template<typename Other, typename = std::enable_if_t<!std::is_same_v<It, Other> && std::is_constructible_v<It, Other>>>
+    dense_map_local_iterator(const dense_map_local_iterator<Other> &other) ENTT_NOEXCEPT
+        : it{other.it},
+          offset{other.offset} {}
+
+    dense_map_local_iterator &operator++() ENTT_NOEXCEPT {
+        return offset = it[offset].next, *this;
+    }
+
+    dense_map_local_iterator operator++(int) ENTT_NOEXCEPT {
+        dense_map_local_iterator orig = *this;
+        return ++(*this), orig;
+    }
+
+    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
+        return operator*();
+    }
+
+    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
+        return {it[offset].element.first, it[offset].element.second};
+    }
+
+    [[nodiscard]] std::size_t index() const ENTT_NOEXCEPT {
+        return offset;
+    }
+
+private:
+    It it;
+    std::size_t offset;
+};
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator==(const dense_map_local_iterator<ILhs> &lhs, const dense_map_local_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.index() == rhs.index();
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator!=(const dense_map_local_iterator<ILhs> &lhs, const dense_map_local_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Associative container for key-value pairs with unique keys.
+ *
+ * Internally, elements are organized into buckets. Which bucket an element is
+ * placed into depends entirely on the hash of its key. Keys with the same hash
+ * code appear in the same bucket.
+ *
+ * @tparam Key Key type of the associative container.
+ * @tparam Type Mapped type of the associative container.
+ * @tparam Hash Type of function to use to hash the keys.
+ * @tparam KeyEqual Type of function to use to compare the keys for equality.
+ * @tparam Allocator Type of allocator used to manage memory and elements.
+ */
+template<typename Key, typename Type, typename Hash, typename KeyEqual, typename Allocator>
+class dense_map {
+    static constexpr float default_threshold = 0.875f;
+    static constexpr std::size_t minimum_capacity = 8u;
+
+    using node_type = internal::dense_map_node<Key, Type>;
+    using alloc_traits = typename std::allocator_traits<Allocator>;
+    static_assert(std::is_same_v<typename alloc_traits::value_type, std::pair<const Key, Type>>, "Invalid value type");
+    using sparse_container_type = std::vector<std::size_t, typename alloc_traits::template rebind_alloc<std::size_t>>;
+    using packed_container_type = std::vector<node_type, typename alloc_traits::template rebind_alloc<node_type>>;
+
+    template<typename Other>
+    [[nodiscard]] std::size_t key_to_bucket(const Other &key) const ENTT_NOEXCEPT {
+        return fast_mod(sparse.second()(key), bucket_count());
+    }
+
+    template<typename Other>
+    [[nodiscard]] auto constrained_find(const Other &key, std::size_t bucket) {
+        for(auto it = begin(bucket), last = end(bucket); it != last; ++it) {
+            if(packed.second()(it->first, key)) {
+                return begin() + static_cast<typename iterator::difference_type>(it.index());
+            }
+        }
+
+        return end();
+    }
+
+    template<typename Other>
+    [[nodiscard]] auto constrained_find(const Other &key, std::size_t bucket) const {
+        for(auto it = cbegin(bucket), last = cend(bucket); it != last; ++it) {
+            if(packed.second()(it->first, key)) {
+                return cbegin() + static_cast<typename iterator::difference_type>(it.index());
+            }
+        }
+
+        return cend();
+    }
+
+    template<typename Other, typename... Args>
+    [[nodiscard]] auto insert_or_do_nothing(Other &&key, Args &&...args) {
+        const auto index = key_to_bucket(key);
+
+        if(auto it = constrained_find(key, index); it != end()) {
+            return std::make_pair(it, false);
+        }
+
+        packed.first().emplace_back(sparse.first()[index], std::piecewise_construct, std::forward_as_tuple(std::forward<Other>(key)), std::forward_as_tuple(std::forward<Args>(args)...));
+        sparse.first()[index] = packed.first().size() - 1u;
+        rehash_if_required();
+
+        return std::make_pair(--end(), true);
+    }
+
+    template<typename Other, typename Arg>
+    [[nodiscard]] auto insert_or_overwrite(Other &&key, Arg &&value) {
+        const auto index = key_to_bucket(key);
+
+        if(auto it = constrained_find(key, index); it != end()) {
+            it->second = std::forward<Arg>(value);
+            return std::make_pair(it, false);
+        }
+
+        packed.first().emplace_back(sparse.first()[index], std::forward<Other>(key), std::forward<Arg>(value));
+        sparse.first()[index] = packed.first().size() - 1u;
+        rehash_if_required();
+
+        return std::make_pair(--end(), true);
+    }
+
+    void move_and_pop(const std::size_t pos) {
+        if(const auto last = size() - 1u; pos != last) {
+            packed.first()[pos] = std::move(packed.first().back());
+            size_type *curr = sparse.first().data() + key_to_bucket(packed.first().back().element.first);
+            for(; *curr != last; curr = &packed.first()[*curr].next) {}
+            *curr = pos;
+        }
+
+        packed.first().pop_back();
+    }
+
+    void rehash_if_required() {
+        if(size() > (bucket_count() * max_load_factor())) {
+            rehash(bucket_count() * 2u);
+        }
+    }
+
+public:
+    /*! @brief Key type of the container. */
+    using key_type = Key;
+    /*! @brief Mapped type of the container. */
+    using mapped_type = Type;
+    /*! @brief Key-value type of the container. */
+    using value_type = std::pair<const Key, Type>;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+    /*! @brief Type of function to use to hash the keys. */
+    using hasher = Hash;
+    /*! @brief Type of function to use to compare the keys for equality. */
+    using key_equal = KeyEqual;
+    /*! @brief Allocator type. */
+    using allocator_type = Allocator;
+    /*! @brief Input iterator type. */
+    using iterator = internal::dense_map_iterator<typename packed_container_type::iterator>;
+    /*! @brief Constant input iterator type. */
+    using const_iterator = internal::dense_map_iterator<typename packed_container_type::const_iterator>;
+    /*! @brief Input iterator type. */
+    using local_iterator = internal::dense_map_local_iterator<typename packed_container_type::iterator>;
+    /*! @brief Constant input iterator type. */
+    using const_local_iterator = internal::dense_map_local_iterator<typename packed_container_type::const_iterator>;
+
+    /*! @brief Default constructor. */
+    dense_map()
+        : dense_map(minimum_capacity) {}
+
+    /**
+     * @brief Constructs an empty container with a given allocator.
+     * @param allocator The allocator to use.
+     */
+    explicit dense_map(const allocator_type &allocator)
+        : dense_map{minimum_capacity, hasher{}, key_equal{}, allocator} {}
+
+    /**
+     * @brief Constructs an empty container with a given allocator and user
+     * supplied minimal number of buckets.
+     * @param bucket_count Minimal number of buckets.
+     * @param allocator The allocator to use.
+     */
+    dense_map(const size_type bucket_count, const allocator_type &allocator)
+        : dense_map{bucket_count, hasher{}, key_equal{}, allocator} {}
+
+    /**
+     * @brief Constructs an empty container with a given allocator, hash
+     * function and user supplied minimal number of buckets.
+     * @param bucket_count Minimal number of buckets.
+     * @param hash Hash function to use.
+     * @param allocator The allocator to use.
+     */
+    dense_map(const size_type bucket_count, const hasher &hash, const allocator_type &allocator)
+        : dense_map{bucket_count, hash, key_equal{}, allocator} {}
+
+    /**
+     * @brief Constructs an empty container with a given allocator, hash
+     * function, compare function and user supplied minimal number of buckets.
+     * @param bucket_count Minimal number of buckets.
+     * @param hash Hash function to use.
+     * @param equal Compare function to use.
+     * @param allocator The allocator to use.
+     */
+    explicit dense_map(const size_type bucket_count, const hasher &hash = hasher{}, const key_equal &equal = key_equal{}, const allocator_type &allocator = allocator_type{})
+        : sparse{allocator, hash},
+          packed{allocator, equal},
+          threshold{default_threshold} {
+        rehash(bucket_count);
+    }
+
+    /*! @brief Default copy constructor. */
+    dense_map(const dense_map &) = default;
+
+    /**
+     * @brief Allocator-extended copy constructor.
+     * @param other The instance to copy from.
+     * @param allocator The allocator to use.
+     */
+    dense_map(const dense_map &other, const allocator_type &allocator)
+        : sparse{std::piecewise_construct, std::forward_as_tuple(other.sparse.first(), allocator), std::forward_as_tuple(other.sparse.second())},
+          packed{std::piecewise_construct, std::forward_as_tuple(other.packed.first(), allocator), std::forward_as_tuple(other.packed.second())},
+          threshold{other.threshold} {}
+
+    /*! @brief Default move constructor. */
+    dense_map(dense_map &&) = default;
+
+    /**
+     * @brief Allocator-extended move constructor.
+     * @param other The instance to move from.
+     * @param allocator The allocator to use.
+     */
+    dense_map(dense_map &&other, const allocator_type &allocator)
+        : sparse{std::piecewise_construct, std::forward_as_tuple(std::move(other.sparse.first()), allocator), std::forward_as_tuple(std::move(other.sparse.second()))},
+          packed{std::piecewise_construct, std::forward_as_tuple(std::move(other.packed.first()), allocator), std::forward_as_tuple(std::move(other.packed.second()))},
+          threshold{other.threshold} {}
+
+    /**
+     * @brief Default copy assignment operator.
+     * @return This container.
+     */
+    dense_map &operator=(const dense_map &) = default;
+
+    /**
+     * @brief Default move assignment operator.
+     * @return This container.
+     */
+    dense_map &operator=(dense_map &&) = default;
+
+    /**
+     * @brief Returns the associated allocator.
+     * @return The associated allocator.
+     */
+    [[nodiscard]] constexpr allocator_type get_allocator() const ENTT_NOEXCEPT {
+        return sparse.first().get_allocator();
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning.
+     *
+     * The returned iterator points to the first instance of the internal array.
+     * If the array is empty, the returned iterator will be equal to `end()`.
+     *
+     * @return An iterator to the first instance of the internal array.
+     */
+    [[nodiscard]] const_iterator cbegin() const ENTT_NOEXCEPT {
+        return packed.first().begin();
+    }
+
+    /*! @copydoc cbegin */
+    [[nodiscard]] const_iterator begin() const ENTT_NOEXCEPT {
+        return cbegin();
+    }
+
+    /*! @copydoc begin */
+    [[nodiscard]] iterator begin() ENTT_NOEXCEPT {
+        return packed.first().begin();
+    }
+
+    /**
+     * @brief Returns an iterator to the end.
+     *
+     * The returned iterator points to the element following the last instance
+     * of the internal array. Attempting to dereference the returned iterator
+     * results in undefined behavior.
+     *
+     * @return An iterator to the element following the last instance of the
+     * internal array.
+     */
+    [[nodiscard]] const_iterator cend() const ENTT_NOEXCEPT {
+        return packed.first().end();
+    }
+
+    /*! @copydoc cend */
+    [[nodiscard]] const_iterator end() const ENTT_NOEXCEPT {
+        return cend();
+    }
+
+    /*! @copydoc end */
+    [[nodiscard]] iterator end() ENTT_NOEXCEPT {
+        return packed.first().end();
+    }
+
+    /**
+     * @brief Checks whether a container is empty.
+     * @return True if the container is empty, false otherwise.
+     */
+    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
+        return packed.first().empty();
+    }
+
+    /**
+     * @brief Returns the number of elements in a container.
+     * @return Number of elements in a container.
+     */
+    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
+        return packed.first().size();
+    }
+
+    /*! @brief Clears the container. */
+    void clear() ENTT_NOEXCEPT {
+        sparse.first().clear();
+        packed.first().clear();
+        rehash(0u);
+    }
+
+    /**
+     * @brief Inserts an element into the container, if the key does not exist.
+     * @param value A key-value pair eventually convertible to the value type.
+     * @return A pair consisting of an iterator to the inserted element (or to
+     * the element that prevented the insertion) and a bool denoting whether the
+     * insertion took place.
+     */
+    std::pair<iterator, bool> insert(const value_type &value) {
+        return insert_or_do_nothing(value.first, value.second);
+    }
+
+    /*! @copydoc insert */
+    std::pair<iterator, bool> insert(value_type &&value) {
+        return insert_or_do_nothing(std::move(value.first), std::move(value.second));
+    }
+
+    /**
+     * @copydoc insert
+     * @tparam Arg Type of the key-value pair to insert into the container.
+     */
+    template<typename Arg>
+    std::enable_if_t<std::is_constructible_v<value_type, Arg &&>, std::pair<iterator, bool>>
+    insert(Arg &&value) {
+        return insert_or_do_nothing(std::forward<Arg>(value).first, std::forward<Arg>(value).second);
+    }
+
+    /**
+     * @brief Inserts elements into the container, if their keys do not exist.
+     * @tparam It Type of input iterator.
+     * @param first An iterator to the first element of the range of elements.
+     * @param last An iterator past the last element of the range of elements.
+     */
+    template<typename It>
+    void insert(It first, It last) {
+        for(; first != last; ++first) {
+            insert(*first);
+        }
+    }
+
+    /**
+     * @brief Inserts an element into the container or assigns to the current
+     * element if the key already exists.
+     * @tparam Arg Type of the value to insert or assign.
+     * @param key A key used both to look up and to insert if not found.
+     * @param value A value to insert or assign.
+     * @return A pair consisting of an iterator to the element and a bool
+     * denoting whether the insertion took place.
+     */
+    template<typename Arg>
+    std::pair<iterator, bool> insert_or_assign(const key_type &key, Arg &&value) {
+        return insert_or_overwrite(key, std::forward<Arg>(value));
+    }
+
+    /*! @copydoc insert_or_assign */
+    template<typename Arg>
+    std::pair<iterator, bool> insert_or_assign(key_type &&key, Arg &&value) {
+        return insert_or_overwrite(std::move(key), std::forward<Arg>(value));
+    }
+
+    /**
+     * @brief Constructs an element in-place, if the key does not exist.
+     *
+     * The element is also constructed when the container already has the key,
+     * in which case the newly constructed object is destroyed immediately.
+     *
+     * @tparam Args Types of arguments to forward to the constructor of the
+     * element.
+     * @param args Arguments to forward to the constructor of the element.
+     * @return A pair consisting of an iterator to the inserted element (or to
+     * the element that prevented the insertion) and a bool denoting whether the
+     * insertion took place.
+     */
+    template<typename... Args>
+    std::pair<iterator, bool> emplace([[maybe_unused]] Args &&...args) {
+        if constexpr(sizeof...(Args) == 0u) {
+            return insert_or_do_nothing(key_type{});
+        } else if constexpr(sizeof...(Args) == 1u) {
+            return insert_or_do_nothing(std::forward<Args>(args).first..., std::forward<Args>(args).second...);
+        } else if constexpr(sizeof...(Args) == 2u) {
+            return insert_or_do_nothing(std::forward<Args>(args)...);
+        } else {
+            auto &node = packed.first().emplace_back(packed.first().size(), std::forward<Args>(args)...);
+            const auto index = key_to_bucket(node.element.first);
+
+            if(auto it = constrained_find(node.element.first, index); it != end()) {
+                packed.first().pop_back();
+                return std::make_pair(it, false);
+            }
+
+            std::swap(node.next, sparse.first()[index]);
+            rehash_if_required();
+
+            return std::make_pair(--end(), true);
+        }
+    }
+
+    /**
+     * @brief Inserts in-place if the key does not exist, does nothing if the
+     * key exists.
+     * @tparam Args Types of arguments to forward to the constructor of the
+     * element.
+     * @param key A key used both to look up and to insert if not found.
+     * @param args Arguments to forward to the constructor of the element.
+     * @return A pair consisting of an iterator to the inserted element (or to
+     * the element that prevented the insertion) and a bool denoting whether the
+     * insertion took place.
+     */
+    template<typename... Args>
+    std::pair<iterator, bool> try_emplace(const key_type &key, Args &&...args) {
+        return insert_or_do_nothing(key, std::forward<Args>(args)...);
+    }
+
+    /*! @copydoc try_emplace */
+    template<typename... Args>
+    std::pair<iterator, bool> try_emplace(key_type &&key, Args &&...args) {
+        return insert_or_do_nothing(std::move(key), std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Removes an element from a given position.
+     * @param pos An iterator to the element to remove.
+     * @return An iterator following the removed element.
+     */
+    iterator erase(const_iterator pos) {
+        const auto diff = pos - cbegin();
+        erase(pos->first);
+        return begin() + diff;
+    }
+
+    /**
+     * @brief Removes the given elements from a container.
+     * @param first An iterator to the first element of the range of elements.
+     * @param last An iterator past the last element of the range of elements.
+     * @return An iterator following the last removed element.
+     */
+    iterator erase(const_iterator first, const_iterator last) {
+        const auto dist = first - cbegin();
+
+        for(auto from = last - cbegin(); from != dist; --from) {
+            erase(packed.first()[from - 1u].element.first);
+        }
+
+        return (begin() + dist);
+    }
+
+    /**
+     * @brief Removes the element associated with a given key.
+     * @param key A key value of an element to remove.
+     * @return Number of elements removed (either 0 or 1).
+     */
+    size_type erase(const key_type &key) {
+        for(size_type *curr = sparse.first().data() + key_to_bucket(key); *curr != (std::numeric_limits<size_type>::max)(); curr = &packed.first()[*curr].next) {
+            if(packed.second()(packed.first()[*curr].element.first, key)) {
+                const auto index = *curr;
+                *curr = packed.first()[*curr].next;
+                move_and_pop(index);
+                return 1u;
+            }
+        }
+
+        return 0u;
+    }
+
+    /**
+     * @brief Exchanges the contents with those of a given container.
+     * @param other Container to exchange the content with.
+     */
+    void swap(dense_map &other) {
+        using std::swap;
+        swap(sparse, other.sparse);
+        swap(packed, other.packed);
+        swap(threshold, other.threshold);
+    }
+
+    /**
+     * @brief Accesses a given element with bounds checking.
+     * @param key A key of an element to find.
+     * @return A reference to the mapped value of the requested element.
+     */
+    [[nodiscard]] mapped_type &at(const key_type &key) {
+        auto it = find(key);
+        ENTT_ASSERT(it != end(), "Invalid key");
+        return it->second;
+    }
+
+    /*! @copydoc at */
+    [[nodiscard]] const mapped_type &at(const key_type &key) const {
+        auto it = find(key);
+        ENTT_ASSERT(it != cend(), "Invalid key");
+        return it->second;
+    }
+
+    /**
+     * @brief Accesses or inserts a given element.
+     * @param key A key of an element to find or insert.
+     * @return A reference to the mapped value of the requested element.
+     */
+    [[nodiscard]] mapped_type &operator[](const key_type &key) {
+        return insert_or_do_nothing(key).first->second;
+    }
+
+    /**
+     * @brief Accesses or inserts a given element.
+     * @param key A key of an element to find or insert.
+     * @return A reference to the mapped value of the requested element.
+     */
+    [[nodiscard]] mapped_type &operator[](key_type &&key) {
+        return insert_or_do_nothing(std::move(key)).first->second;
+    }
+
+    /**
+     * @brief Finds an element with a given key.
+     * @param key Key value of an element to search for.
+     * @return An iterator to an element with the given key. If no such element
+     * is found, a past-the-end iterator is returned.
+     */
+    [[nodiscard]] iterator find(const key_type &key) {
+        return constrained_find(key, key_to_bucket(key));
+    }
+
+    /*! @copydoc find */
+    [[nodiscard]] const_iterator find(const key_type &key) const {
+        return constrained_find(key, key_to_bucket(key));
+    }
+
+    /**
+     * @brief Finds an element with a key that compares _equivalent_ to a given
+     * value.
+     * @tparam Other Type of the key value of an element to search for.
+     * @param key Key value of an element to search for.
+     * @return An iterator to an element with the given key. If no such element
+     * is found, a past-the-end iterator is returned.
+     */
+    template<typename Other>
+    [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, iterator>>
+    find(const Other &key) {
+        return constrained_find(key, key_to_bucket(key));
+    }
+
+    /*! @copydoc find */
+    template<typename Other>
+    [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, const_iterator>>
+    find(const Other &key) const {
+        return constrained_find(key, key_to_bucket(key));
+    }
+
+    /**
+     * @brief Checks if the container contains an element with a given key.
+     * @param key Key value of an element to search for.
+     * @return True if there is such an element, false otherwise.
+     */
+    [[nodiscard]] bool contains(const key_type &key) const {
+        return (find(key) != cend());
+    }
+
+    /**
+     * @brief Checks if the container contains an element with a key that
+     * compares _equivalent_ to a given value.
+     * @tparam Other Type of the key value of an element to search for.
+     * @param key Key value of an element to search for.
+     * @return True if there is such an element, false otherwise.
+     */
+    template<typename Other>
+    [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, bool>>
+    contains(const Other &key) const {
+        return (find(key) != cend());
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the beginning of the given bucket.
+     */
+    [[nodiscard]] const_local_iterator cbegin(const size_type index) const {
+        return {packed.first().begin(), sparse.first()[index]};
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the beginning of the given bucket.
+     */
+    [[nodiscard]] const_local_iterator begin(const size_type index) const {
+        return cbegin(index);
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the beginning of the given bucket.
+     */
+    [[nodiscard]] local_iterator begin(const size_type index) {
+        return {packed.first().begin(), sparse.first()[index]};
+    }
+
+    /**
+     * @brief Returns an iterator to the end of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the end of the given bucket.
+     */
+    [[nodiscard]] const_local_iterator cend([[maybe_unused]] const size_type index) const {
+        return {packed.first().begin(), (std::numeric_limits<size_type>::max)()};
+    }
+
+    /**
+     * @brief Returns an iterator to the end of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the end of the given bucket.
+     */
+    [[nodiscard]] const_local_iterator end([[maybe_unused]] const size_type index) const {
+        return cend(index);
+    }
+
+    /**
+     * @brief Returns an iterator to the end of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the end of the given bucket.
+     */
+    [[nodiscard]] local_iterator end([[maybe_unused]] const size_type index) {
+        return {packed.first().begin(), (std::numeric_limits<size_type>::max)()};
+    }
+
+    /**
+     * @brief Returns the number of buckets.
+     * @return The number of buckets.
+     */
+    [[nodiscard]] size_type bucket_count() const {
+        return sparse.first().size();
+    }
+
+    /**
+     * @brief Returns the maximum number of buckets.
+     * @return The maximum number of buckets.
+     */
+    [[nodiscard]] size_type max_bucket_count() const {
+        return sparse.first().max_size();
+    }
+
+    /**
+     * @brief Returns the number of elements in a given bucket.
+     * @param index The index of the bucket to examine.
+     * @return The number of elements in the given bucket.
+     */
+    [[nodiscard]] size_type bucket_size(const size_type index) const {
+        return static_cast<size_type>(std::distance(begin(index), end(index)));
+    }
+
+    /**
+     * @brief Returns the bucket for a given key.
+     * @param key The value of the key to examine.
+     * @return The bucket for the given key.
+     */
+    [[nodiscard]] size_type bucket(const key_type &key) const {
+        return key_to_bucket(key);
+    }
+
+    /**
+     * @brief Returns the average number of elements per bucket.
+     * @return The average number of elements per bucket.
+     */
+    [[nodiscard]] float load_factor() const {
+        return size() / static_cast<float>(bucket_count());
+    }
+
+    /**
+     * @brief Returns the maximum average number of elements per bucket.
+     * @return The maximum average number of elements per bucket.
+     */
+    [[nodiscard]] float max_load_factor() const {
+        return threshold;
+    }
+
+    /**
+     * @brief Sets the desired maximum average number of elements per bucket.
+     * @param value A desired maximum average number of elements per bucket.
+     */
+    void max_load_factor(const float value) {
+        ENTT_ASSERT(value > 0.f, "Invalid load factor");
+        threshold = value;
+        rehash(0u);
+    }
+
+    /**
+     * @brief Reserves at least the specified number of buckets and regenerates
+     * the hash table.
+     * @param count New number of buckets.
+     */
+    void rehash(const size_type count) {
+        auto value = (std::max)(count, minimum_capacity);
+        value = (std::max)(value, static_cast<size_type>(size() / max_load_factor()));
+
+        if(const auto sz = next_power_of_two(value); sz != bucket_count()) {
+            sparse.first().resize(sz);
+            std::fill(sparse.first().begin(), sparse.first().end(), (std::numeric_limits<size_type>::max)());
+
+            for(size_type pos{}, last = size(); pos < last; ++pos) {
+                const auto index = key_to_bucket(packed.first()[pos].element.first);
+                packed.first()[pos].next = std::exchange(sparse.first()[index], pos);
+            }
+        }
+    }
+
+    /**
+     * @brief Reserves space for at least the specified number of elements and
+     * regenerates the hash table.
+     * @param count New number of elements.
+     */
+    void reserve(const size_type count) {
+        packed.first().reserve(count);
+        rehash(static_cast<size_type>(std::ceil(count / max_load_factor())));
+    }
+
+    /**
+     * @brief Returns the function used to hash the keys.
+     * @return The function used to hash the keys.
+     */
+    [[nodiscard]] hasher hash_function() const {
+        return sparse.second();
+    }
+
+    /**
+     * @brief Returns the function used to compare keys for equality.
+     * @return The function used to compare keys for equality.
+     */
+    [[nodiscard]] key_equal key_eq() const {
+        return packed.second();
+    }
+
+private:
+    compressed_pair<sparse_container_type, hasher> sparse;
+    compressed_pair<packed_container_type, key_equal> packed;
+    float threshold;
+};
+
+} // namespace entt
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace std {
+
+template<typename Key, typename Value, typename Allocator>
+struct uses_allocator<entt::internal::dense_map_node<Key, Value>, Allocator>
+    : std::true_type {};
+
+} // namespace std
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+#endif

src/entt/container/dense_set.hpp

@@ -0,0 +1,823 @@
+#ifndef ENTT_CONTAINER_DENSE_SET_HPP
+#define ENTT_CONTAINER_DENSE_SET_HPP
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "../config/config.h"
+#include "../core/compressed_pair.hpp"
+#include "../core/memory.hpp"
+#include "../core/type_traits.hpp"
+#include "fwd.hpp"
+
+namespace entt {
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename It>
+class dense_set_iterator final {
+    template<typename>
+    friend class dense_set_iterator;
+
+public:
+    using value_type = typename It::value_type::second_type;
+    using pointer = const value_type *;
+    using reference = const value_type &;
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::random_access_iterator_tag;
+
+    dense_set_iterator() ENTT_NOEXCEPT
+        : it{} {}
+
+    dense_set_iterator(const It iter) ENTT_NOEXCEPT
+        : it{iter} {}
+
+    template<typename Other, typename = std::enable_if_t<!std::is_same_v<It, Other> && std::is_constructible_v<It, Other>>>
+    dense_set_iterator(const dense_set_iterator<Other> &other) ENTT_NOEXCEPT
+        : it{other.it} {}
+
+    dense_set_iterator &operator++() ENTT_NOEXCEPT {
+        return ++it, *this;
+    }
+
+    dense_set_iterator operator++(int) ENTT_NOEXCEPT {
+        dense_set_iterator orig = *this;
+        return ++(*this), orig;
+    }
+
+    dense_set_iterator &operator--() ENTT_NOEXCEPT {
+        return --it, *this;
+    }
+
+    dense_set_iterator operator--(int) ENTT_NOEXCEPT {
+        dense_set_iterator orig = *this;
+        return operator--(), orig;
+    }
+
+    dense_set_iterator &operator+=(const difference_type value) ENTT_NOEXCEPT {
+        it += value;
+        return *this;
+    }
+
+    dense_set_iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
+        dense_set_iterator copy = *this;
+        return (copy += value);
+    }
+
+    dense_set_iterator &operator-=(const difference_type value) ENTT_NOEXCEPT {
+        return (*this += -value);
+    }
+
+    dense_set_iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
+        return (*this + -value);
+    }
+
+    [[nodiscard]] reference operator[](const difference_type value) const ENTT_NOEXCEPT {
+        return it[value].second;
+    }
+
+    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
+        return std::addressof(it->second);
+    }
+
+    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
+        return *operator->();
+    }
+
+    template<typename ILhs, typename IRhs>
+    friend std::ptrdiff_t operator-(const dense_set_iterator<ILhs> &, const dense_set_iterator<IRhs> &) ENTT_NOEXCEPT;
+
+    template<typename ILhs, typename IRhs>
+    friend bool operator==(const dense_set_iterator<ILhs> &, const dense_set_iterator<IRhs> &) ENTT_NOEXCEPT;
+
+    template<typename ILhs, typename IRhs>
+    friend bool operator<(const dense_set_iterator<ILhs> &, const dense_set_iterator<IRhs> &) ENTT_NOEXCEPT;
+
+private:
+    It it;
+};
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] std::ptrdiff_t operator-(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.it - rhs.it;
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator==(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.it == rhs.it;
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator!=(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator<(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.it < rhs.it;
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator>(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return rhs < lhs;
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator<=(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs > rhs);
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator>=(const dense_set_iterator<ILhs> &lhs, const dense_set_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs < rhs);
+}
+
+template<typename It>
+class dense_set_local_iterator final {
+    template<typename>
+    friend class dense_set_local_iterator;
+
+public:
+    using value_type = typename It::value_type::second_type;
+    using pointer = const value_type *;
+    using reference = const value_type &;
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::forward_iterator_tag;
+
+    dense_set_local_iterator() ENTT_NOEXCEPT
+        : it{},
+          offset{} {}
+
+    dense_set_local_iterator(It iter, const std::size_t pos) ENTT_NOEXCEPT
+        : it{iter},
+          offset{pos} {}
+
+    template<typename Other, typename = std::enable_if_t<!std::is_same_v<It, Other> && std::is_constructible_v<It, Other>>>
+    dense_set_local_iterator(const dense_set_local_iterator<Other> &other) ENTT_NOEXCEPT
+        : it{other.it},
+          offset{other.offset} {}
+
+    dense_set_local_iterator &operator++() ENTT_NOEXCEPT {
+        return offset = it[offset].first, *this;
+    }
+
+    dense_set_local_iterator operator++(int) ENTT_NOEXCEPT {
+        dense_set_local_iterator orig = *this;
+        return ++(*this), orig;
+    }
+
+    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
+        return std::addressof(it[offset].second);
+    }
+
+    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
+        return *operator->();
+    }
+
+    [[nodiscard]] std::size_t index() const ENTT_NOEXCEPT {
+        return offset;
+    }
+
+private:
+    It it;
+    std::size_t offset;
+};
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator==(const dense_set_local_iterator<ILhs> &lhs, const dense_set_local_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.index() == rhs.index();
+}
+
+template<typename ILhs, typename IRhs>
+[[nodiscard]] bool operator!=(const dense_set_local_iterator<ILhs> &lhs, const dense_set_local_iterator<IRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Associative container for unique objects of a given type.
+ *
+ * Internally, elements are organized into buckets. Which bucket an element is
+ * placed into depends entirely on its hash. Elements with the same hash code
+ * appear in the same bucket.
+ *
+ * @tparam Type Value type of the associative container.
+ * @tparam Hash Type of function to use to hash the values.
+ * @tparam KeyEqual Type of function to use to compare the values for equality.
+ * @tparam Allocator Type of allocator used to manage memory and elements.
+ */
+template<typename Type, typename Hash, typename KeyEqual, typename Allocator>
+class dense_set {
+    static constexpr float default_threshold = 0.875f;
+    static constexpr std::size_t minimum_capacity = 8u;
+
+    using node_type = std::pair<std::size_t, Type>;
+    using alloc_traits = std::allocator_traits<Allocator>;
+    static_assert(std::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
+    using sparse_container_type = std::vector<std::size_t, typename alloc_traits::template rebind_alloc<std::size_t>>;
+    using packed_container_type = std::vector<node_type, typename alloc_traits::template rebind_alloc<node_type>>;
+
+    template<typename Other>
+    [[nodiscard]] std::size_t value_to_bucket(const Other &value) const ENTT_NOEXCEPT {
+        return fast_mod(sparse.second()(value), bucket_count());
+    }
+
+    template<typename Other>
+    [[nodiscard]] auto constrained_find(const Other &value, std::size_t bucket) {
+        for(auto it = begin(bucket), last = end(bucket); it != last; ++it) {
+            if(packed.second()(*it, value)) {
+                return begin() + static_cast<typename iterator::difference_type>(it.index());
+            }
+        }
+
+        return end();
+    }
+
+    template<typename Other>
+    [[nodiscard]] auto constrained_find(const Other &value, std::size_t bucket) const {
+        for(auto it = cbegin(bucket), last = cend(bucket); it != last; ++it) {
+            if(packed.second()(*it, value)) {
+                return cbegin() + static_cast<typename iterator::difference_type>(it.index());
+            }
+        }
+
+        return cend();
+    }
+
+    template<typename Other>
+    [[nodiscard]] auto insert_or_do_nothing(Other &&value) {
+        const auto index = value_to_bucket(value);
+
+        if(auto it = constrained_find(value, index); it != end()) {
+            return std::make_pair(it, false);
+        }
+
+        packed.first().emplace_back(sparse.first()[index], std::forward<Other>(value));
+        sparse.first()[index] = packed.first().size() - 1u;
+        rehash_if_required();
+
+        return std::make_pair(--end(), true);
+    }
+
+    void move_and_pop(const std::size_t pos) {
+        if(const auto last = size() - 1u; pos != last) {
+            packed.first()[pos] = std::move(packed.first().back());
+            size_type *curr = sparse.first().data() + value_to_bucket(packed.first().back().second);
+            for(; *curr != last; curr = &packed.first()[*curr].first) {}
+            *curr = pos;
+        }
+
+        packed.first().pop_back();
+    }
+
+    void rehash_if_required() {
+        if(size() > (bucket_count() * max_load_factor())) {
+            rehash(bucket_count() * 2u);
+        }
+    }
+
+public:
+    /*! @brief Key type of the container. */
+    using key_type = Type;
+    /*! @brief Value type of the container. */
+    using value_type = Type;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+    /*! @brief Type of function to use to hash the elements. */
+    using hasher = Hash;
+    /*! @brief Type of function to use to compare the elements for equality. */
+    using key_equal = KeyEqual;
+    /*! @brief Allocator type. */
+    using allocator_type = Allocator;
+    /*! @brief Random access iterator type. */
+    using iterator = internal::dense_set_iterator<typename packed_container_type::iterator>;
+    /*! @brief Constant random access iterator type. */
+    using const_iterator = internal::dense_set_iterator<typename packed_container_type::const_iterator>;
+    /*! @brief Forward iterator type. */
+    using local_iterator = internal::dense_set_local_iterator<typename packed_container_type::iterator>;
+    /*! @brief Constant forward iterator type. */
+    using const_local_iterator = internal::dense_set_local_iterator<typename packed_container_type::const_iterator>;
+
+    /*! @brief Default constructor. */
+    dense_set()
+        : dense_set(minimum_capacity) {}
+
+    /**
+     * @brief Constructs an empty container with a given allocator.
+     * @param allocator The allocator to use.
+     */
+    explicit dense_set(const allocator_type &allocator)
+        : dense_set{minimum_capacity, hasher{}, key_equal{}, allocator} {}
+
+    /**
+     * @brief Constructs an empty container with a given allocator and user
+     * supplied minimal number of buckets.
+     * @param bucket_count Minimal number of buckets.
+     * @param allocator The allocator to use.
+     */
+    dense_set(const size_type bucket_count, const allocator_type &allocator)
+        : dense_set{bucket_count, hasher{}, key_equal{}, allocator} {}
+
+    /**
+     * @brief Constructs an empty container with a given allocator, hash
+     * function and user supplied minimal number of buckets.
+     * @param bucket_count Minimal number of buckets.
+     * @param hash Hash function to use.
+     * @param allocator The allocator to use.
+     */
+    dense_set(const size_type bucket_count, const hasher &hash, const allocator_type &allocator)
+        : dense_set{bucket_count, hash, key_equal{}, allocator} {}
+
+    /**
+     * @brief Constructs an empty container with a given allocator, hash
+     * function, compare function and user supplied minimal number of buckets.
+     * @param bucket_count Minimal number of buckets.
+     * @param hash Hash function to use.
+     * @param equal Compare function to use.
+     * @param allocator The allocator to use.
+     */
+    explicit dense_set(const size_type bucket_count, const hasher &hash = hasher{}, const key_equal &equal = key_equal{}, const allocator_type &allocator = allocator_type{})
+        : sparse{allocator, hash},
+          packed{allocator, equal},
+          threshold{default_threshold} {
+        rehash(bucket_count);
+    }
+
+    /*! @brief Default copy constructor. */
+    dense_set(const dense_set &) = default;
+
+    /**
+     * @brief Allocator-extended copy constructor.
+     * @param other The instance to copy from.
+     * @param allocator The allocator to use.
+     */
+    dense_set(const dense_set &other, const allocator_type &allocator)
+        : sparse{std::piecewise_construct, std::forward_as_tuple(other.sparse.first(), allocator), std::forward_as_tuple(other.sparse.second())},
+          packed{std::piecewise_construct, std::forward_as_tuple(other.packed.first(), allocator), std::forward_as_tuple(other.packed.second())},
+          threshold{other.threshold} {}
+
+    /*! @brief Default move constructor. */
+    dense_set(dense_set &&) = default;
+
+    /**
+     * @brief Allocator-extended move constructor.
+     * @param other The instance to move from.
+     * @param allocator The allocator to use.
+     */
+    dense_set(dense_set &&other, const allocator_type &allocator)
+        : sparse{std::piecewise_construct, std::forward_as_tuple(std::move(other.sparse.first()), allocator), std::forward_as_tuple(std::move(other.sparse.second()))},
+          packed{std::piecewise_construct, std::forward_as_tuple(std::move(other.packed.first()), allocator), std::forward_as_tuple(std::move(other.packed.second()))},
+          threshold{other.threshold} {}
+
+    /**
+     * @brief Default copy assignment operator.
+     * @return This container.
+     */
+    dense_set &operator=(const dense_set &) = default;
+
+    /**
+     * @brief Default move assignment operator.
+     * @return This container.
+     */
+    dense_set &operator=(dense_set &&) = default;
+
+    /**
+     * @brief Returns the associated allocator.
+     * @return The associated allocator.
+     */
+    [[nodiscard]] constexpr allocator_type get_allocator() const ENTT_NOEXCEPT {
+        return sparse.first().get_allocator();
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning.
+     *
+     * The returned iterator points to the first instance of the internal array.
+     * If the array is empty, the returned iterator will be equal to `end()`.
+     *
+     * @return An iterator to the first instance of the internal array.
+     */
+    [[nodiscard]] const_iterator cbegin() const ENTT_NOEXCEPT {
+        return packed.first().begin();
+    }
+
+    /*! @copydoc cbegin */
+    [[nodiscard]] const_iterator begin() const ENTT_NOEXCEPT {
+        return cbegin();
+    }
+
+    /*! @copydoc begin */
+    [[nodiscard]] iterator begin() ENTT_NOEXCEPT {
+        return packed.first().begin();
+    }
+
+    /**
+     * @brief Returns an iterator to the end.
+     *
+     * The returned iterator points to the element following the last instance
+     * of the internal array. Attempting to dereference the returned iterator
+     * results in undefined behavior.
+     *
+     * @return An iterator to the element following the last instance of the
+     * internal array.
+     */
+    [[nodiscard]] const_iterator cend() const ENTT_NOEXCEPT {
+        return packed.first().end();
+    }
+
+    /*! @copydoc cend */
+    [[nodiscard]] const_iterator end() const ENTT_NOEXCEPT {
+        return cend();
+    }
+
+    /*! @copydoc end */
+    [[nodiscard]] iterator end() ENTT_NOEXCEPT {
+        return packed.first().end();
+    }
+
+    /**
+     * @brief Checks whether a container is empty.
+     * @return True if the container is empty, false otherwise.
+     */
+    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
+        return packed.first().empty();
+    }
+
+    /**
+     * @brief Returns the number of elements in a container.
+     * @return Number of elements in a container.
+     */
+    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
+        return packed.first().size();
+    }
+
+    /*! @brief Clears the container. */
+    void clear() ENTT_NOEXCEPT {
+        sparse.first().clear();
+        packed.first().clear();
+        rehash(0u);
+    }
+
+    /**
+     * @brief Inserts an element into the container, if it does not exist.
+     * @param value An element to insert into the container.
+     * @return A pair consisting of an iterator to the inserted element (or to
+     * the element that prevented the insertion) and a bool denoting whether the
+     * insertion took place.
+     */
+    std::pair<iterator, bool> insert(const value_type &value) {
+        return insert_or_do_nothing(value);
+    }
+
+    /*! @copydoc insert */
+    std::pair<iterator, bool> insert(value_type &&value) {
+        return insert_or_do_nothing(std::move(value));
+    }
+
+    /**
+     * @brief Inserts elements into the container, if they do not exist.
+     * @tparam It Type of input iterator.
+     * @param first An iterator to the first element of the range of elements.
+     * @param last An iterator past the last element of the range of elements.
+     */
+    template<typename It>
+    void insert(It first, It last) {
+        for(; first != last; ++first) {
+            insert(*first);
+        }
+    }
+
+    /**
+     * @brief Constructs an element in-place, if it does not exist.
+     *
+     * The element is also constructed when the container already has the key,
+     * in which case the newly constructed object is destroyed immediately.
+     *
+     * @tparam Args Types of arguments to forward to the constructor of the
+     * element.
+     * @param args Arguments to forward to the constructor of the element.
+     * @return A pair consisting of an iterator to the inserted element (or to
+     * the element that prevented the insertion) and a bool denoting whether the
+     * insertion took place.
+     */
+    template<typename... Args>
+    std::pair<iterator, bool> emplace(Args &&...args) {
+        if constexpr(((sizeof...(Args) == 1u) && ... && std::is_same_v<std::remove_cv_t<std::remove_reference_t<Args>>, value_type>)) {
+            return insert_or_do_nothing(std::forward<Args>(args)...);
+        } else {
+            auto &node = packed.first().emplace_back(std::piecewise_construct, std::make_tuple(packed.first().size()), std::forward_as_tuple(std::forward<Args>(args)...));
+            const auto index = value_to_bucket(node.second);
+
+            if(auto it = constrained_find(node.second, index); it != end()) {
+                packed.first().pop_back();
+                return std::make_pair(it, false);
+            }
+
+            std::swap(node.first, sparse.first()[index]);
+            rehash_if_required();
+
+            return std::make_pair(--end(), true);
+        }
+    }
+
+    /**
+     * @brief Removes an element from a given position.
+     * @param pos An iterator to the element to remove.
+     * @return An iterator following the removed element.
+     */
+    iterator erase(const_iterator pos) {
+        const auto diff = pos - cbegin();
+        erase(*pos);
+        return begin() + diff;
+    }
+
+    /**
+     * @brief Removes the given elements from a container.
+     * @param first An iterator to the first element of the range of elements.
+     * @param last An iterator past the last element of the range of elements.
+     * @return An iterator following the last removed element.
+     */
+    iterator erase(const_iterator first, const_iterator last) {
+        const auto dist = first - cbegin();
+
+        for(auto from = last - cbegin(); from != dist; --from) {
+            erase(packed.first()[from - 1u].second);
+        }
+
+        return (begin() + dist);
+    }
+
+    /**
+     * @brief Removes the element associated with a given value.
+     * @param value Value of an element to remove.
+     * @return Number of elements removed (either 0 or 1).
+     */
+    size_type erase(const value_type &value) {
+        for(size_type *curr = sparse.first().data() + value_to_bucket(value); *curr != (std::numeric_limits<size_type>::max)(); curr = &packed.first()[*curr].first) {
+            if(packed.second()(packed.first()[*curr].second, value)) {
+                const auto index = *curr;
+                *curr = packed.first()[*curr].first;
+                move_and_pop(index);
+                return 1u;
+            }
+        }
+
+        return 0u;
+    }
+
+    /**
+     * @brief Exchanges the contents with those of a given container.
+     * @param other Container to exchange the content with.
+     */
+    void swap(dense_set &other) {
+        using std::swap;
+        swap(sparse, other.sparse);
+        swap(packed, other.packed);
+        swap(threshold, other.threshold);
+    }
+
+    /**
+     * @brief Finds an element with a given value.
+     * @param value Value of an element to search for.
+     * @return An iterator to an element with the given value. If no such
+     * element is found, a past-the-end iterator is returned.
+     */
+    [[nodiscard]] iterator find(const value_type &value) {
+        return constrained_find(value, value_to_bucket(value));
+    }
+
+    /*! @copydoc find */
+    [[nodiscard]] const_iterator find(const value_type &value) const {
+        return constrained_find(value, value_to_bucket(value));
+    }
+
+    /**
+     * @brief Finds an element that compares _equivalent_ to a given value.
+     * @tparam Other Type of an element to search for.
+     * @param value Value of an element to search for.
+     * @return An iterator to an element with the given value. If no such
+     * element is found, a past-the-end iterator is returned.
+     */
+    template<typename Other>
+    [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, iterator>>
+    find(const Other &value) {
+        return constrained_find(value, value_to_bucket(value));
+    }
+
+    /*! @copydoc find */
+    template<typename Other>
+    [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, const_iterator>>
+    find(const Other &value) const {
+        return constrained_find(value, value_to_bucket(value));
+    }
+
+    /**
+     * @brief Checks if the container contains an element with a given value.
+     * @param value Value of an element to search for.
+     * @return True if there is such an element, false otherwise.
+     */
+    [[nodiscard]] bool contains(const value_type &value) const {
+        return (find(value) != cend());
+    }
+
+    /**
+     * @brief Checks if the container contains an element that compares
+     * _equivalent_ to a given value.
+     * @tparam Other Type of an element to search for.
+     * @param value Value of an element to search for.
+     * @return True if there is such an element, false otherwise.
+     */
+    template<typename Other>
+    [[nodiscard]] std::enable_if_t<is_transparent_v<hasher> && is_transparent_v<key_equal>, std::conditional_t<false, Other, bool>>
+    contains(const Other &value) const {
+        return (find(value) != cend());
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the beginning of the given bucket.
+     */
+    [[nodiscard]] const_local_iterator cbegin(const size_type index) const {
+        return {packed.first().begin(), sparse.first()[index]};
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the beginning of the given bucket.
+     */
+    [[nodiscard]] const_local_iterator begin(const size_type index) const {
+        return cbegin(index);
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the beginning of the given bucket.
+     */
+    [[nodiscard]] local_iterator begin(const size_type index) {
+        return {packed.first().begin(), sparse.first()[index]};
+    }
+
+    /**
+     * @brief Returns an iterator to the end of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the end of the given bucket.
+     */
+    [[nodiscard]] const_local_iterator cend([[maybe_unused]] const size_type index) const {
+        return {packed.first().begin(), (std::numeric_limits<size_type>::max)()};
+    }
+
+    /**
+     * @brief Returns an iterator to the end of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the end of the given bucket.
+     */
+    [[nodiscard]] const_local_iterator end([[maybe_unused]] const size_type index) const {
+        return cend(index);
+    }
+
+    /**
+     * @brief Returns an iterator to the end of a given bucket.
+     * @param index An index of a bucket to access.
+     * @return An iterator to the end of the given bucket.
+     */
+    [[nodiscard]] local_iterator end([[maybe_unused]] const size_type index) {
+        return {packed.first().begin(), (std::numeric_limits<size_type>::max)()};
+    }
+
+    /**
+     * @brief Returns the number of buckets.
+     * @return The number of buckets.
+     */
+    [[nodiscard]] size_type bucket_count() const {
+        return sparse.first().size();
+    }
+
+    /**
+     * @brief Returns the maximum number of buckets.
+     * @return The maximum number of buckets.
+     */
+    [[nodiscard]] size_type max_bucket_count() const {
+        return sparse.first().max_size();
+    }
+
+    /**
+     * @brief Returns the number of elements in a given bucket.
+     * @param index The index of the bucket to examine.
+     * @return The number of elements in the given bucket.
+     */
+    [[nodiscard]] size_type bucket_size(const size_type index) const {
+        return static_cast<size_type>(std::distance(begin(index), end(index)));
+    }
+
+    /**
+     * @brief Returns the bucket for a given element.
+     * @param value The value of the element to examine.
+     * @return The bucket for the given element.
+     */
+    [[nodiscard]] size_type bucket(const value_type &value) const {
+        return value_to_bucket(value);
+    }
+
+    /**
+     * @brief Returns the average number of elements per bucket.
+     * @return The average number of elements per bucket.
+     */
+    [[nodiscard]] float load_factor() const {
+        return size() / static_cast<float>(bucket_count());
+    }
+
+    /**
+     * @brief Returns the maximum average number of elements per bucket.
+     * @return The maximum average number of elements per bucket.
+     */
+    [[nodiscard]] float max_load_factor() const {
+        return threshold;
+    }
+
+    /**
+     * @brief Sets the desired maximum average number of elements per bucket.
+     * @param value A desired maximum average number of elements per bucket.
+     */
+    void max_load_factor(const float value) {
+        ENTT_ASSERT(value > 0.f, "Invalid load factor");
+        threshold = value;
+        rehash(0u);
+    }
+
+    /**
+     * @brief Reserves at least the specified number of buckets and regenerates
+     * the hash table.
+     * @param count New number of buckets.
+     */
+    void rehash(const size_type count) {
+        auto value = (std::max)(count, minimum_capacity);
+        value = (std::max)(value, static_cast<size_type>(size() / max_load_factor()));
+
+        if(const auto sz = next_power_of_two(value); sz != bucket_count()) {
+            sparse.first().resize(sz);
+            std::fill(sparse.first().begin(), sparse.first().end(), (std::numeric_limits<size_type>::max)());
+
+            for(size_type pos{}, last = size(); pos < last; ++pos) {
+                const auto index = value_to_bucket(packed.first()[pos].second);
+                packed.first()[pos].first = std::exchange(sparse.first()[index], pos);
+            }
+        }
+    }
+
+    /**
+     * @brief Reserves space for at least the specified number of elements and
+     * regenerates the hash table.
+     * @param count New number of elements.
+     */
+    void reserve(const size_type count) {
+        packed.first().reserve(count);
+        rehash(static_cast<size_type>(std::ceil(count / max_load_factor())));
+    }
+
+    /**
+     * @brief Returns the function used to hash the elements.
+     * @return The function used to hash the elements.
+     */
+    [[nodiscard]] hasher hash_function() const {
+        return sparse.second();
+    }
+
+    /**
+     * @brief Returns the function used to compare elements for equality.
+     * @return The function used to compare elements for equality.
+     */
+    [[nodiscard]] key_equal key_eq() const {
+        return packed.second();
+    }
+
+private:
+    compressed_pair<sparse_container_type, hasher> sparse;
+    compressed_pair<packed_container_type, key_equal> packed;
+    float threshold;
+};
+
+} // namespace entt
+
+#endif

src/entt/container/fwd.hpp

@@ -0,0 +1,26 @@
+#ifndef ENTT_CONTAINER_FWD_HPP
+#define ENTT_CONTAINER_FWD_HPP
+
+#include <functional>
+#include <memory>
+
+namespace entt {
+
+template<
+    typename Key,
+    typename Type,
+    typename = std::hash<Key>,
+    typename = std::equal_to<Key>,
+    typename = std::allocator<std::pair<const Key, Type>>>
+class dense_map;
+
+template<
+    typename Type,
+    typename = std::hash<Type>,
+    typename = std::equal_to<Type>,
+    typename = std::allocator<Type>>
+class dense_set;
+
+} // namespace entt
+
+#endif

src/entt/core/algorithm.hpp

@@ -0,0 +1,137 @@
+#ifndef ENTT_CORE_ALGORITHM_HPP
+#define ENTT_CORE_ALGORITHM_HPP
+
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <utility>
+#include <vector>
+#include "utility.hpp"
+
+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 std_sort {
+    /**
+     * @brief Sorts the elements in a range.
+     *
+     * Sorts the elements in a range using the given binary comparison function.
+     *
+     * @tparam It Type of random access iterator.
+     * @tparam Compare Type of comparison function object.
+     * @tparam Args Types of arguments to forward to the sort function.
+     * @param first An iterator to the first element of the range to sort.
+     * @param last An iterator past the last element of the range to sort.
+     * @param compare A valid comparison function object.
+     * @param args Arguments to forward to the sort function, if any.
+     */
+    template<typename It, typename Compare = std::less<>, typename... Args>
+    void operator()(It first, It last, Compare compare = Compare{}, Args &&...args) const {
+        std::sort(std::forward<Args>(args)..., std::move(first), std::move(last), std::move(compare));
+    }
+};
+
+/*! @brief Function object for performing insertion sort. */
+struct insertion_sort {
+    /**
+     * @brief Sorts the elements in a range.
+     *
+     * Sorts the elements in a range using the given binary comparison function.
+     *
+     * @tparam It Type of random access iterator.
+     * @tparam Compare Type of comparison function object.
+     * @param first An iterator to the first element of the range to sort.
+     * @param last An iterator past the last element of the range to sort.
+     * @param compare A valid comparison function object.
+     */
+    template<typename It, typename Compare = std::less<>>
+    void operator()(It first, It last, Compare compare = Compare{}) const {
+        if(first < last) {
+            for(auto it = first + 1; it < last; ++it) {
+                auto value = std::move(*it);
+                auto pre = it;
+
+                for(; pre > first && compare(value, *(pre - 1)); --pre) {
+                    *pre = std::move(*(pre - 1));
+                }
+
+                *pre = std::move(value);
+            }
+        }
+    }
+};
+
+/**
+ * @brief Function object for performing LSD radix sort.
+ * @tparam Bit Number of bits processed per pass.
+ * @tparam N Maximum number of bits to sort.
+ */
+template<std::size_t Bit, std::size_t N>
+struct radix_sort {
+    static_assert((N % Bit) == 0, "The maximum number of bits to sort must be a multiple of the number of bits processed per pass");
+
+    /**
+     * @brief Sorts the elements in a range.
+     *
+     * Sorts the elements in a range using the given _getter_ to access the
+     * actual data to be sorted.
+     *
+     * This implementation is inspired by the online book
+     * [Physically Based Rendering](http://www.pbr-book.org/3ed-2018/Primitives_and_Intersection_Acceleration/Bounding_Volume_Hierarchies.html#RadixSort).
+     *
+     * @tparam It Type of random access iterator.
+     * @tparam Getter Type of _getter_ 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 getter A valid _getter_ function object.
+     */
+    template<typename It, typename Getter = identity>
+    void operator()(It first, It last, Getter getter = Getter{}) const {
+        if(first < last) {
+            static constexpr auto mask = (1 << Bit) - 1;
+            static constexpr auto buckets = 1 << Bit;
+            static constexpr auto passes = N / Bit;
+
+            using value_type = typename std::iterator_traits<It>::value_type;
+            std::vector<value_type> aux(std::distance(first, last));
+
+            auto part = [getter = std::move(getter)](auto from, auto to, auto out, auto start) {
+                std::size_t index[buckets]{};
+                std::size_t count[buckets]{};
+
+                for(auto it = from; it != to; ++it) {
+                    ++count[(getter(*it) >> start) & mask];
+                }
+
+                for(std::size_t pos{}, end = buckets - 1u; pos < end; ++pos) {
+                    index[pos + 1u] = index[pos] + count[pos];
+                }
+
+                for(auto it = from; it != to; ++it) {
+                    out[index[(getter(*it) >> start) & mask]++] = std::move(*it);
+                }
+            };
+
+            for(std::size_t pass = 0; pass < (passes & ~1); pass += 2) {
+                part(first, last, aux.begin(), pass * Bit);
+                part(aux.begin(), aux.end(), first, (pass + 1) * Bit);
+            }
+
+            if constexpr(passes & 1) {
+                part(first, last, aux.begin(), (passes - 1) * Bit);
+                std::move(aux.begin(), aux.end(), first);
+            }
+        }
+    }
+};
+
+} // namespace entt
+
+#endif

src/entt/core/any.hpp

@@ -0,0 +1,490 @@
+#ifndef ENTT_CORE_ANY_HPP
+#define ENTT_CORE_ANY_HPP
+
+#include <cstddef>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+#include "../core/utility.hpp"
+#include "fwd.hpp"
+#include "type_info.hpp"
+#include "type_traits.hpp"
+
+namespace entt {
+
+/**
+ * @brief A SBO friendly, type-safe container for single values of any type.
+ * @tparam Len Size of the storage reserved for the small buffer optimization.
+ * @tparam Align Optional alignment requirement.
+ */
+template<std::size_t Len, std::size_t Align>
+class basic_any {
+    enum class operation : std::uint8_t {
+        copy,
+        move,
+        transfer,
+        assign,
+        destroy,
+        compare,
+        get
+    };
+
+    enum class policy : std::uint8_t {
+        owner,
+        ref,
+        cref
+    };
+
+    using storage_type = std::aligned_storage_t<Len + !Len, Align>;
+    using vtable_type = const void *(const operation, const basic_any &, const void *);
+
+    template<typename Type>
+    static constexpr bool in_situ = Len && alignof(Type) <= alignof(storage_type) && sizeof(Type) <= sizeof(storage_type) && std::is_nothrow_move_constructible_v<Type>;
+
+    template<typename Type>
+    static const void *basic_vtable([[maybe_unused]] const operation op, [[maybe_unused]] const basic_any &value, [[maybe_unused]] const void *other) {
+        static_assert(!std::is_same_v<Type, void> && std::is_same_v<std::remove_cv_t<std::remove_reference_t<Type>>, Type>, "Invalid type");
+        const Type *element = nullptr;
+
+        if constexpr(in_situ<Type>) {
+            element = value.owner() ? reinterpret_cast<const Type *>(&value.storage) : static_cast<const Type *>(value.instance);
+        } else {
+            element = static_cast<const Type *>(value.instance);
+        }
+
+        switch(op) {
+        case operation::copy:
+            if constexpr(std::is_copy_constructible_v<Type>) {
+                static_cast<basic_any *>(const_cast<void *>(other))->initialize<Type>(*element);
+            }
+            break;
+        case operation::move:
+            if constexpr(in_situ<Type>) {
+                if(value.owner()) {
+                    return new(&static_cast<basic_any *>(const_cast<void *>(other))->storage) Type{std::move(*const_cast<Type *>(element))};
+                }
+            }
+
+            return (static_cast<basic_any *>(const_cast<void *>(other))->instance = std::exchange(const_cast<basic_any &>(value).instance, nullptr));
+        case operation::transfer:
+            if constexpr(std::is_move_assignable_v<Type>) {
+                *const_cast<Type *>(element) = std::move(*static_cast<Type *>(const_cast<void *>(other)));
+                return other;
+            }
+            [[fallthrough]];
+        case operation::assign:
+            if constexpr(std::is_copy_assignable_v<Type>) {
+                *const_cast<Type *>(element) = *static_cast<const Type *>(other);
+                return other;
+            }
+            break;
+        case operation::destroy:
+            if constexpr(in_situ<Type>) {
+                element->~Type();
+            } else if constexpr(std::is_array_v<Type>) {
+                delete[] element;
+            } else {
+                delete element;
+            }
+            break;
+        case operation::compare:
+            if constexpr(!std::is_function_v<Type> && !std::is_array_v<Type> && is_equality_comparable_v<Type>) {
+                return *static_cast<const Type *>(element) == *static_cast<const Type *>(other) ? other : nullptr;
+            } else {
+                return (element == other) ? other : nullptr;
+            }
+        case operation::get:
+            return element;
+        }
+
+        return nullptr;
+    }
+
+    template<typename Type, typename... Args>
+    void initialize([[maybe_unused]] Args &&...args) {
+        if constexpr(!std::is_void_v<Type>) {
+            info = &type_id<std::remove_cv_t<std::remove_reference_t<Type>>>();
+            vtable = basic_vtable<std::remove_cv_t<std::remove_reference_t<Type>>>;
+
+            if constexpr(std::is_lvalue_reference_v<Type>) {
+                static_assert(sizeof...(Args) == 1u && (std::is_lvalue_reference_v<Args> && ...), "Invalid arguments");
+                mode = std::is_const_v<std::remove_reference_t<Type>> ? policy::cref : policy::ref;
+                instance = (std::addressof(args), ...);
+            } else if constexpr(in_situ<Type>) {
+                if constexpr(sizeof...(Args) != 0u && std::is_aggregate_v<Type>) {
+                    new(&storage) Type{std::forward<Args>(args)...};
+                } else {
+                    new(&storage) Type(std::forward<Args>(args)...);
+                }
+            } else {
+                if constexpr(sizeof...(Args) != 0u && std::is_aggregate_v<Type>) {
+                    instance = new Type{std::forward<Args>(args)...};
+                } else {
+                    instance = new Type(std::forward<Args>(args)...);
+                }
+            }
+        }
+    }
+
+    basic_any(const basic_any &other, const policy pol) ENTT_NOEXCEPT
+        : instance{other.data()},
+          info{other.info},
+          vtable{other.vtable},
+          mode{pol} {}
+
+public:
+    /*! @brief Size of the internal storage. */
+    static constexpr auto length = Len;
+    /*! @brief Alignment requirement. */
+    static constexpr auto alignment = Align;
+
+    /*! @brief Default constructor. */
+    constexpr basic_any() ENTT_NOEXCEPT
+        : instance{},
+          info{&type_id<void>()},
+          vtable{},
+          mode{policy::owner} {}
+
+    /**
+     * @brief Constructs a wrapper by directly initializing the new object.
+     * @tparam Type Type of object to use to initialize the wrapper.
+     * @tparam Args Types of arguments to use to construct the new instance.
+     * @param args Parameters to use to construct the instance.
+     */
+    template<typename Type, typename... Args>
+    explicit basic_any(std::in_place_type_t<Type>, Args &&...args)
+        : basic_any{} {
+        initialize<Type>(std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Constructs a wrapper from a given value.
+     * @tparam Type Type of object to use to initialize the wrapper.
+     * @param value An instance of an object to use to initialize the wrapper.
+     */
+    template<typename Type, typename = std::enable_if_t<!std::is_same_v<std::decay_t<Type>, basic_any>>>
+    basic_any(Type &&value)
+        : basic_any{} {
+        initialize<std::decay_t<Type>>(std::forward<Type>(value));
+    }
+
+    /**
+     * @brief Copy constructor.
+     * @param other The instance to copy from.
+     */
+    basic_any(const basic_any &other)
+        : basic_any{} {
+        if(other.vtable) {
+            other.vtable(operation::copy, other, this);
+        }
+    }
+
+    /**
+     * @brief Move constructor.
+     * @param other The instance to move from.
+     */
+    basic_any(basic_any &&other) ENTT_NOEXCEPT
+        : instance{},
+          info{other.info},
+          vtable{other.vtable},
+          mode{other.mode} {
+        if(other.vtable) {
+            other.vtable(operation::move, other, this);
+        }
+    }
+
+    /*! @brief Frees the internal storage, whatever it means. */
+    ~basic_any() {
+        if(vtable && owner()) {
+            vtable(operation::destroy, *this, nullptr);
+        }
+    }
+
+    /**
+     * @brief Copy assignment operator.
+     * @param other The instance to copy from.
+     * @return This any object.
+     */
+    basic_any &operator=(const basic_any &other) {
+        reset();
+
+        if(other.vtable) {
+            other.vtable(operation::copy, other, this);
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Move assignment operator.
+     * @param other The instance to move from.
+     * @return This any object.
+     */
+    basic_any &operator=(basic_any &&other) ENTT_NOEXCEPT {
+        reset();
+
+        if(other.vtable) {
+            other.vtable(operation::move, other, this);
+            info = other.info;
+            vtable = other.vtable;
+            mode = other.mode;
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Value assignment operator.
+     * @tparam Type Type of object to use to initialize the wrapper.
+     * @param value An instance of an object to use to initialize the wrapper.
+     * @return This any object.
+     */
+    template<typename Type>
+    std::enable_if_t<!std::is_same_v<std::decay_t<Type>, basic_any>, basic_any &>
+    operator=(Type &&value) {
+        emplace<std::decay_t<Type>>(std::forward<Type>(value));
+        return *this;
+    }
+
+    /**
+     * @brief Returns the object type if any, `type_id<void>()` otherwise.
+     * @return The object type if any, `type_id<void>()` otherwise.
+     */
+    [[nodiscard]] const type_info &type() const ENTT_NOEXCEPT {
+        return *info;
+    }
+
+    /**
+     * @brief Returns an opaque pointer to the contained instance.
+     * @return An opaque pointer the contained instance, if any.
+     */
+    [[nodiscard]] const void *data() const ENTT_NOEXCEPT {
+        return vtable ? vtable(operation::get, *this, nullptr) : nullptr;
+    }
+
+    /**
+     * @brief Returns an opaque pointer to the contained instance.
+     * @param req Expected type.
+     * @return An opaque pointer the contained instance, if any.
+     */
+    [[nodiscard]] const void *data(const type_info &req) const ENTT_NOEXCEPT {
+        return *info == req ? data() : nullptr;
+    }
+
+    /**
+     * @brief Returns an opaque pointer to the contained instance.
+     * @return An opaque pointer the contained instance, if any.
+     */
+    [[nodiscard]] void *data() ENTT_NOEXCEPT {
+        return (!vtable || mode == policy::cref) ? nullptr : const_cast<void *>(vtable(operation::get, *this, nullptr));
+    }
+
+    /**
+     * @brief Returns an opaque pointer to the contained instance.
+     * @param req Expected type.
+     * @return An opaque pointer the contained instance, if any.
+     */
+    [[nodiscard]] void *data(const type_info &req) ENTT_NOEXCEPT {
+        return *info == req ? data() : nullptr;
+    }
+
+    /**
+     * @brief Replaces the contained object by creating a new instance directly.
+     * @tparam Type Type of object to use to initialize the wrapper.
+     * @tparam Args Types of arguments to use to construct the new instance.
+     * @param args Parameters to use to construct the instance.
+     */
+    template<typename Type, typename... Args>
+    void emplace(Args &&...args) {
+        reset();
+        initialize<Type>(std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Assigns a value to the contained object without replacing it.
+     * @param other The value to assign to the contained object.
+     * @return True in case of success, false otherwise.
+     */
+    bool assign(const any &other) {
+        if(vtable && mode != policy::cref && *info == *other.info) {
+            return (vtable(operation::assign, *this, other.data()) != nullptr);
+        }
+
+        return false;
+    }
+
+    /*! @copydoc assign */
+    bool assign(any &&other) {
+        if(vtable && mode != policy::cref && *info == *other.info) {
+            if(auto *val = other.data(); val) {
+                return (vtable(operation::transfer, *this, val) != nullptr);
+            } else {
+                return (vtable(operation::assign, *this, std::as_const(other).data()) != nullptr);
+            }
+        }
+
+        return false;
+    }
+
+    /*! @brief Destroys contained object */
+    void reset() {
+        if(vtable && owner()) {
+            vtable(operation::destroy, *this, nullptr);
+        }
+
+        info = &type_id<void>();
+        vtable = nullptr;
+        mode = policy::owner;
+    }
+
+    /**
+     * @brief Returns false if a wrapper is empty, true otherwise.
+     * @return False if the wrapper is empty, true otherwise.
+     */
+    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
+        return vtable != nullptr;
+    }
+
+    /**
+     * @brief Checks if two wrappers differ in their content.
+     * @param other Wrapper with which to compare.
+     * @return False if the two objects differ in their content, true otherwise.
+     */
+    bool operator==(const basic_any &other) const ENTT_NOEXCEPT {
+        if(vtable && *info == *other.info) {
+            return (vtable(operation::compare, *this, other.data()) != nullptr);
+        }
+
+        return (!vtable && !other.vtable);
+    }
+
+    /**
+     * @brief Aliasing constructor.
+     * @return A wrapper that shares a reference to an unmanaged object.
+     */
+    [[nodiscard]] basic_any as_ref() ENTT_NOEXCEPT {
+        return basic_any{*this, (mode == policy::cref ? policy::cref : policy::ref)};
+    }
+
+    /*! @copydoc as_ref */
+    [[nodiscard]] basic_any as_ref() const ENTT_NOEXCEPT {
+        return basic_any{*this, policy::cref};
+    }
+
+    /**
+     * @brief Returns true if a wrapper owns its object, false otherwise.
+     * @return True if the wrapper owns its object, false otherwise.
+     */
+    [[nodiscard]] bool owner() const ENTT_NOEXCEPT {
+        return (mode == policy::owner);
+    }
+
+private:
+    union {
+        const void *instance;
+        storage_type storage;
+    };
+    const type_info *info;
+    vtable_type *vtable;
+    policy mode;
+};
+
+/**
+ * @brief Checks if two wrappers differ in their content.
+ * @tparam Len Size of the storage reserved for the small buffer optimization.
+ * @tparam Align Alignment requirement.
+ * @param lhs A wrapper, either empty or not.
+ * @param rhs A wrapper, either empty or not.
+ * @return True if the two wrappers differ in their content, false otherwise.
+ */
+template<std::size_t Len, std::size_t Align>
+[[nodiscard]] inline bool operator!=(const basic_any<Len, Align> &lhs, const basic_any<Len, Align> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+/**
+ * @brief Performs type-safe access to the contained object.
+ * @tparam Type Type to which conversion is required.
+ * @tparam Len Size of the storage reserved for the small buffer optimization.
+ * @tparam Align Alignment requirement.
+ * @param data Target any object.
+ * @return The element converted to the requested type.
+ */
+template<typename Type, std::size_t Len, std::size_t Align>
+Type any_cast(const basic_any<Len, Align> &data) ENTT_NOEXCEPT {
+    const auto *const instance = any_cast<std::remove_reference_t<Type>>(&data);
+    ENTT_ASSERT(instance, "Invalid instance");
+    return static_cast<Type>(*instance);
+}
+
+/*! @copydoc any_cast */
+template<typename Type, std::size_t Len, std::size_t Align>
+Type any_cast(basic_any<Len, Align> &data) ENTT_NOEXCEPT {
+    // forces const on non-reference types to make them work also with wrappers for const references
+    auto *const instance = any_cast<std::remove_reference_t<const Type>>(&data);
+    ENTT_ASSERT(instance, "Invalid instance");
+    return static_cast<Type>(*instance);
+}
+
+/*! @copydoc any_cast */
+template<typename Type, std::size_t Len, std::size_t Align>
+Type any_cast(basic_any<Len, Align> &&data) ENTT_NOEXCEPT {
+    if constexpr(std::is_copy_constructible_v<std::remove_cv_t<std::remove_reference_t<Type>>>) {
+        if(auto *const instance = any_cast<std::remove_reference_t<Type>>(&data); instance) {
+            return static_cast<Type>(std::move(*instance));
+        } else {
+            return any_cast<Type>(data);
+        }
+    } else {
+        auto *const instance = any_cast<std::remove_reference_t<Type>>(&data);
+        ENTT_ASSERT(instance, "Invalid instance");
+        return static_cast<Type>(std::move(*instance));
+    }
+}
+
+/*! @copydoc any_cast */
+template<typename Type, std::size_t Len, std::size_t Align>
+const Type *any_cast(const basic_any<Len, Align> *data) ENTT_NOEXCEPT {
+    const auto &info = type_id<std::remove_cv_t<std::remove_reference_t<Type>>>();
+    return static_cast<const Type *>(data->data(info));
+}
+
+/*! @copydoc any_cast */
+template<typename Type, std::size_t Len, std::size_t Align>
+Type *any_cast(basic_any<Len, Align> *data) ENTT_NOEXCEPT {
+    const auto &info = type_id<std::remove_cv_t<std::remove_reference_t<Type>>>();
+    // last attempt to make wrappers for const references return their values
+    return static_cast<Type *>(static_cast<constness_as_t<basic_any<Len, Align>, Type> *>(data)->data(info));
+}
+
+/**
+ * @brief Constructs a wrapper from a given type, passing it all arguments.
+ * @tparam Type Type of object to use to initialize the wrapper.
+ * @tparam Len Size of the storage reserved for the small buffer optimization.
+ * @tparam Align Optional alignment requirement.
+ * @tparam Args Types of arguments to use to construct the new instance.
+ * @param args Parameters to use to construct the instance.
+ * @return A properly initialized wrapper for an object of the given type.
+ */
+template<typename Type, std::size_t Len = basic_any<>::length, std::size_t Align = basic_any<Len>::alignment, typename... Args>
+basic_any<Len, Align> make_any(Args &&...args) {
+    return basic_any<Len, Align>{std::in_place_type<Type>, std::forward<Args>(args)...};
+}
+
+/**
+ * @brief Forwards its argument and avoids copies for lvalue references.
+ * @tparam Len Size of the storage reserved for the small buffer optimization.
+ * @tparam Align Optional alignment requirement.
+ * @tparam Type Type of argument to use to construct the new instance.
+ * @param value Parameter to use to construct the instance.
+ * @return A properly initialized and not necessarily owning wrapper.
+ */
+template<std::size_t Len = basic_any<>::length, std::size_t Align = basic_any<Len>::alignment, typename Type>
+basic_any<Len, Align> forward_as_any(Type &&value) {
+    return basic_any<Len, Align>{std::in_place_type<std::conditional_t<std::is_rvalue_reference_v<Type>, std::decay_t<Type>, Type>>, std::forward<Type>(value)};
+}
+
+} // namespace entt
+
+#endif

src/entt/core/attribute.h

@@ -0,0 +1,30 @@
+#ifndef ENTT_CORE_ATTRIBUTE_H
+#define ENTT_CORE_ATTRIBUTE_H
+
+#ifndef ENTT_EXPORT
+#    if defined _WIN32 || defined __CYGWIN__ || defined _MSC_VER
+#        define ENTT_EXPORT __declspec(dllexport)
+#        define ENTT_IMPORT __declspec(dllimport)
+#        define ENTT_HIDDEN
+#    elif defined __GNUC__ && __GNUC__ >= 4
+#        define ENTT_EXPORT __attribute__((visibility("default")))
+#        define ENTT_IMPORT __attribute__((visibility("default")))
+#        define ENTT_HIDDEN __attribute__((visibility("hidden")))
+#    else /* Unsupported compiler */
+#        define ENTT_EXPORT
+#        define ENTT_IMPORT
+#        define ENTT_HIDDEN
+#    endif
+#endif
+
+#ifndef ENTT_API
+#    if defined ENTT_API_EXPORT
+#        define ENTT_API ENTT_EXPORT
+#    elif defined ENTT_API_IMPORT
+#        define ENTT_API ENTT_IMPORT
+#    else /* No API */
+#        define ENTT_API
+#    endif
+#endif
+
+#endif

src/entt/core/compressed_pair.hpp

@@ -0,0 +1,280 @@
+#ifndef ENTT_CORE_COMPRESSED_PAIR_HPP
+#define ENTT_CORE_COMPRESSED_PAIR_HPP
+
+#include <cstddef>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+#include "type_traits.hpp"
+
+namespace entt {
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename Type, std::size_t, typename = void>
+struct compressed_pair_element {
+    using reference = Type &;
+    using const_reference = const Type &;
+
+    template<bool Dummy = true, typename = std::enable_if_t<Dummy && std::is_default_constructible_v<Type>>>
+    compressed_pair_element()
+        : value{} {}
+
+    template<typename Args, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Args>>, compressed_pair_element>>>
+    compressed_pair_element(Args &&args)
+        : value{std::forward<Args>(args)} {}
+
+    template<typename... Args, std::size_t... Index>
+    compressed_pair_element(std::tuple<Args...> args, std::index_sequence<Index...>)
+        : value{std::forward<Args>(std::get<Index>(args))...} {}
+
+    [[nodiscard]] reference get() ENTT_NOEXCEPT {
+        return value;
+    }
+
+    [[nodiscard]] const_reference get() const ENTT_NOEXCEPT {
+        return value;
+    }
+
+private:
+    Type value;
+};
+
+template<typename Type, std::size_t Tag>
+struct compressed_pair_element<Type, Tag, std::enable_if_t<is_ebco_eligible_v<Type>>>: Type {
+    using reference = Type &;
+    using const_reference = const Type &;
+    using base_type = Type;
+
+    template<bool Dummy = true, typename = std::enable_if_t<Dummy && std::is_default_constructible_v<base_type>>>
+    compressed_pair_element()
+        : base_type{} {}
+
+    template<typename Args, typename = std::enable_if_t<!std::is_same_v<std::remove_cv_t<std::remove_reference_t<Args>>, compressed_pair_element>>>
+    compressed_pair_element(Args &&args)
+        : base_type{std::forward<Args>(args)} {}
+
+    template<typename... Args, std::size_t... Index>
+    compressed_pair_element(std::tuple<Args...> args, std::index_sequence<Index...>)
+        : base_type{std::forward<Args>(std::get<Index>(args))...} {}
+
+    [[nodiscard]] reference get() ENTT_NOEXCEPT {
+        return *this;
+    }
+
+    [[nodiscard]] const_reference get() const ENTT_NOEXCEPT {
+        return *this;
+    }
+};
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief A compressed pair.
+ *
+ * A pair that exploits the _Empty Base Class Optimization_ (or _EBCO_) to
+ * reduce its final size to a minimum.
+ *
+ * @tparam First The type of the first element that the pair stores.
+ * @tparam Second The type of the second element that the pair stores.
+ */
+template<typename First, typename Second>
+class compressed_pair final
+    : internal::compressed_pair_element<First, 0u>,
+      internal::compressed_pair_element<Second, 1u> {
+    using first_base = internal::compressed_pair_element<First, 0u>;
+    using second_base = internal::compressed_pair_element<Second, 1u>;
+
+public:
+    /*! @brief The type of the first element that the pair stores. */
+    using first_type = First;
+    /*! @brief The type of the second element that the pair stores. */
+    using second_type = Second;
+
+    /**
+     * @brief Default constructor, conditionally enabled.
+     *
+     * This constructor is only available when the types that the pair stores
+     * are both at least default constructible.
+     *
+     * @tparam Dummy Dummy template parameter used for internal purposes.
+     */
+    template<bool Dummy = true, typename = std::enable_if_t<Dummy && std::is_default_constructible_v<first_type> && std::is_default_constructible_v<second_type>>>
+    constexpr compressed_pair()
+        : first_base{},
+          second_base{} {}
+
+    /**
+     * @brief Copy constructor.
+     * @param other The instance to copy from.
+     */
+    constexpr compressed_pair(const compressed_pair &other) = default;
+
+    /**
+     * @brief Move constructor.
+     * @param other The instance to move from.
+     */
+    constexpr compressed_pair(compressed_pair &&other) = default;
+
+    /**
+     * @brief Constructs a pair from its values.
+     * @tparam Arg Type of value to use to initialize the first element.
+     * @tparam Other Type of value to use to initialize the second element.
+     * @param arg Value to use to initialize the first element.
+     * @param other Value to use to initialize the second element.
+     */
+    template<typename Arg, typename Other>
+    constexpr compressed_pair(Arg &&arg, Other &&other)
+        : first_base{std::forward<Arg>(arg)},
+          second_base{std::forward<Other>(other)} {}
+
+    /**
+     * @brief Constructs a pair by forwarding the arguments to its parts.
+     * @tparam Args Types of arguments to use to initialize the first element.
+     * @tparam Other Types of arguments to use to initialize the second element.
+     * @param args Arguments to use to initialize the first element.
+     * @param other Arguments to use to initialize the second element.
+     */
+    template<typename... Args, typename... Other>
+    constexpr compressed_pair(std::piecewise_construct_t, std::tuple<Args...> args, std::tuple<Other...> other)
+        : first_base{std::move(args), std::index_sequence_for<Args...>{}},
+          second_base{std::move(other), std::index_sequence_for<Other...>{}} {}
+
+    /**
+     * @brief Copy assignment operator.
+     * @param other The instance to copy from.
+     * @return This compressed pair object.
+     */
+    constexpr compressed_pair &operator=(const compressed_pair &other) = default;
+
+    /**
+     * @brief Move assignment operator.
+     * @param other The instance to move from.
+     * @return This compressed pair object.
+     */
+    constexpr compressed_pair &operator=(compressed_pair &&other) = default;
+
+    /**
+     * @brief Returns the first element that a pair stores.
+     * @return The first element that a pair stores.
+     */
+    [[nodiscard]] first_type &first() ENTT_NOEXCEPT {
+        return static_cast<first_base &>(*this).get();
+    }
+
+    /*! @copydoc first */
+    [[nodiscard]] const first_type &first() const ENTT_NOEXCEPT {
+        return static_cast<const first_base &>(*this).get();
+    }
+
+    /**
+     * @brief Returns the second element that a pair stores.
+     * @return The second element that a pair stores.
+     */
+    [[nodiscard]] second_type &second() ENTT_NOEXCEPT {
+        return static_cast<second_base &>(*this).get();
+    }
+
+    /*! @copydoc second */
+    [[nodiscard]] const second_type &second() const ENTT_NOEXCEPT {
+        return static_cast<const second_base &>(*this).get();
+    }
+
+    /**
+     * @brief Swaps two compressed pair objects.
+     * @param other The compressed pair to swap with.
+     */
+    void swap(compressed_pair &other) {
+        using std::swap;
+        swap(first(), other.first());
+        swap(second(), other.second());
+    }
+
+    /**
+     * @brief Extracts an element from the compressed pair.
+     * @tparam Index An integer value that is either 0 or 1.
+     * @return Returns a reference to the first element if `Index` is 0 and a
+     * reference to the second element if `Index` is 1.
+     */
+    template<std::size_t Index>
+    decltype(auto) get() ENTT_NOEXCEPT {
+        if constexpr(Index == 0u) {
+            return first();
+        } else {
+            static_assert(Index == 1u, "Index out of bounds");
+            return second();
+        }
+    }
+
+    /*! @copydoc get */
+    template<std::size_t Index>
+    decltype(auto) get() const ENTT_NOEXCEPT {
+        if constexpr(Index == 0u) {
+            return first();
+        } else {
+            static_assert(Index == 1u, "Index out of bounds");
+            return second();
+        }
+    }
+};
+
+/**
+ * @brief Deduction guide.
+ * @tparam Type Type of value to use to initialize the first element.
+ * @tparam Other Type of value to use to initialize the second element.
+ */
+template<typename Type, typename Other>
+compressed_pair(Type &&, Other &&) -> compressed_pair<std::decay_t<Type>, std::decay_t<Other>>;
+
+/**
+ * @brief Swaps two compressed pair objects.
+ * @tparam First The type of the first element that the pairs store.
+ * @tparam Second The type of the second element that the pairs store.
+ * @param lhs A valid compressed pair object.
+ * @param rhs A valid compressed pair object.
+ */
+template<typename First, typename Second>
+inline void swap(compressed_pair<First, Second> &lhs, compressed_pair<First, Second> &rhs) {
+    lhs.swap(rhs);
+}
+
+} // namespace entt
+
+// disable structured binding support for clang 6, it messes when specializing tuple_size
+#if !defined __clang_major__ || __clang_major__ > 6
+namespace std {
+
+/**
+ * @brief `std::tuple_size` specialization for `compressed_pair`s.
+ * @tparam First The type of the first element that the pair stores.
+ * @tparam Second The type of the second element that the pair stores.
+ */
+template<typename First, typename Second>
+struct tuple_size<entt::compressed_pair<First, Second>>: integral_constant<size_t, 2u> {};
+
+/**
+ * @brief `std::tuple_element` specialization for `compressed_pair`s.
+ * @tparam Index The index of the type to return.
+ * @tparam First The type of the first element that the pair stores.
+ * @tparam Second The type of the second element that the pair stores.
+ */
+template<size_t Index, typename First, typename Second>
+struct tuple_element<Index, entt::compressed_pair<First, Second>>: conditional<Index == 0u, First, Second> {
+    static_assert(Index < 2u, "Index out of bounds");
+};
+
+} // namespace std
+#endif
+
+#endif

src/entt/core/enum.hpp

@@ -0,0 +1,98 @@
+#ifndef ENTT_CORE_ENUM_HPP
+#define ENTT_CORE_ENUM_HPP
+
+#include <type_traits>
+#include "../config/config.h"
+
+namespace entt {
+
+/**
+ * @brief Enable bitmask support for enum classes.
+ * @tparam Type The enum type for which to enable bitmask support.
+ */
+template<typename Type, typename = void>
+struct enum_as_bitmask: std::false_type {};
+
+/*! @copydoc enum_as_bitmask */
+template<typename Type>
+struct enum_as_bitmask<Type, std::void_t<decltype(Type::_entt_enum_as_bitmask)>>: std::is_enum<Type> {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type The enum class type for which to enable bitmask support.
+ */
+template<typename Type>
+inline constexpr bool enum_as_bitmask_v = enum_as_bitmask<Type>::value;
+
+} // namespace entt
+
+/**
+ * @brief Operator available for enums for which bitmask support is enabled.
+ * @tparam Type Enum class type.
+ * @param lhs The first value to use.
+ * @param rhs The second value to use.
+ * @return The result of invoking the operator on the underlying types of the
+ * two values provided.
+ */
+template<typename Type>
+[[nodiscard]] constexpr std::enable_if_t<entt::enum_as_bitmask_v<Type>, Type>
+operator|(const Type lhs, const Type rhs) ENTT_NOEXCEPT {
+    return static_cast<Type>(static_cast<std::underlying_type_t<Type>>(lhs) | static_cast<std::underlying_type_t<Type>>(rhs));
+}
+
+/*! @copydoc operator| */
+template<typename Type>
+[[nodiscard]] constexpr std::enable_if_t<entt::enum_as_bitmask_v<Type>, Type>
+operator&(const Type lhs, const Type rhs) ENTT_NOEXCEPT {
+    return static_cast<Type>(static_cast<std::underlying_type_t<Type>>(lhs) & static_cast<std::underlying_type_t<Type>>(rhs));
+}
+
+/*! @copydoc operator| */
+template<typename Type>
+[[nodiscard]] constexpr std::enable_if_t<entt::enum_as_bitmask_v<Type>, Type>
+operator^(const Type lhs, const Type rhs) ENTT_NOEXCEPT {
+    return static_cast<Type>(static_cast<std::underlying_type_t<Type>>(lhs) ^ static_cast<std::underlying_type_t<Type>>(rhs));
+}
+
+/**
+ * @brief Operator available for enums for which bitmask support is enabled.
+ * @tparam Type Enum class type.
+ * @param value The value to use.
+ * @return The result of invoking the operator on the underlying types of the
+ * value provided.
+ */
+template<typename Type>
+[[nodiscard]] constexpr std::enable_if_t<entt::enum_as_bitmask_v<Type>, Type>
+operator~(const Type value) ENTT_NOEXCEPT {
+    return static_cast<Type>(~static_cast<std::underlying_type_t<Type>>(value));
+}
+
+/*! @copydoc operator~ */
+template<typename Type>
+[[nodiscard]] constexpr std::enable_if_t<entt::enum_as_bitmask_v<Type>, bool>
+operator!(const Type value) ENTT_NOEXCEPT {
+    return !static_cast<std::underlying_type_t<Type>>(value);
+}
+
+/*! @copydoc operator| */
+template<typename Type>
+constexpr std::enable_if_t<entt::enum_as_bitmask_v<Type>, Type &>
+operator|=(Type &lhs, const Type rhs) ENTT_NOEXCEPT {
+    return (lhs = (lhs | rhs));
+}
+
+/*! @copydoc operator| */
+template<typename Type>
+constexpr std::enable_if_t<entt::enum_as_bitmask_v<Type>, Type &>
+operator&=(Type &lhs, const Type rhs) ENTT_NOEXCEPT {
+    return (lhs = (lhs & rhs));
+}
+
+/*! @copydoc operator| */
+template<typename Type>
+constexpr std::enable_if_t<entt::enum_as_bitmask_v<Type>, Type &>
+operator^=(Type &lhs, const Type rhs) ENTT_NOEXCEPT {
+    return (lhs = (lhs ^ rhs));
+}
+
+#endif

src/entt/core/family.hpp

@@ -1,14 +1,11 @@
 #ifndef ENTT_CORE_FAMILY_HPP
 #define ENTT_CORE_FAMILY_HPP
 
-
-#include<type_traits>
-#include<cstddef>
-
+#include "../config/config.h"
+#include "fwd.hpp"
 
 namespace entt {
 
-
 /**
  * @brief Dynamic identifier generator.
  *
@@ -17,34 +14,19 @@ namespace entt {
  * identifiers.
  */
 template<typename...>
-class Family {
-    static std::size_t identifier() noexcept {
-        static std::size_t value = 0;
-        return value++;
-    }
-
-    template<typename...>
-    static std::size_t family() noexcept {
-        static const std::size_t value = identifier();
-        return value;
-    }
+class family {
+    inline static ENTT_MAYBE_ATOMIC(id_type) identifier{};
 
 public:
     /*! @brief Unsigned integer type. */
-    using family_type = std::size_t;
+    using family_type = id_type;
 
-    /**
-     * @brief Returns an unique identifier for the given type.
-     * @return Statically generated unique identifier for the given type.
-     */
+    /*! @brief Statically generated unique identifier for the given type. */
     template<typename... Type>
-    static family_type type() noexcept {
-        return family<std::decay_t<Type>...>();
-    }
+    // at the time I'm writing, clang crashes during compilation if auto is used instead of family_type
+    inline static const family_type type = identifier++;
 };
 
+} // namespace entt
 
-}
-
-
-#endif // ENTT_CORE_FAMILY_HPP
+#endif

src/entt/core/fwd.hpp

@@ -0,0 +1,21 @@
+#ifndef ENTT_CORE_FWD_HPP
+#define ENTT_CORE_FWD_HPP
+
+#include <cstdint>
+#include <type_traits>
+#include "../config/config.h"
+
+namespace entt {
+
+template<std::size_t Len = sizeof(double[2]), std::size_t = alignof(typename std::aligned_storage_t<Len + !Len>)>
+class basic_any;
+
+/*! @brief Alias declaration for type identifiers. */
+using id_type = ENTT_ID_TYPE;
+
+/*! @brief Alias declaration for the most common use case. */
+using any = basic_any<>;
+
+} // namespace entt
+
+#endif

src/entt/core/hashed_string.hpp

@@ -1,109 +1,333 @@
 #ifndef ENTT_CORE_HASHED_STRING_HPP
 #define ENTT_CORE_HASHED_STRING_HPP
 
-
+#include <cstddef>
 #include <cstdint>
-
+#include "../config/config.h"
+#include "fwd.hpp"
 
 namespace entt {
 
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename>
+struct fnv1a_traits;
+
+template<>
+struct fnv1a_traits<std::uint32_t> {
+    using type = std::uint32_t;
+    static constexpr std::uint32_t offset = 2166136261;
+    static constexpr std::uint32_t prime = 16777619;
+};
+
+template<>
+struct fnv1a_traits<std::uint64_t> {
+    using type = std::uint64_t;
+    static constexpr std::uint64_t offset = 14695981039346656037ull;
+    static constexpr std::uint64_t prime = 1099511628211ull;
+};
+
+template<typename Char>
+struct basic_hashed_string {
+    using value_type = Char;
+    using size_type = std::size_t;
+    using hash_type = id_type;
+
+    const value_type *repr;
+    size_type length;
+    hash_type hash;
+};
+
+} // namespace internal
 
 /**
- * @brief Zero overhead resource identifier.
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Zero overhead unique identifier.
  *
  * A hashed string is a compile-time tool that allows users to use
- * human-readable identifers in the codebase while using their numeric
+ * human-readable identifiers in the codebase while using their numeric
  * counterparts at runtime.<br/>
  * Because of that, a hashed string can also be used in constant expressions if
  * required.
+ *
+ * @warning
+ * This class doesn't take ownership of user-supplied strings nor does it make a
+ * copy of them.
+ *
+ * @tparam Char Character type.
  */
-class HashedString final {
-    struct ConstCharWrapper final {
+template<typename Char>
+class basic_hashed_string: internal::basic_hashed_string<Char> {
+    using base_type = internal::basic_hashed_string<Char>;
+    using hs_traits = internal::fnv1a_traits<id_type>;
+
+    struct const_wrapper {
         // non-explicit constructor on purpose
-        constexpr ConstCharWrapper(const char *str) noexcept: str{str} {}
-        const char *str;
+        constexpr const_wrapper(const Char *str) ENTT_NOEXCEPT: repr{str} {}
+        const Char *repr;
     };
 
-    static constexpr std::uint64_t offset = 14695981039346656037ull;
-    static constexpr std::uint64_t prime = 1099511628211ull;
+    // Fowler–Noll–Vo hash function v. 1a - the good
+    [[nodiscard]] static constexpr auto helper(const Char *str) ENTT_NOEXCEPT {
+        base_type base{str, 0u, hs_traits::offset};
+
+        for(; str[base.length]; ++base.length) {
+            base.hash = (base.hash ^ static_cast<hs_traits::type>(str[base.length])) * hs_traits::prime;
+        }
+
+        return base;
+    }
 
     // Fowler–Noll–Vo hash function v. 1a - the good
-    static constexpr std::uint64_t helper(std::uint64_t partial, const char *str) noexcept {
-        return str[0] == 0 ? partial : helper((partial^str[0])*prime, str+1);
+    [[nodiscard]] static constexpr auto helper(const Char *str, const std::size_t len) ENTT_NOEXCEPT {
+        base_type base{str, len, hs_traits::offset};
+
+        for(size_type pos{}; pos < len; ++pos) {
+            base.hash = (base.hash ^ static_cast<hs_traits::type>(str[pos])) * hs_traits::prime;
+        }
+
+        return base;
     }
 
 public:
+    /*! @brief Character type. */
+    using value_type = typename base_type::value_type;
     /*! @brief Unsigned integer type. */
-    using hash_type = std::uint64_t;
+    using size_type = typename base_type::size_type;
+    /*! @brief Unsigned integer type. */
+    using hash_type = typename base_type::hash_type;
 
     /**
-     * @brief Constructs a hashed string from an array of const chars.
-     *
-     * Forcing template resolution avoids implicit conversions. An
-     * human-readable identifier can be anything but a plain, old bunch of
-     * characters.<br/>
-     * Example of use:
-     * @code{.cpp}
-     * HashedString sh{"my.png"};
-     * @endcode
-     *
-     * @tparam N Number of characters of the identifier.
-     * @param str Human-readable identifer.
+     * @brief Returns directly the numeric representation of a string view.
+     * @param str Human-readable identifier.
+     * @param len Length of the string to hash.
+     * @return The numeric representation of the string.
      */
-    template <std::size_t N>
-    constexpr HashedString(const char (&str)[N]) noexcept
-        : hash{helper(offset, str)}, str{str}
-    {}
+    [[nodiscard]] static constexpr hash_type value(const value_type *str, const size_type len) ENTT_NOEXCEPT {
+        return basic_hashed_string{str, len};
+    }
+
+    /**
+     * @brief Returns directly the numeric representation of a string.
+     * @tparam N Number of characters of the identifier.
+     * @param str Human-readable identifier.
+     * @return The numeric representation of the string.
+     */
+    template<std::size_t N>
+    [[nodiscard]] static constexpr hash_type value(const value_type (&str)[N]) ENTT_NOEXCEPT {
+        return basic_hashed_string{str};
+    }
+
+    /**
+     * @brief Returns directly the numeric representation of a string.
+     * @param wrapper Helps achieving the purpose by relying on overloading.
+     * @return The numeric representation of the string.
+     */
+    [[nodiscard]] static constexpr hash_type value(const_wrapper wrapper) ENTT_NOEXCEPT {
+        return basic_hashed_string{wrapper};
+    }
+
+    /*! @brief Constructs an empty hashed string. */
+    constexpr basic_hashed_string() ENTT_NOEXCEPT
+        : base_type{} {}
+
+    /**
+     * @brief Constructs a hashed string from a string view.
+     * @param str Human-readable identifier.
+     * @param len Length of the string to hash.
+     */
+    constexpr basic_hashed_string(const value_type *str, const size_type len) ENTT_NOEXCEPT
+        : base_type{helper(str, len)} {}
+
+    /**
+     * @brief Constructs a hashed string from an array of const characters.
+     * @tparam N Number of characters of the identifier.
+     * @param str Human-readable identifier.
+     */
+    template<std::size_t N>
+    constexpr basic_hashed_string(const value_type (&str)[N]) ENTT_NOEXCEPT
+        : base_type{helper(str)} {}
 
     /**
      * @brief Explicit constructor on purpose to avoid constructing a hashed
-     * string directly from a `const char *`.
+     * string directly from a `const value_type *`.
+     *
+     * @warning
+     * The lifetime of the string is not extended nor is it copied.
      *
      * @param wrapper Helps achieving the purpose by relying on overloading.
      */
-    explicit constexpr HashedString(ConstCharWrapper wrapper) noexcept
-        : hash{helper(offset, wrapper.str)}, str{wrapper.str}
-    {}
+    explicit constexpr basic_hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT
+        : base_type{helper(wrapper.repr)} {}
+
+    /**
+     * @brief Returns the size a hashed string.
+     * @return The size of the hashed string.
+     */
+    [[nodiscard]] constexpr size_type size() const ENTT_NOEXCEPT {
+        return base_type::length;
+    }
 
     /**
      * @brief Returns the human-readable representation of a hashed string.
-     * @return The string used to initialize the instance.
+     * @return The string used to initialize the hashed string.
      */
-    constexpr operator const char *() const noexcept { return str; }
+    [[nodiscard]] constexpr const value_type *data() const ENTT_NOEXCEPT {
+        return base_type::repr;
+    }
 
     /**
      * @brief Returns the numeric representation of a hashed string.
-     * @return The numeric representation of the instance.
+     * @return The numeric representation of the hashed string.
      */
-    constexpr operator hash_type() const 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 {
-        return hash == other.hash;
+    [[nodiscard]] constexpr hash_type value() const ENTT_NOEXCEPT {
+        return base_type::hash;
     }
 
-private:
-    const hash_type hash;
-    const char *str;
+    /*! @copydoc data */
+    [[nodiscard]] constexpr operator const value_type *() const ENTT_NOEXCEPT {
+        return data();
+    }
+
+    /**
+     * @brief Returns the numeric representation of a hashed string.
+     * @return The numeric representation of the hashed string.
+     */
+    [[nodiscard]] constexpr operator hash_type() const ENTT_NOEXCEPT {
+        return value();
+    }
 };
 
+/**
+ * @brief Deduction guide.
+ * @tparam Char Character type.
+ * @param str Human-readable identifier.
+ * @param len Length of the string to hash.
+ */
+template<typename Char>
+basic_hashed_string(const Char *str, const std::size_t len) -> basic_hashed_string<Char>;
+
+/**
+ * @brief Deduction guide.
+ * @tparam Char Character type.
+ * @tparam N Number of characters of the identifier.
+ * @param str Human-readable identifier.
+ */
+template<typename Char, std::size_t N>
+basic_hashed_string(const Char (&str)[N]) -> basic_hashed_string<Char>;
 
 /**
  * @brief Compares two hashed strings.
+ * @tparam Char Character type.
  * @param lhs A valid hashed string.
  * @param rhs A valid hashed string.
  * @return True if the two hashed strings are identical, false otherwise.
  */
-constexpr bool operator!=(const HashedString &lhs, const HashedString &rhs) noexcept {
+template<typename Char>
+[[nodiscard]] constexpr bool operator==(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
+    return lhs.value() == rhs.value();
+}
+
+/**
+ * @brief Compares two hashed strings.
+ * @tparam Char Character type.
+ * @param lhs A valid hashed string.
+ * @param rhs A valid hashed string.
+ * @return True if the two hashed strings differ, false otherwise.
+ */
+template<typename Char>
+[[nodiscard]] constexpr bool operator!=(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
     return !(lhs == rhs);
 }
 
-
+/**
+ * @brief Compares two hashed strings.
+ * @tparam Char Character type.
+ * @param lhs A valid hashed string.
+ * @param rhs A valid hashed string.
+ * @return True if the first element is less than the second, false otherwise.
+ */
+template<typename Char>
+[[nodiscard]] constexpr bool operator<(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
+    return lhs.value() < rhs.value();
 }
 
+/**
+ * @brief Compares two hashed strings.
+ * @tparam Char Character type.
+ * @param lhs A valid hashed string.
+ * @param rhs A valid hashed string.
+ * @return True if the first element is less than or equal to the second, false
+ * otherwise.
+ */
+template<typename Char>
+[[nodiscard]] constexpr bool operator<=(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
+    return !(rhs < lhs);
+}
 
-#endif // ENTT_CORE_HASHED_STRING_HPP
+/**
+ * @brief Compares two hashed strings.
+ * @tparam Char Character type.
+ * @param lhs A valid hashed string.
+ * @param rhs A valid hashed string.
+ * @return True if the first element is greater than the second, false
+ * otherwise.
+ */
+template<typename Char>
+[[nodiscard]] constexpr bool operator>(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
+    return rhs < lhs;
+}
+
+/**
+ * @brief Compares two hashed strings.
+ * @tparam Char Character type.
+ * @param lhs A valid hashed string.
+ * @param rhs A valid hashed string.
+ * @return True if the first element is greater than or equal to the second,
+ * false otherwise.
+ */
+template<typename Char>
+[[nodiscard]] constexpr bool operator>=(const basic_hashed_string<Char> &lhs, const basic_hashed_string<Char> &rhs) ENTT_NOEXCEPT {
+    return !(lhs < rhs);
+}
+
+/*! @brief Aliases for common character types. */
+using hashed_string = basic_hashed_string<char>;
+
+/*! @brief Aliases for common character types. */
+using hashed_wstring = basic_hashed_string<wchar_t>;
+
+inline namespace literals {
+
+/**
+ * @brief User defined literal for hashed strings.
+ * @param str The literal without its suffix.
+ * @return A properly initialized hashed string.
+ */
+[[nodiscard]] constexpr hashed_string operator"" _hs(const char *str, std::size_t) ENTT_NOEXCEPT {
+    return hashed_string{str};
+}
+
+/**
+ * @brief User defined literal for hashed wstrings.
+ * @param str The literal without its suffix.
+ * @return A properly initialized hashed wstring.
+ */
+[[nodiscard]] constexpr hashed_wstring operator"" _hws(const wchar_t *str, std::size_t) ENTT_NOEXCEPT {
+    return hashed_wstring{str};
+}
+
+} // namespace literals
+
+} // namespace entt
+
+#endif

src/entt/core/ident.hpp

@@ -1,73 +1,33 @@
 #ifndef ENTT_CORE_IDENT_HPP
 #define ENTT_CORE_IDENT_HPP
 
-
-#include<type_traits>
-#include<cstddef>
-#include<utility>
-
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+#include "fwd.hpp"
+#include "type_traits.hpp"
 
 namespace entt {
 
-
-namespace {
-
-
-template<typename... Types>
-struct Identifier final: Identifier<Types>... {
-    using identifier_type = std::size_t;
-
-    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 Type>
-struct Identifier<Type> {
-    using identifier_type = std::size_t;
-
-    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;
-};
-
-
-}
-
-
 /**
- * @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<a_type, another_type>;
  *
- * switch(aTypeIdentifier) {
- * case identifers.get<AType>():
+ * switch(a_type_identifier) {
+ * case id::type<a_type>:
  *     // ...
  *     break;
- * case identifers.get<AnotherType>():
+ * case id::type<another_type>:
  *     // ...
  *     break;
  * default:
@@ -75,22 +35,25 @@ 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 {
+    template<typename Type, std::size_t... Index>
+    [[nodiscard]] static constexpr id_type get(std::index_sequence<Index...>) ENTT_NOEXCEPT {
+        static_assert((std::is_same_v<Type, Types> || ...), "Invalid type");
+        return (0 + ... + (std::is_same_v<Type, type_list_element_t<Index, type_list<std::decay_t<Types>...>>> ? id_type{Index} : id_type{}));
+    }
 
+public:
+    /*! @brief Unsigned integer type. */
+    using identifier_type = id_type;
 
-}
+    /*! @brief Statically generated unique identifier for the given type. */
+    template<typename Type>
+    static constexpr identifier_type type = get<std::decay_t<Type>>(std::index_sequence_for<Types...>{});
+};
 
+} // namespace entt
 
-#endif // ENTT_CORE_IDENT_HPP
+#endif

src/entt/core/iterator.hpp

@@ -0,0 +1,117 @@
+#ifndef ENTT_CORE_ITERATOR_HPP
+#define ENTT_CORE_ITERATOR_HPP
+
+#include <iterator>
+#include <memory>
+#include <utility>
+#include "../config/config.h"
+
+namespace entt {
+
+/**
+ * @brief Helper type to use as pointer with input iterators.
+ * @tparam Type of wrapped value.
+ */
+template<typename Type>
+struct input_iterator_pointer final {
+    /*! @brief Pointer type. */
+    using pointer = Type *;
+
+    /*! @brief Default copy constructor, deleted on purpose. */
+    input_iterator_pointer(const input_iterator_pointer &) = delete;
+
+    /*! @brief Default move constructor. */
+    input_iterator_pointer(input_iterator_pointer &&) = default;
+
+    /**
+     * @brief Constructs a proxy object by move.
+     * @param val Value to use to initialize the proxy object.
+     */
+    input_iterator_pointer(Type &&val)
+        : value{std::move(val)} {}
+
+    /**
+     * @brief Default copy assignment operator, deleted on purpose.
+     * @return This proxy object.
+     */
+    input_iterator_pointer &operator=(const input_iterator_pointer &) = delete;
+
+    /**
+     * @brief Default move assignment operator.
+     * @return This proxy object.
+     */
+    input_iterator_pointer &operator=(input_iterator_pointer &&) = default;
+
+    /**
+     * @brief Access operator for accessing wrapped values.
+     * @return A pointer to the wrapped value.
+     */
+    [[nodiscard]] pointer operator->() ENTT_NOEXCEPT {
+        return std::addressof(value);
+    }
+
+private:
+    Type value;
+};
+
+/**
+ * @brief Utility class to create an iterable object from a pair of iterators.
+ * @tparam It Type of iterator.
+ * @tparam Sentinel Type of sentinel.
+ */
+template<typename It, typename Sentinel = It>
+struct iterable_adaptor final {
+    /*! @brief Value type. */
+    using value_type = typename std::iterator_traits<It>::value_type;
+    /*! @brief Iterator type. */
+    using iterator = It;
+    /*! @brief Sentinel type. */
+    using sentinel = Sentinel;
+
+    /*! @brief Default constructor. */
+    iterable_adaptor() = default;
+
+    /**
+     * @brief Creates an iterable object from a pair of iterators.
+     * @param from Begin iterator.
+     * @param to End iterator.
+     */
+    iterable_adaptor(iterator from, sentinel to)
+        : first{from},
+          last{to} {}
+
+    /**
+     * @brief Returns an iterator to the beginning.
+     * @return An iterator to the first element of the range.
+     */
+    [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
+        return first;
+    }
+
+    /**
+     * @brief Returns an iterator to the end.
+     * @return An iterator to the element following the last element of the
+     * range.
+     */
+    [[nodiscard]] sentinel end() const ENTT_NOEXCEPT {
+        return last;
+    }
+
+    /*! @copydoc begin */
+    [[nodiscard]] iterator cbegin() const ENTT_NOEXCEPT {
+        return begin();
+    }
+
+    /*! @copydoc end */
+    [[nodiscard]] sentinel cend() const ENTT_NOEXCEPT {
+        return end();
+    }
+
+private:
+    It first;
+    Sentinel last;
+};
+
+} // namespace entt
+
+#endif

src/entt/core/memory.hpp

@@ -0,0 +1,289 @@
+#ifndef ENTT_CORE_MEMORY_HPP
+#define ENTT_CORE_MEMORY_HPP
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+
+namespace entt {
+
+/**
+ * @brief Unwraps fancy pointers, does nothing otherwise (waiting for C++20).
+ * @tparam Type Pointer type.
+ * @param ptr Fancy or raw pointer.
+ * @return A raw pointer that represents the address of the original pointer.
+ */
+template<typename Type>
+[[nodiscard]] constexpr auto to_address(Type &&ptr) ENTT_NOEXCEPT {
+    if constexpr(std::is_pointer_v<std::remove_cv_t<std::remove_reference_t<Type>>>) {
+        return ptr;
+    } else {
+        return to_address(std::forward<Type>(ptr).operator->());
+    }
+}
+
+/**
+ * @brief Utility function to design allocation-aware containers.
+ * @tparam Allocator Type of allocator.
+ * @param lhs A valid allocator.
+ * @param rhs Another valid allocator.
+ */
+template<typename Allocator>
+constexpr void propagate_on_container_copy_assignment([[maybe_unused]] Allocator &lhs, [[maybe_unused]] Allocator &rhs) ENTT_NOEXCEPT {
+    if constexpr(std::allocator_traits<Allocator>::propagate_on_container_copy_assignment::value) {
+        lhs = rhs;
+    }
+}
+
+/**
+ * @brief Utility function to design allocation-aware containers.
+ * @tparam Allocator Type of allocator.
+ * @param lhs A valid allocator.
+ * @param rhs Another valid allocator.
+ */
+template<typename Allocator>
+constexpr void propagate_on_container_move_assignment([[maybe_unused]] Allocator &lhs, [[maybe_unused]] Allocator &rhs) ENTT_NOEXCEPT {
+    if constexpr(std::allocator_traits<Allocator>::propagate_on_container_move_assignment::value) {
+        lhs = std::move(rhs);
+    }
+}
+
+/**
+ * @brief Utility function to design allocation-aware containers.
+ * @tparam Allocator Type of allocator.
+ * @param lhs A valid allocator.
+ * @param rhs Another valid allocator.
+ */
+template<typename Allocator>
+constexpr void propagate_on_container_swap([[maybe_unused]] Allocator &lhs, [[maybe_unused]] Allocator &rhs) ENTT_NOEXCEPT {
+    ENTT_ASSERT(std::allocator_traits<Allocator>::propagate_on_container_swap::value || lhs == rhs, "Cannot swap the containers");
+
+    if constexpr(std::allocator_traits<Allocator>::propagate_on_container_swap::value) {
+        using std::swap;
+        swap(lhs, rhs);
+    }
+}
+
+/**
+ * @brief Checks whether a value is a power of two or not.
+ * @param value A value that may or may not be a power of two.
+ * @return True if the value is a power of two, false otherwise.
+ */
+[[nodiscard]] inline constexpr bool is_power_of_two(const std::size_t value) ENTT_NOEXCEPT {
+    return value && ((value & (value - 1)) == 0);
+}
+
+/**
+ * @brief Computes the smallest power of two greater than or equal to a value.
+ * @param value The value to use.
+ * @return The smallest power of two greater than or equal to the given value.
+ */
+[[nodiscard]] inline constexpr std::size_t next_power_of_two(const std::size_t value) ENTT_NOEXCEPT {
+    ENTT_ASSERT(value < (std::size_t{1u} << (std::numeric_limits<std::size_t>::digits - 1)), "Numeric limits exceeded");
+    std::size_t curr = value - (value != 0u);
+
+    for(int next = 1; next < std::numeric_limits<std::size_t>::digits; next = next * 2) {
+        curr |= curr >> next;
+    }
+
+    return ++curr;
+}
+
+/**
+ * @brief Fast module utility function (powers of two only).
+ * @param value A value for which to calculate the modulus.
+ * @param mod _Modulus_, it must be a power of two.
+ * @return The common remainder.
+ */
+[[nodiscard]] inline constexpr std::size_t fast_mod(const std::size_t value, const std::size_t mod) ENTT_NOEXCEPT {
+    ENTT_ASSERT(is_power_of_two(mod), "Value must be a power of two");
+    return value & (mod - 1u);
+}
+
+/**
+ * @brief Deleter for allocator-aware unique pointers (waiting for C++20).
+ * @tparam Args Types of arguments to use to construct the object.
+ */
+template<typename Allocator>
+struct allocation_deleter: private Allocator {
+    /*! @brief Allocator type. */
+    using allocator_type = Allocator;
+    /*! @brief Pointer type. */
+    using pointer = typename std::allocator_traits<Allocator>::pointer;
+
+    /**
+     * @brief Inherited constructors.
+     * @param alloc The allocator to use.
+     */
+    allocation_deleter(const allocator_type &alloc)
+        : Allocator{alloc} {}
+
+    /**
+     * @brief Destroys the pointed object and deallocates its memory.
+     * @param ptr A valid pointer to an object of the given type.
+     */
+    void operator()(pointer ptr) {
+        using alloc_traits = typename std::allocator_traits<Allocator>;
+        alloc_traits::destroy(*this, to_address(ptr));
+        alloc_traits::deallocate(*this, ptr, 1u);
+    }
+};
+
+/**
+ * @brief Allows `std::unique_ptr` to use allocators (waiting for C++20).
+ * @tparam Type Type of object to allocate for and to construct.
+ * @tparam Allocator Type of allocator used to manage memory and elements.
+ * @tparam Args Types of arguments to use to construct the object.
+ * @param allocator The allocator to use.
+ * @param args Parameters to use to construct the object.
+ * @return A properly initialized unique pointer with a custom deleter.
+ */
+template<typename Type, typename Allocator, typename... Args>
+auto allocate_unique(Allocator &allocator, Args &&...args) {
+    static_assert(!std::is_array_v<Type>, "Array types are not supported");
+
+    using alloc_traits = typename std::allocator_traits<Allocator>::template rebind_traits<Type>;
+    using allocator_type = typename alloc_traits::allocator_type;
+
+    allocator_type alloc{allocator};
+    auto ptr = alloc_traits::allocate(alloc, 1u);
+
+    ENTT_TRY {
+        alloc_traits::construct(alloc, to_address(ptr), std::forward<Args>(args)...);
+    }
+    ENTT_CATCH {
+        alloc_traits::deallocate(alloc, ptr, 1u);
+        ENTT_THROW;
+    }
+
+    return std::unique_ptr<Type, allocation_deleter<allocator_type>>{ptr, alloc};
+}
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename Type>
+struct uses_allocator_construction {
+    template<typename Allocator, typename... Params>
+    static constexpr auto args([[maybe_unused]] const Allocator &allocator, Params &&...params) ENTT_NOEXCEPT {
+        if constexpr(!std::uses_allocator_v<Type, Allocator> && std::is_constructible_v<Type, Params...>) {
+            return std::forward_as_tuple(std::forward<Params>(params)...);
+        } else {
+            static_assert(std::uses_allocator_v<Type, Allocator>, "Ill-formed request");
+
+            if constexpr(std::is_constructible_v<Type, std::allocator_arg_t, const Allocator &, Params...>) {
+                return std::tuple<std::allocator_arg_t, const Allocator &, Params &&...>(std::allocator_arg, allocator, std::forward<Params>(params)...);
+            } else {
+                static_assert(std::is_constructible_v<Type, Params..., const Allocator &>, "Ill-formed request");
+                return std::forward_as_tuple(std::forward<Params>(params)..., allocator);
+            }
+        }
+    }
+};
+
+template<typename Type, typename Other>
+struct uses_allocator_construction<std::pair<Type, Other>> {
+    using type = std::pair<Type, Other>;
+
+    template<typename Allocator, typename First, typename Second>
+    static constexpr auto args(const Allocator &allocator, std::piecewise_construct_t, First &&first, Second &&second) ENTT_NOEXCEPT {
+        return std::make_tuple(
+            std::piecewise_construct,
+            std::apply([&allocator](auto &&...curr) { return uses_allocator_construction<Type>::args(allocator, std::forward<decltype(curr)>(curr)...); }, std::forward<First>(first)),
+            std::apply([&allocator](auto &&...curr) { return uses_allocator_construction<Other>::args(allocator, std::forward<decltype(curr)>(curr)...); }, std::forward<Second>(second)));
+    }
+
+    template<typename Allocator>
+    static constexpr auto args(const Allocator &allocator) ENTT_NOEXCEPT {
+        return uses_allocator_construction<type>::args(allocator, std::piecewise_construct, std::tuple<>{}, std::tuple<>{});
+    }
+
+    template<typename Allocator, typename First, typename Second>
+    static constexpr auto args(const Allocator &allocator, First &&first, Second &&second) ENTT_NOEXCEPT {
+        return uses_allocator_construction<type>::args(allocator, std::piecewise_construct, std::forward_as_tuple(std::forward<First>(first)), std::forward_as_tuple(std::forward<Second>(second)));
+    }
+
+    template<typename Allocator, typename First, typename Second>
+    static constexpr auto args(const Allocator &allocator, const std::pair<First, Second> &value) ENTT_NOEXCEPT {
+        return uses_allocator_construction<type>::args(allocator, std::piecewise_construct, std::forward_as_tuple(value.first), std::forward_as_tuple(value.second));
+    }
+
+    template<typename Allocator, typename First, typename Second>
+    static constexpr auto args(const Allocator &allocator, std::pair<First, Second> &&value) ENTT_NOEXCEPT {
+        return uses_allocator_construction<type>::args(allocator, std::piecewise_construct, std::forward_as_tuple(std::move(value.first)), std::forward_as_tuple(std::move(value.second)));
+    }
+};
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Uses-allocator construction utility (waiting for C++20).
+ *
+ * Primarily intended for internal use. Prepares the argument list needed to
+ * create an object of a given type by means of uses-allocator construction.
+ *
+ * @tparam Type Type to return arguments for.
+ * @tparam Allocator Type of allocator used to manage memory and elements.
+ * @tparam Args Types of arguments to use to construct the object.
+ * @param allocator The allocator to use.
+ * @param args Parameters to use to construct the object.
+ * @return The arguments needed to create an object of the given type.
+ */
+template<typename Type, typename Allocator, typename... Args>
+constexpr auto uses_allocator_construction_args(const Allocator &allocator, Args &&...args) ENTT_NOEXCEPT {
+    return internal::uses_allocator_construction<Type>::args(allocator, std::forward<Args>(args)...);
+}
+
+/**
+ * @brief Uses-allocator construction utility (waiting for C++20).
+ *
+ * Primarily intended for internal use. Creates an object of a given type by
+ * means of uses-allocator construction.
+ *
+ * @tparam Type Type of object to create.
+ * @tparam Allocator Type of allocator used to manage memory and elements.
+ * @tparam Args Types of arguments to use to construct the object.
+ * @param allocator The allocator to use.
+ * @param args Parameters to use to construct the object.
+ * @return A newly created object of the given type.
+ */
+template<typename Type, typename Allocator, typename... Args>
+constexpr Type make_obj_using_allocator(const Allocator &allocator, Args &&...args) {
+    return std::make_from_tuple<Type>(internal::uses_allocator_construction<Type>::args(allocator, std::forward<Args>(args)...));
+}
+
+/**
+ * @brief Uses-allocator construction utility (waiting for C++20).
+ *
+ * Primarily intended for internal use. Creates an object of a given type by
+ * means of uses-allocator construction at an uninitialized memory location.
+ *
+ * @tparam Type Type of object to create.
+ * @tparam Allocator Type of allocator used to manage memory and elements.
+ * @tparam Args Types of arguments to use to construct the object.
+ * @param value Memory location in which to place the object.
+ * @param allocator The allocator to use.
+ * @param args Parameters to use to construct the object.
+ * @return A pointer to the newly created object of the given type.
+ */
+template<typename Type, typename Allocator, typename... Args>
+constexpr Type *uninitialized_construct_using_allocator(Type *value, const Allocator &allocator, Args &&...args) {
+    return std::apply([&](auto &&...curr) { return new(value) Type(std::forward<decltype(curr)>(curr)...); }, internal::uses_allocator_construction<Type>::args(allocator, std::forward<Args>(args)...));
+}
+
+} // namespace entt
+
+#endif

src/entt/core/monostate.hpp

@@ -0,0 +1,56 @@
+#ifndef ENTT_CORE_MONOSTATE_HPP
+#define ENTT_CORE_MONOSTATE_HPP
+
+#include "../config/config.h"
+#include "fwd.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<id_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 {
+        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 value<Type>;
+    }
+
+private:
+    template<typename Type>
+    inline static ENTT_MAYBE_ATOMIC(Type) value{};
+};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Value Value used to differentiate between different variables.
+ */
+template<id_type Value>
+inline monostate<Value> monostate_v = {};
+
+} // namespace entt
+
+#endif

src/entt/core/tuple.hpp

@@ -0,0 +1,29 @@
+#ifndef ENTT_CORE_TUPLE_HPP
+#define ENTT_CORE_TUPLE_HPP
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+
+namespace entt {
+
+/**
+ * @brief Utility function to unwrap tuples of a single element.
+ * @tparam Type Tuple type of any sizes.
+ * @param value A tuple object of the given type.
+ * @return The tuple itself if it contains more than one element, the first
+ * element otherwise.
+ */
+template<typename Type>
+constexpr decltype(auto) unwrap_tuple(Type &&value) ENTT_NOEXCEPT {
+    if constexpr(std::tuple_size_v<std::remove_reference_t<Type>> == 1u) {
+        return std::get<0>(std::forward<Type>(value));
+    } else {
+        return std::forward<Type>(value);
+    }
+}
+
+} // namespace entt
+
+#endif

src/entt/core/type_info.hpp

@@ -0,0 +1,274 @@
+#ifndef ENTT_CORE_TYPE_INFO_HPP
+#define ENTT_CORE_TYPE_INFO_HPP
+
+#include <string_view>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+#include "../core/attribute.h"
+#include "fwd.hpp"
+#include "hashed_string.hpp"
+
+namespace entt {
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+struct ENTT_API type_index final {
+    [[nodiscard]] static id_type next() ENTT_NOEXCEPT {
+        static ENTT_MAYBE_ATOMIC(id_type) value{};
+        return value++;
+    }
+};
+
+template<typename Type>
+[[nodiscard]] constexpr auto stripped_type_name() ENTT_NOEXCEPT {
+#if defined ENTT_PRETTY_FUNCTION
+    std::string_view pretty_function{ENTT_PRETTY_FUNCTION};
+    auto first = pretty_function.find_first_not_of(' ', pretty_function.find_first_of(ENTT_PRETTY_FUNCTION_PREFIX) + 1);
+    auto value = pretty_function.substr(first, pretty_function.find_last_of(ENTT_PRETTY_FUNCTION_SUFFIX) - first);
+    return value;
+#else
+    return std::string_view{""};
+#endif
+}
+
+template<typename Type, auto = stripped_type_name<Type>().find_first_of('.')>
+[[nodiscard]] static constexpr std::string_view type_name(int) ENTT_NOEXCEPT {
+    constexpr auto value = stripped_type_name<Type>();
+    return value;
+}
+
+template<typename Type>
+[[nodiscard]] static std::string_view type_name(char) ENTT_NOEXCEPT {
+    static const auto value = stripped_type_name<Type>();
+    return value;
+}
+
+template<typename Type, auto = stripped_type_name<Type>().find_first_of('.')>
+[[nodiscard]] static constexpr id_type type_hash(int) ENTT_NOEXCEPT {
+    constexpr auto stripped = stripped_type_name<Type>();
+    constexpr auto value = hashed_string::value(stripped.data(), stripped.size());
+    return value;
+}
+
+template<typename Type>
+[[nodiscard]] static id_type type_hash(char) ENTT_NOEXCEPT {
+    static const auto value = [](const auto stripped) {
+        return hashed_string::value(stripped.data(), stripped.size());
+    }(stripped_type_name<Type>());
+    return value;
+}
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Type sequential identifier.
+ * @tparam Type Type for which to generate a sequential identifier.
+ */
+template<typename Type, typename = void>
+struct ENTT_API type_index final {
+    /**
+     * @brief Returns the sequential identifier of a given type.
+     * @return The sequential identifier of a given type.
+     */
+    [[nodiscard]] static id_type value() ENTT_NOEXCEPT {
+        static const id_type value = internal::type_index::next();
+        return value;
+    }
+
+    /*! @copydoc value */
+    [[nodiscard]] constexpr operator id_type() const ENTT_NOEXCEPT {
+        return value();
+    }
+};
+
+/**
+ * @brief Type hash.
+ * @tparam Type Type for which to generate a hash value.
+ */
+template<typename Type, typename = void>
+struct type_hash final {
+    /**
+     * @brief Returns the numeric representation of a given type.
+     * @return The numeric representation of the given type.
+     */
+#if defined ENTT_PRETTY_FUNCTION
+    [[nodiscard]] static constexpr id_type value() ENTT_NOEXCEPT {
+        return internal::type_hash<Type>(0);
+#else
+    [[nodiscard]] static constexpr id_type value() ENTT_NOEXCEPT {
+        return type_index<Type>::value();
+#endif
+    }
+
+    /*! @copydoc value */
+    [[nodiscard]] constexpr operator id_type() const ENTT_NOEXCEPT {
+        return value();
+    }
+};
+
+/**
+ * @brief Type name.
+ * @tparam Type Type for which to generate a name.
+ */
+template<typename Type, typename = void>
+struct type_name final {
+    /**
+     * @brief Returns the name of a given type.
+     * @return The name of the given type.
+     */
+    [[nodiscard]] static constexpr std::string_view value() ENTT_NOEXCEPT {
+        return internal::type_name<Type>(0);
+    }
+
+    /*! @copydoc value */
+    [[nodiscard]] constexpr operator std::string_view() const ENTT_NOEXCEPT {
+        return value();
+    }
+};
+
+/*! @brief Implementation specific information about a type. */
+struct type_info final {
+    /**
+     * @brief Constructs a type info object for a given type.
+     * @tparam Type Type for which to construct a type info object.
+     */
+    template<typename Type>
+    constexpr type_info(std::in_place_type_t<Type>) ENTT_NOEXCEPT
+        : seq{type_index<std::remove_cv_t<std::remove_reference_t<Type>>>::value()},
+          identifier{type_hash<std::remove_cv_t<std::remove_reference_t<Type>>>::value()},
+          alias{type_name<std::remove_cv_t<std::remove_reference_t<Type>>>::value()} {}
+
+    /**
+     * @brief Type index.
+     * @return Type index.
+     */
+    [[nodiscard]] constexpr id_type index() const ENTT_NOEXCEPT {
+        return seq;
+    }
+
+    /**
+     * @brief Type hash.
+     * @return Type hash.
+     */
+    [[nodiscard]] constexpr id_type hash() const ENTT_NOEXCEPT {
+        return identifier;
+    }
+
+    /**
+     * @brief Type name.
+     * @return Type name.
+     */
+    [[nodiscard]] constexpr std::string_view name() const ENTT_NOEXCEPT {
+        return alias;
+    }
+
+private:
+    id_type seq;
+    id_type identifier;
+    std::string_view alias;
+};
+
+/**
+ * @brief Compares the contents of two type info objects.
+ * @param lhs A type info object.
+ * @param rhs A type info object.
+ * @return True if the two type info objects are identical, false otherwise.
+ */
+[[nodiscard]] inline constexpr bool operator==(const type_info &lhs, const type_info &rhs) ENTT_NOEXCEPT {
+    return lhs.hash() == rhs.hash();
+}
+
+/**
+ * @brief Compares the contents of two type info objects.
+ * @param lhs A type info object.
+ * @param rhs A type info object.
+ * @return True if the two type info objects differ, false otherwise.
+ */
+[[nodiscard]] inline constexpr bool operator!=(const type_info &lhs, const type_info &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+/**
+ * @brief Compares two type info objects.
+ * @param lhs A valid type info object.
+ * @param rhs A valid type info object.
+ * @return True if the first element is less than the second, false otherwise.
+ */
+[[nodiscard]] constexpr bool operator<(const type_info &lhs, const type_info &rhs) ENTT_NOEXCEPT {
+    return lhs.index() < rhs.index();
+}
+
+/**
+ * @brief Compares two type info objects.
+ * @param lhs A valid type info object.
+ * @param rhs A valid type info object.
+ * @return True if the first element is less than or equal to the second, false
+ * otherwise.
+ */
+[[nodiscard]] constexpr bool operator<=(const type_info &lhs, const type_info &rhs) ENTT_NOEXCEPT {
+    return !(rhs < lhs);
+}
+
+/**
+ * @brief Compares two type info objects.
+ * @param lhs A valid type info object.
+ * @param rhs A valid type info object.
+ * @return True if the first element is greater than the second, false
+ * otherwise.
+ */
+[[nodiscard]] constexpr bool operator>(const type_info &lhs, const type_info &rhs) ENTT_NOEXCEPT {
+    return rhs < lhs;
+}
+
+/**
+ * @brief Compares two type info objects.
+ * @param lhs A valid type info object.
+ * @param rhs A valid type info object.
+ * @return True if the first element is greater than or equal to the second,
+ * false otherwise.
+ */
+[[nodiscard]] constexpr bool operator>=(const type_info &lhs, const type_info &rhs) ENTT_NOEXCEPT {
+    return !(lhs < rhs);
+}
+
+/**
+ * @brief Returns the type info object associated to a given type.
+ *
+ * The returned element refers to an object with static storage duration.<br/>
+ * The type doesn't need to be a complete type. If the type is a reference, the
+ * result refers to the referenced type. In all cases, top-level cv-qualifiers
+ * are ignored.
+ *
+ * @tparam Type Type for which to generate a type info object.
+ * @return A reference to a properly initialized type info object.
+ */
+template<typename Type>
+[[nodiscard]] const type_info &type_id() ENTT_NOEXCEPT {
+    if constexpr(std::is_same_v<Type, std::remove_cv_t<std::remove_reference_t<Type>>>) {
+        static type_info instance{std::in_place_type<Type>};
+        return instance;
+    } else {
+        return type_id<std::remove_cv_t<std::remove_reference_t<Type>>>();
+    }
+}
+
+/*! @copydoc type_id */
+template<typename Type>
+[[nodiscard]] const type_info &type_id(Type &&) ENTT_NOEXCEPT {
+    return type_id<std::remove_cv_t<std::remove_reference_t<Type>>>();
+}
+
+} // namespace entt
+
+#endif

src/entt/core/type_traits.hpp

@@ -0,0 +1,651 @@
+#ifndef ENTT_CORE_TYPE_TRAITS_HPP
+#define ENTT_CORE_TYPE_TRAITS_HPP
+
+#include <cstddef>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+#include "fwd.hpp"
+
+namespace entt {
+
+/**
+ * @brief Utility class to disambiguate overloaded functions.
+ * @tparam N Number of choices available.
+ */
+template<std::size_t N>
+struct choice_t
+    // Unfortunately, doxygen cannot parse such a construct.
+    : /*! @cond TURN_OFF_DOXYGEN */ choice_t<N - 1> /*! @endcond */
+{};
+
+/*! @copybrief choice_t */
+template<>
+struct choice_t<0> {};
+
+/**
+ * @brief Variable template for the choice trick.
+ * @tparam N Number of choices available.
+ */
+template<std::size_t N>
+inline constexpr choice_t<N> choice{};
+
+/**
+ * @brief Identity type trait.
+ *
+ * Useful to establish non-deduced contexts in template argument deduction
+ * (waiting for C++20) or to provide types through function arguments.
+ *
+ * @tparam Type A type.
+ */
+template<typename Type>
+struct type_identity {
+    /*! @brief Identity type. */
+    using type = Type;
+};
+
+/**
+ * @brief Helper type.
+ * @tparam Type A type.
+ */
+template<typename Type>
+using type_identity_t = typename type_identity<Type>::type;
+
+/**
+ * @brief A type-only `sizeof` wrapper that returns 0 where `sizeof` complains.
+ * @tparam Type The type of which to return the size.
+ * @tparam The size of the type if `sizeof` accepts it, 0 otherwise.
+ */
+template<typename Type, typename = void>
+struct size_of: std::integral_constant<std::size_t, 0u> {};
+
+/*! @copydoc size_of */
+template<typename Type>
+struct size_of<Type, std::void_t<decltype(sizeof(Type))>>
+    : std::integral_constant<std::size_t, sizeof(Type)> {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type The type of which to return the size.
+ */
+template<typename Type>
+inline constexpr std::size_t size_of_v = size_of<Type>::value;
+
+/**
+ * @brief Using declaration to be used to _repeat_ the same type a number of
+ * times equal to the size of a given parameter pack.
+ * @tparam Type A type to repeat.
+ */
+template<typename Type, typename>
+using unpack_as_type = Type;
+
+/**
+ * @brief Helper variable template to be used to _repeat_ the same value a
+ * number of times equal to the size of a given parameter pack.
+ * @tparam Value A value to repeat.
+ */
+template<auto Value, typename>
+inline constexpr auto unpack_as_value = Value;
+
+/**
+ * @brief Wraps a static constant.
+ * @tparam Value A static constant.
+ */
+template<auto Value>
+using integral_constant = std::integral_constant<decltype(Value), Value>;
+
+/**
+ * @brief Alias template to facilitate the creation of named values.
+ * @tparam Value A constant value at least convertible to `id_type`.
+ */
+template<id_type Value>
+using tag = integral_constant<Value>;
+
+/**
+ * @brief A class to use to push around lists of types, nothing more.
+ * @tparam Type Types provided by the type list.
+ */
+template<typename... Type>
+struct type_list {
+    /*! @brief Type list type. */
+    using type = type_list;
+    /*! @brief Compile-time number of elements in the type list. */
+    static constexpr auto size = sizeof...(Type);
+};
+
+/*! @brief Primary template isn't defined on purpose. */
+template<std::size_t, typename>
+struct type_list_element;
+
+/**
+ * @brief Provides compile-time indexed access to the types of a type list.
+ * @tparam Index Index of the type to return.
+ * @tparam Type First type provided by the type list.
+ * @tparam Other Other types provided by the type list.
+ */
+template<std::size_t Index, typename Type, typename... Other>
+struct type_list_element<Index, type_list<Type, Other...>>
+    : type_list_element<Index - 1u, type_list<Other...>> {};
+
+/**
+ * @brief Provides compile-time indexed access to the types of a type list.
+ * @tparam Type First type provided by the type list.
+ * @tparam Other Other types provided by the type list.
+ */
+template<typename Type, typename... Other>
+struct type_list_element<0u, type_list<Type, Other...>> {
+    /*! @brief Searched type. */
+    using type = Type;
+};
+
+/**
+ * @brief Helper type.
+ * @tparam Index Index of the type to return.
+ * @tparam List Type list to search into.
+ */
+template<std::size_t Index, typename List>
+using type_list_element_t = typename type_list_element<Index, List>::type;
+
+/**
+ * @brief Concatenates multiple type lists.
+ * @tparam Type Types provided by the first type list.
+ * @tparam Other Types provided by the second type list.
+ * @return A type list composed by the types of both the type lists.
+ */
+template<typename... Type, typename... Other>
+constexpr type_list<Type..., Other...> operator+(type_list<Type...>, type_list<Other...>) {
+    return {};
+}
+
+/*! @brief Primary template isn't defined on purpose. */
+template<typename...>
+struct type_list_cat;
+
+/*! @brief Concatenates multiple type lists. */
+template<>
+struct type_list_cat<> {
+    /*! @brief A type list composed by the types of all the type lists. */
+    using type = type_list<>;
+};
+
+/**
+ * @brief Concatenates multiple type lists.
+ * @tparam Type Types provided by the first type list.
+ * @tparam Other Types provided by the second type list.
+ * @tparam List Other type lists, if any.
+ */
+template<typename... Type, typename... Other, typename... List>
+struct type_list_cat<type_list<Type...>, type_list<Other...>, List...> {
+    /*! @brief A type list composed by the types of all the type lists. */
+    using type = typename type_list_cat<type_list<Type..., Other...>, List...>::type;
+};
+
+/**
+ * @brief Concatenates multiple type lists.
+ * @tparam Type Types provided by the type list.
+ */
+template<typename... Type>
+struct type_list_cat<type_list<Type...>> {
+    /*! @brief A type list composed by the types of all the type lists. */
+    using type = type_list<Type...>;
+};
+
+/**
+ * @brief Helper type.
+ * @tparam List Type lists to concatenate.
+ */
+template<typename... List>
+using type_list_cat_t = typename type_list_cat<List...>::type;
+
+/*! @brief Primary template isn't defined on purpose. */
+template<typename>
+struct type_list_unique;
+
+/**
+ * @brief Removes duplicates types from a type list.
+ * @tparam Type One of the types provided by the given type list.
+ * @tparam Other The other types provided by the given type list.
+ */
+template<typename Type, typename... Other>
+struct type_list_unique<type_list<Type, Other...>> {
+    /*! @brief A type list without duplicate types. */
+    using type = std::conditional_t<
+        (std::is_same_v<Type, Other> || ...),
+        typename type_list_unique<type_list<Other...>>::type,
+        type_list_cat_t<type_list<Type>, typename type_list_unique<type_list<Other...>>::type>>;
+};
+
+/*! @brief Removes duplicates types from a type list. */
+template<>
+struct type_list_unique<type_list<>> {
+    /*! @brief A type list without duplicate types. */
+    using type = type_list<>;
+};
+
+/**
+ * @brief Helper type.
+ * @tparam Type A type list.
+ */
+template<typename Type>
+using type_list_unique_t = typename type_list_unique<Type>::type;
+
+/**
+ * @brief Provides the member constant `value` to true if a type list contains a
+ * given type, false otherwise.
+ * @tparam List Type list.
+ * @tparam Type Type to look for.
+ */
+template<typename List, typename Type>
+struct type_list_contains;
+
+/**
+ * @copybrief type_list_contains
+ * @tparam Type Types provided by the type list.
+ * @tparam Other Type to look for.
+ */
+template<typename... Type, typename Other>
+struct type_list_contains<type_list<Type...>, Other>: std::disjunction<std::is_same<Type, Other>...> {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam List Type list.
+ * @tparam Type Type to look for.
+ */
+template<typename List, typename Type>
+inline constexpr bool type_list_contains_v = type_list_contains<List, Type>::value;
+
+/*! @brief Primary template isn't defined on purpose. */
+template<typename...>
+struct type_list_diff;
+
+/**
+ * @brief Computes the difference between two type lists.
+ * @tparam Type Types provided by the first type list.
+ * @tparam Other Types provided by the second type list.
+ */
+template<typename... Type, typename... Other>
+struct type_list_diff<type_list<Type...>, type_list<Other...>> {
+    /*! @brief A type list that is the difference between the two type lists. */
+    using type = type_list_cat_t<std::conditional_t<type_list_contains_v<type_list<Other...>, Type>, type_list<>, type_list<Type>>...>;
+};
+
+/**
+ * @brief Helper type.
+ * @tparam List Type lists between which to compute the difference.
+ */
+template<typename... List>
+using type_list_diff_t = typename type_list_diff<List...>::type;
+
+/**
+ * @brief A class to use to push around lists of constant values, nothing more.
+ * @tparam Value Values provided by the value list.
+ */
+template<auto... Value>
+struct value_list {
+    /*! @brief Value list type. */
+    using type = value_list;
+    /*! @brief Compile-time number of elements in the value list. */
+    static constexpr auto size = sizeof...(Value);
+};
+
+/*! @brief Primary template isn't defined on purpose. */
+template<std::size_t, typename>
+struct value_list_element;
+
+/**
+ * @brief Provides compile-time indexed access to the values of a value list.
+ * @tparam Index Index of the value to return.
+ * @tparam Value First value provided by the value list.
+ * @tparam Other Other values provided by the value list.
+ */
+template<std::size_t Index, auto Value, auto... Other>
+struct value_list_element<Index, value_list<Value, Other...>>
+    : value_list_element<Index - 1u, value_list<Other...>> {};
+
+/**
+ * @brief Provides compile-time indexed access to the types of a type list.
+ * @tparam Value First value provided by the value list.
+ * @tparam Other Other values provided by the value list.
+ */
+template<auto Value, auto... Other>
+struct value_list_element<0u, value_list<Value, Other...>> {
+    /*! @brief Searched value. */
+    static constexpr auto value = Value;
+};
+
+/**
+ * @brief Helper type.
+ * @tparam Index Index of the value to return.
+ * @tparam List Value list to search into.
+ */
+template<std::size_t Index, typename List>
+inline constexpr auto value_list_element_v = value_list_element<Index, List>::value;
+
+/**
+ * @brief Concatenates multiple value lists.
+ * @tparam Value Values provided by the first value list.
+ * @tparam Other Values provided by the second value list.
+ * @return A value list composed by the values of both the value lists.
+ */
+template<auto... Value, auto... Other>
+constexpr value_list<Value..., Other...> operator+(value_list<Value...>, value_list<Other...>) {
+    return {};
+}
+
+/*! @brief Primary template isn't defined on purpose. */
+template<typename...>
+struct value_list_cat;
+
+/*! @brief Concatenates multiple value lists. */
+template<>
+struct value_list_cat<> {
+    /*! @brief A value list composed by the values of all the value lists. */
+    using type = value_list<>;
+};
+
+/**
+ * @brief Concatenates multiple value lists.
+ * @tparam Value Values provided by the first value list.
+ * @tparam Other Values provided by the second value list.
+ * @tparam List Other value lists, if any.
+ */
+template<auto... Value, auto... Other, typename... List>
+struct value_list_cat<value_list<Value...>, value_list<Other...>, List...> {
+    /*! @brief A value list composed by the values of all the value lists. */
+    using type = typename value_list_cat<value_list<Value..., Other...>, List...>::type;
+};
+
+/**
+ * @brief Concatenates multiple value lists.
+ * @tparam Value Values provided by the value list.
+ */
+template<auto... Value>
+struct value_list_cat<value_list<Value...>> {
+    /*! @brief A value list composed by the values of all the value lists. */
+    using type = value_list<Value...>;
+};
+
+/**
+ * @brief Helper type.
+ * @tparam List Value lists to concatenate.
+ */
+template<typename... List>
+using value_list_cat_t = typename value_list_cat<List...>::type;
+
+/*! @brief Same as std::is_invocable, but with tuples. */
+template<typename, typename>
+struct is_applicable: std::false_type {};
+
+/**
+ * @copybrief is_applicable
+ * @tparam Func A valid function type.
+ * @tparam Tuple Tuple-like type.
+ * @tparam Args The list of arguments to use to probe the function type.
+ */
+template<typename Func, template<typename...> class Tuple, typename... Args>
+struct is_applicable<Func, Tuple<Args...>>: std::is_invocable<Func, Args...> {};
+
+/**
+ * @copybrief is_applicable
+ * @tparam Func A valid function type.
+ * @tparam Tuple Tuple-like type.
+ * @tparam Args The list of arguments to use to probe the function type.
+ */
+template<typename Func, template<typename...> class Tuple, typename... Args>
+struct is_applicable<Func, const Tuple<Args...>>: std::is_invocable<Func, Args...> {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Func A valid function type.
+ * @tparam Args The list of arguments to use to probe the function type.
+ */
+template<typename Func, typename Args>
+inline constexpr bool is_applicable_v = is_applicable<Func, Args>::value;
+
+/*! @brief Same as std::is_invocable_r, but with tuples for arguments. */
+template<typename, typename, typename>
+struct is_applicable_r: std::false_type {};
+
+/**
+ * @copybrief is_applicable_r
+ * @tparam Ret The type to which the return type of the function should be
+ * convertible.
+ * @tparam Func A valid function type.
+ * @tparam Args The list of arguments to use to probe the function type.
+ */
+template<typename Ret, typename Func, typename... Args>
+struct is_applicable_r<Ret, Func, std::tuple<Args...>>: std::is_invocable_r<Ret, Func, Args...> {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Ret The type to which the return type of the function should be
+ * convertible.
+ * @tparam Func A valid function type.
+ * @tparam Args The list of arguments to use to probe the function type.
+ */
+template<typename Ret, typename Func, typename Args>
+inline constexpr bool is_applicable_r_v = is_applicable_r<Ret, Func, Args>::value;
+
+/**
+ * @brief Provides the member constant `value` to true if a given type is
+ * complete, false otherwise.
+ * @tparam Type The type to test.
+ */
+template<typename Type, typename = void>
+struct is_complete: std::false_type {};
+
+/*! @copydoc is_complete */
+template<typename Type>
+struct is_complete<Type, std::void_t<decltype(sizeof(Type))>>: std::true_type {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type The type to test.
+ */
+template<typename Type>
+inline constexpr bool is_complete_v = is_complete<Type>::value;
+
+/**
+ * @brief Provides the member constant `value` to true if a given type is an
+ * iterator, false otherwise.
+ * @tparam Type The type to test.
+ */
+template<typename Type, typename = void>
+struct is_iterator: std::false_type {};
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename, typename = void>
+struct has_iterator_category: std::false_type {};
+
+template<typename Type>
+struct has_iterator_category<Type, std::void_t<typename std::iterator_traits<Type>::iterator_category>>: std::true_type {};
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/*! @copydoc is_iterator */
+template<typename Type>
+struct is_iterator<Type, std::enable_if_t<!std::is_same_v<std::remove_const_t<std::remove_pointer_t<Type>>, void>>>
+    : internal::has_iterator_category<Type> {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type The type to test.
+ */
+template<typename Type>
+inline constexpr bool is_iterator_v = is_iterator<Type>::value;
+
+/**
+ * @brief Provides the member constant `value` to true if a given type is both
+ * an empty and non-final class, false otherwise.
+ * @tparam Type The type to test
+ */
+template<typename Type>
+struct is_ebco_eligible
+    : std::conjunction<std::is_empty<Type>, std::negation<std::is_final<Type>>> {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type The type to test.
+ */
+template<typename Type>
+inline constexpr bool is_ebco_eligible_v = is_ebco_eligible<Type>::value;
+
+/**
+ * @brief Provides the member constant `value` to true if `Type::is_transparent`
+ * is valid and denotes a type, false otherwise.
+ * @tparam Type The type to test.
+ */
+template<typename Type, typename = void>
+struct is_transparent: std::false_type {};
+
+/*! @copydoc is_transparent */
+template<typename Type>
+struct is_transparent<Type, std::void_t<typename Type::is_transparent>>: std::true_type {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type The type to test.
+ */
+template<typename Type>
+inline constexpr bool is_transparent_v = is_transparent<Type>::value;
+
+/**
+ * @brief Provides the member constant `value` to true if a given type is
+ * equality comparable, false otherwise.
+ * @tparam Type The type to test.
+ */
+template<typename Type, typename = void>
+struct is_equality_comparable: std::false_type {};
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename, typename = void>
+struct has_tuple_size_value: std::false_type {};
+
+template<typename Type>
+struct has_tuple_size_value<Type, std::void_t<decltype(std::tuple_size<const Type>::value)>>: std::true_type {};
+
+template<typename Type, std::size_t... Index>
+[[nodiscard]] constexpr bool unpack_maybe_equality_comparable(std::index_sequence<Index...>) {
+    return (is_equality_comparable<std::tuple_element_t<Index, Type>>::value && ...);
+}
+
+template<typename>
+[[nodiscard]] constexpr bool maybe_equality_comparable(choice_t<0>) {
+    return true;
+}
+
+template<typename Type>
+[[nodiscard]] constexpr auto maybe_equality_comparable(choice_t<1>) -> decltype(std::declval<typename Type::value_type>(), bool{}) {
+    if constexpr(is_iterator_v<Type>) {
+        return true;
+    } else if constexpr(std::is_same_v<typename Type::value_type, Type>) {
+        return maybe_equality_comparable<Type>(choice<0>);
+    } else {
+        return is_equality_comparable<typename Type::value_type>::value;
+    }
+}
+
+template<typename Type>
+[[nodiscard]] constexpr std::enable_if_t<is_complete_v<std::tuple_size<std::remove_const_t<Type>>>, bool> maybe_equality_comparable(choice_t<2>) {
+    if constexpr(has_tuple_size_value<Type>::value) {
+        return unpack_maybe_equality_comparable<Type>(std::make_index_sequence<std::tuple_size<Type>::value>{});
+    } else {
+        return maybe_equality_comparable<Type>(choice<1>);
+    }
+}
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/*! @copydoc is_equality_comparable */
+template<typename Type>
+struct is_equality_comparable<Type, std::void_t<decltype(std::declval<Type>() == std::declval<Type>())>>
+    : std::bool_constant<internal::maybe_equality_comparable<Type>(choice<2>)> {};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type The type to test.
+ */
+template<typename Type>
+inline constexpr bool is_equality_comparable_v = is_equality_comparable<Type>::value;
+
+/**
+ * @brief Transcribes the constness of a type to another type.
+ * @tparam To The type to which to transcribe the constness.
+ * @tparam From The type from which to transcribe the constness.
+ */
+template<typename To, typename From>
+struct constness_as {
+    /*! @brief The type resulting from the transcription of the constness. */
+    using type = std::remove_const_t<To>;
+};
+
+/*! @copydoc constness_as */
+template<typename To, typename From>
+struct constness_as<To, const From> {
+    /*! @brief The type resulting from the transcription of the constness. */
+    using type = std::add_const_t<To>;
+};
+
+/**
+ * @brief Alias template to facilitate the transcription of the constness.
+ * @tparam To The type to which to transcribe the constness.
+ * @tparam From The type from which to transcribe the constness.
+ */
+template<typename To, typename From>
+using constness_as_t = typename constness_as<To, From>::type;
+
+/**
+ * @brief Extracts the class of a non-static member object or function.
+ * @tparam Member A pointer to a non-static member object or function.
+ */
+template<typename Member>
+class member_class {
+    static_assert(std::is_member_pointer_v<Member>, "Invalid pointer type to non-static member object or function");
+
+    template<typename Class, typename Ret, typename... Args>
+    static Class *clazz(Ret (Class::*)(Args...));
+
+    template<typename Class, typename Ret, typename... Args>
+    static Class *clazz(Ret (Class::*)(Args...) const);
+
+    template<typename Class, typename Type>
+    static Class *clazz(Type Class::*);
+
+public:
+    /*! @brief The class of the given non-static member object or function. */
+    using type = std::remove_pointer_t<decltype(clazz(std::declval<Member>()))>;
+};
+
+/**
+ * @brief Helper type.
+ * @tparam Member A pointer to a non-static member object or function.
+ */
+template<typename Member>
+using member_class_t = typename member_class<Member>::type;
+
+} // namespace entt
+
+#endif

src/entt/core/utility.hpp

@@ -0,0 +1,101 @@
+#ifndef ENTT_CORE_UTILITY_HPP
+#define ENTT_CORE_UTILITY_HPP
+
+#include <utility>
+#include "../config/config.h"
+
+namespace entt {
+
+/*! @brief Identity function object (waiting for C++20). */
+struct identity {
+    /*! @brief Indicates that this is a transparent function object. */
+    using is_transparent = void;
+
+    /**
+     * @brief Returns its argument unchanged.
+     * @tparam Type Type of the argument.
+     * @param value The actual argument.
+     * @return The submitted value as-is.
+     */
+    template<class Type>
+    [[nodiscard]] constexpr Type &&operator()(Type &&value) const ENTT_NOEXCEPT {
+        return std::forward<Type>(value);
+    }
+};
+
+/**
+ * @brief Constant utility to disambiguate overloaded members of a class.
+ * @tparam Type Type of the desired overload.
+ * @tparam Class Type of class to which the member belongs.
+ * @param member A valid pointer to a member.
+ * @return Pointer to the member.
+ */
+template<typename Type, typename Class>
+[[nodiscard]] constexpr auto overload(Type Class::*member) ENTT_NOEXCEPT {
+    return member;
+}
+
+/**
+ * @brief Constant utility to disambiguate overloaded functions.
+ * @tparam Func Function type of the desired overload.
+ * @param func A valid pointer to a function.
+ * @return Pointer to the function.
+ */
+template<typename Func>
+[[nodiscard]] constexpr auto overload(Func *func) ENTT_NOEXCEPT {
+    return func;
+}
+
+/**
+ * @brief Helper type for visitors.
+ * @tparam Func Types of function objects.
+ */
+template<class... Func>
+struct overloaded: Func... {
+    using Func::operator()...;
+};
+
+/**
+ * @brief Deduction guide.
+ * @tparam Func Types of function objects.
+ */
+template<class... Func>
+overloaded(Func...) -> overloaded<Func...>;
+
+/**
+ * @brief Basic implementation of a y-combinator.
+ * @tparam Func Type of a potentially recursive function.
+ */
+template<class Func>
+struct y_combinator {
+    /**
+     * @brief Constructs a y-combinator from a given function.
+     * @param recursive A potentially recursive function.
+     */
+    y_combinator(Func recursive)
+        : func{std::move(recursive)} {}
+
+    /**
+     * @brief Invokes a y-combinator and therefore its underlying function.
+     * @tparam Args Types of arguments to use to invoke the underlying function.
+     * @param args Parameters to use to invoke the underlying function.
+     * @return Return value of the underlying function, if any.
+     */
+    template<class... Args>
+    decltype(auto) operator()(Args &&...args) const {
+        return func(*this, std::forward<Args>(args)...);
+    }
+
+    /*! @copydoc operator()() */
+    template<class... Args>
+    decltype(auto) operator()(Args &&...args) {
+        return func(*this, std::forward<Args>(args)...);
+    }
+
+private:
+    Func func;
+};
+
+} // namespace entt
+
+#endif

src/entt/entity/actor.hpp

@@ -1,152 +0,0 @@
-#ifndef ENTT_ENTITY_ACTOR_HPP
-#define ENTT_ENTITY_ACTOR_HPP
-
-
-#include <utility>
-#include "registry.hpp"
-
-
-namespace entt {
-
-
-/**
- * @brief Dedicated to those who aren't confident with entity-component systems.
- *
- * Tiny wrapper around a registry, for all those users that aren't confident
- * with entity-component systems and prefer to iterate objects directly.
- *
- * @tparam Entity A valid entity type (see entt_traits for more details).
- * @tparam Delta Type to use to provide elapsed time.
- */
-template<typename Entity, typename Delta>
-struct Actor {
-    /*! @brief Type of registry used internally. */
-    using registry_type = Registry<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()}
-    {}
-
-    /*! @brief Default destructor. */
-    virtual ~Actor() {
-        reg.destroy(entity);
-    }
-
-    /*! @brief Default copy constructor. */
-    Actor(const Actor &) = default;
-    /*! @brief Default move constructor. */
-    Actor(Actor &&) = default;
-
-    /*! @brief Default copy assignment operator. @return This actor. */
-    Actor & operator=(const Actor &) = default;
-    /*! @brief Default move assignment operator. @return This actor. */
-    Actor & operator=(Actor &&) = default;
-
-    /**
-     * @brief Assigns the given component to an actor.
-     *
-     * A new instance of the given component is created and initialized with the
-     * arguments provided (the component must have a proper constructor or be of
-     * aggregate type). Then the component is assigned to the actor.<br/>
-     * In case the actor already has a component of the given type, it's
-     * replaced with the new one.
-     *
-     * @tparam Component Type of the component to create.
-     * @tparam Args Types of arguments to use to construct the component.
-     * @param args Parameters to use to initialize the component.
-     * @return A reference to the newly created component.
-     */
-    template<typename Component, typename... Args>
-    Component & set(Args&&... args) {
-        return reg.template accomodate<Component>(entity, std::forward<Args>(args)...);
-    }
-
-    /**
-     * @brief Removes the given component from an actor.
-     * @tparam Component Type of the component to remove.
-     */
-    template<typename Component>
-    void unset() {
-        reg.template remove<Component>(entity);
-    }
-
-    /**
-     * @brief Checks if an actor has the given component.
-     * @tparam Component Type of the component for which to perform the check.
-     * @return True if the actor has the component, false otherwise.
-     */
-    template<typename Component>
-    bool has() const noexcept {
-        return reg.template has<Component>(entity);
-    }
-
-    /**
-     * @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.
-     */
-    template<typename Component>
-    const Component & get() const noexcept {
-        return reg.template get<Component>(entity);
-    }
-
-    /**
-     * @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.
-     */
-    template<typename Component>
-    Component & get() 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
-     */
-    const registry_type & registry() const noexcept {
-        return reg;
-    }
-
-    /**
-     * @brief Returns a reference to the underlying registry.
-     * @return A reference to the underlying registry
-     */
-    registry_type & registry() 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.
-     */
-    virtual void update(delta_type delta) = 0;
-
-private:
-    registry_type &reg;
-    Entity entity;
-};
-
-
-/**
- * @brief Default actor class.
- *
- * The default actor is the best choice for almost all the applications.<br/>
- * Users should have a really good reason to choose something different.
- *
- * @tparam Delta Type to use to provide elapsed time.
- */
-template<typename Delta>
-using DefaultActor = Actor<std::uint32_t, Delta>;
-
-
-}
-
-
-#endif // ENTT_ENTITY_ACTOR_HPP

src/entt/entity/component.hpp

@@ -0,0 +1,61 @@
+#ifndef ENTT_ENTITY_COMPONENT_HPP
+#define ENTT_ENTITY_COMPONENT_HPP
+
+#include <cstddef>
+#include <type_traits>
+#include "../config/config.h"
+
+namespace entt {
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename, typename = void>
+struct in_place_delete: std::false_type {};
+
+template<typename Type>
+struct in_place_delete<Type, std::enable_if_t<Type::in_place_delete>>
+    : std::true_type {};
+
+template<typename Type, typename = void>
+struct page_size: std::integral_constant<std::size_t, (ENTT_IGNORE_IF_EMPTY && std::is_empty_v<Type>) ? 0u : ENTT_PACKED_PAGE> {};
+
+template<typename Type>
+struct page_size<Type, std::enable_if_t<std::is_convertible_v<decltype(Type::page_size), std::size_t>>>
+    : std::integral_constant<std::size_t, Type::page_size> {};
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Common way to access various properties of components.
+ * @tparam Type Type of component.
+ */
+template<typename Type, typename = void>
+struct component_traits {
+    static_assert(std::is_same_v<std::decay_t<Type>, Type>, "Unsupported type");
+
+    /*! @brief Pointer stability, default is `false`. */
+    static constexpr bool in_place_delete = internal::in_place_delete<Type>::value;
+    /*! @brief Page size, default is `ENTT_PACKED_PAGE` for non-empty types. */
+    static constexpr std::size_t page_size = internal::page_size<Type>::value;
+};
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type Type of component.
+ */
+template<class Type>
+inline constexpr bool ignore_as_empty_v = (component_traits<Type>::page_size == 0u);
+
+} // namespace entt
+
+#endif

src/entt/entity/entity.hpp

@@ -0,0 +1,339 @@
+#ifndef ENTT_ENTITY_ENTITY_HPP
+#define ENTT_ENTITY_ENTITY_HPP
+
+#include <cstddef>
+#include <cstdint>
+#include <type_traits>
+#include "../config/config.h"
+#include "fwd.hpp"
+
+namespace entt {
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename, typename = void>
+struct entt_traits;
+
+template<typename Type>
+struct entt_traits<Type, std::enable_if_t<std::is_enum_v<Type>>>
+    : entt_traits<std::underlying_type_t<Type>> {};
+
+template<typename Type>
+struct entt_traits<Type, std::enable_if_t<std::is_class_v<Type>>>
+    : entt_traits<typename Type::entity_type> {};
+
+template<>
+struct entt_traits<std::uint32_t> {
+    using entity_type = std::uint32_t;
+    using version_type = std::uint16_t;
+
+    static constexpr entity_type entity_mask = 0xFFFFF;
+    static constexpr entity_type version_mask = 0xFFF;
+    static constexpr std::size_t entity_shift = 20u;
+};
+
+template<>
+struct entt_traits<std::uint64_t> {
+    using entity_type = std::uint64_t;
+    using version_type = std::uint32_t;
+
+    static constexpr entity_type entity_mask = 0xFFFFFFFF;
+    static constexpr entity_type version_mask = 0xFFFFFFFF;
+    static constexpr std::size_t entity_shift = 32u;
+};
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Entity traits.
+ * @tparam Type Type of identifier.
+ */
+template<typename Type>
+class entt_traits: internal::entt_traits<Type> {
+    using base_type = internal::entt_traits<Type>;
+
+public:
+    /*! @brief Value type. */
+    using value_type = Type;
+    /*! @brief Underlying entity type. */
+    using entity_type = typename base_type::entity_type;
+    /*! @brief Underlying version type. */
+    using version_type = typename base_type::version_type;
+    /*! @brief Reserved identifier. */
+    static constexpr entity_type reserved = base_type::entity_mask | (base_type::version_mask << base_type::entity_shift);
+    /*! @brief Page size, default is `ENTT_SPARSE_PAGE`. */
+    static constexpr auto page_size = ENTT_SPARSE_PAGE;
+
+    /**
+     * @brief Converts an entity to its underlying type.
+     * @param value The value to convert.
+     * @return The integral representation of the given value.
+     */
+    [[nodiscard]] static constexpr entity_type to_integral(const value_type value) ENTT_NOEXCEPT {
+        return static_cast<entity_type>(value);
+    }
+
+    /**
+     * @brief Returns the entity part once converted to the underlying type.
+     * @param value The value to convert.
+     * @return The integral representation of the entity part.
+     */
+    [[nodiscard]] static constexpr entity_type to_entity(const value_type value) ENTT_NOEXCEPT {
+        return (to_integral(value) & base_type::entity_mask);
+    }
+
+    /**
+     * @brief Returns the version part once converted to the underlying type.
+     * @param value The value to convert.
+     * @return The integral representation of the version part.
+     */
+    [[nodiscard]] static constexpr version_type to_version(const value_type value) ENTT_NOEXCEPT {
+        return (to_integral(value) >> base_type::entity_shift);
+    }
+
+    /**
+     * @brief Constructs an identifier from its parts.
+     *
+     * If the version part is not provided, a tombstone is returned.<br/>
+     * If the entity part is not provided, a null identifier is returned.
+     *
+     * @param entity The entity part of the identifier.
+     * @param version The version part of the identifier.
+     * @return A properly constructed identifier.
+     */
+    [[nodiscard]] static constexpr value_type construct(const entity_type entity, const version_type version) ENTT_NOEXCEPT {
+        return value_type{(entity & base_type::entity_mask) | (static_cast<entity_type>(version) << base_type::entity_shift)};
+    }
+
+    /**
+     * @brief Combines two identifiers in a single one.
+     *
+     * The returned identifier is a copy of the first element except for its
+     * version, which is taken from the second element.
+     *
+     * @param lhs The identifier from which to take the entity part.
+     * @param rhs The identifier from which to take the version part.
+     * @return A properly constructed identifier.
+     */
+    [[nodiscard]] static constexpr value_type combine(const entity_type lhs, const entity_type rhs) ENTT_NOEXCEPT {
+        constexpr auto mask = (base_type::version_mask << base_type::entity_shift);
+        return value_type{(lhs & base_type::entity_mask) | (rhs & mask)};
+    }
+};
+
+/**
+ * @copydoc entt_traits<Entity>::to_integral
+ * @tparam Entity The value type.
+ */
+template<typename Entity>
+[[nodiscard]] constexpr typename entt_traits<Entity>::entity_type to_integral(const Entity value) ENTT_NOEXCEPT {
+    return entt_traits<Entity>::to_integral(value);
+}
+
+/**
+ * @copydoc entt_traits<Entity>::to_entity
+ * @tparam Entity The value type.
+ */
+template<typename Entity>
+[[nodiscard]] constexpr typename entt_traits<Entity>::entity_type to_entity(const Entity value) ENTT_NOEXCEPT {
+    return entt_traits<Entity>::to_entity(value);
+}
+
+/**
+ * @copydoc entt_traits<Entity>::to_version
+ * @tparam Entity The value type.
+ */
+template<typename Entity>
+[[nodiscard]] constexpr typename entt_traits<Entity>::version_type to_version(const Entity value) ENTT_NOEXCEPT {
+    return entt_traits<Entity>::to_version(value);
+}
+
+/*! @brief Null object for all identifiers.  */
+struct null_t {
+    /**
+     * @brief Converts the null object to identifiers of any type.
+     * @tparam Entity Type of identifier.
+     * @return The null representation for the given type.
+     */
+    template<typename Entity>
+    [[nodiscard]] constexpr operator Entity() const ENTT_NOEXCEPT {
+        using entity_traits = entt_traits<Entity>;
+        return entity_traits::combine(entity_traits::reserved, entity_traits::reserved);
+    }
+
+    /**
+     * @brief Compares two null objects.
+     * @param other A null object.
+     * @return True in all cases.
+     */
+    [[nodiscard]] constexpr bool operator==([[maybe_unused]] const null_t other) const ENTT_NOEXCEPT {
+        return true;
+    }
+
+    /**
+     * @brief Compares two null objects.
+     * @param other A null object.
+     * @return False in all cases.
+     */
+    [[nodiscard]] constexpr bool operator!=([[maybe_unused]] const null_t other) const ENTT_NOEXCEPT {
+        return false;
+    }
+
+    /**
+     * @brief Compares a null object and an identifier of any type.
+     * @tparam Entity Type of identifier.
+     * @param entity Identifier with which to compare.
+     * @return False if the two elements differ, true otherwise.
+     */
+    template<typename Entity>
+    [[nodiscard]] constexpr bool operator==(const Entity entity) const ENTT_NOEXCEPT {
+        using entity_traits = entt_traits<Entity>;
+        return entity_traits::to_entity(entity) == entity_traits::to_entity(*this);
+    }
+
+    /**
+     * @brief Compares a null object and an identifier of any type.
+     * @tparam Entity Type of identifier.
+     * @param entity Identifier with which to compare.
+     * @return True if the two elements differ, false otherwise.
+     */
+    template<typename Entity>
+    [[nodiscard]] constexpr bool operator!=(const Entity entity) const ENTT_NOEXCEPT {
+        return !(entity == *this);
+    }
+};
+
+/**
+ * @brief Compares a null object and an identifier of any type.
+ * @tparam Entity Type of identifier.
+ * @param entity Identifier with which to compare.
+ * @param other A null object yet to be converted.
+ * @return False if the two elements differ, true otherwise.
+ */
+template<typename Entity>
+[[nodiscard]] constexpr bool operator==(const Entity entity, const null_t other) ENTT_NOEXCEPT {
+    return other.operator==(entity);
+}
+
+/**
+ * @brief Compares a null object and an identifier of any type.
+ * @tparam Entity Type of identifier.
+ * @param entity Identifier with which to compare.
+ * @param other A null object yet to be converted.
+ * @return True if the two elements differ, false otherwise.
+ */
+template<typename Entity>
+[[nodiscard]] constexpr bool operator!=(const Entity entity, const null_t other) ENTT_NOEXCEPT {
+    return !(other == entity);
+}
+
+/*! @brief Tombstone object for all identifiers.  */
+struct tombstone_t {
+    /**
+     * @brief Converts the tombstone object to identifiers of any type.
+     * @tparam Entity Type of identifier.
+     * @return The tombstone representation for the given type.
+     */
+    template<typename Entity>
+    [[nodiscard]] constexpr operator Entity() const ENTT_NOEXCEPT {
+        using entity_traits = entt_traits<Entity>;
+        return entity_traits::combine(entity_traits::reserved, entity_traits::reserved);
+    }
+
+    /**
+     * @brief Compares two tombstone objects.
+     * @param other A tombstone object.
+     * @return True in all cases.
+     */
+    [[nodiscard]] constexpr bool operator==([[maybe_unused]] const tombstone_t other) const ENTT_NOEXCEPT {
+        return true;
+    }
+
+    /**
+     * @brief Compares two tombstone objects.
+     * @param other A tombstone object.
+     * @return False in all cases.
+     */
+    [[nodiscard]] constexpr bool operator!=([[maybe_unused]] const tombstone_t other) const ENTT_NOEXCEPT {
+        return false;
+    }
+
+    /**
+     * @brief Compares a tombstone object and an identifier of any type.
+     * @tparam Entity Type of identifier.
+     * @param entity Identifier with which to compare.
+     * @return False if the two elements differ, true otherwise.
+     */
+    template<typename Entity>
+    [[nodiscard]] constexpr bool operator==(const Entity entity) const ENTT_NOEXCEPT {
+        using entity_traits = entt_traits<Entity>;
+        return entity_traits::to_version(entity) == entity_traits::to_version(*this);
+    }
+
+    /**
+     * @brief Compares a tombstone object and an identifier of any type.
+     * @tparam Entity Type of identifier.
+     * @param entity Identifier with which to compare.
+     * @return True if the two elements differ, false otherwise.
+     */
+    template<typename Entity>
+    [[nodiscard]] constexpr bool operator!=(const Entity entity) const ENTT_NOEXCEPT {
+        return !(entity == *this);
+    }
+};
+
+/**
+ * @brief Compares a tombstone object and an identifier of any type.
+ * @tparam Entity Type of identifier.
+ * @param entity Identifier with which to compare.
+ * @param other A tombstone object yet to be converted.
+ * @return False if the two elements differ, true otherwise.
+ */
+template<typename Entity>
+[[nodiscard]] constexpr bool operator==(const Entity entity, const tombstone_t other) ENTT_NOEXCEPT {
+    return other.operator==(entity);
+}
+
+/**
+ * @brief Compares a tombstone object and an identifier of any type.
+ * @tparam Entity Type of identifier.
+ * @param entity Identifier with which to compare.
+ * @param other A tombstone object yet to be converted.
+ * @return True if the two elements differ, false otherwise.
+ */
+template<typename Entity>
+[[nodiscard]] constexpr bool operator!=(const Entity entity, const tombstone_t other) ENTT_NOEXCEPT {
+    return !(other == entity);
+}
+
+/**
+ * @brief Compile-time constant for null entities.
+ *
+ * There exist implicit conversions from this variable to identifiers of any
+ * allowed type. Similarly, there exist comparison operators between the null
+ * entity and any other identifier.
+ */
+inline constexpr null_t null{};
+
+/**
+ * @brief Compile-time constant for tombstone entities.
+ *
+ * There exist implicit conversions from this variable to identifiers of any
+ * allowed type. Similarly, there exist comparison operators between the
+ * tombstone entity and any other identifier.
+ */
+inline constexpr tombstone_t tombstone{};
+
+} // namespace entt
+
+#endif

src/entt/entity/fwd.hpp

@@ -0,0 +1,117 @@
+#ifndef ENTT_ENTITY_FWD_HPP
+#define ENTT_ENTITY_FWD_HPP
+
+#include <memory>
+#include "../core/fwd.hpp"
+#include "utility.hpp"
+
+namespace entt {
+
+template<typename Entity, typename = std::allocator<Entity>>
+class basic_sparse_set;
+
+template<typename, typename Type, typename = std::allocator<Type>, typename = void>
+class basic_storage;
+
+template<typename>
+class basic_registry;
+
+template<typename, typename, typename, typename = void>
+class basic_view;
+
+template<typename>
+struct basic_runtime_view;
+
+template<typename, typename, typename, typename>
+class basic_group;
+
+template<typename>
+class basic_observer;
+
+template<typename>
+class basic_organizer;
+
+template<typename, typename...>
+struct basic_handle;
+
+template<typename>
+class basic_snapshot;
+
+template<typename>
+class basic_snapshot_loader;
+
+template<typename>
+class basic_continuous_loader;
+
+/*! @brief Default entity identifier. */
+enum class entity : id_type {};
+
+/*! @brief Alias declaration for the most common use case. */
+using sparse_set = basic_sparse_set<entity>;
+
+/**
+ * @brief Alias declaration for the most common use case.
+ * @tparam Args Other template parameters.
+ */
+template<typename... Args>
+using storage = basic_storage<entity, Args...>;
+
+/*! @brief Alias declaration for the most common use case. */
+using registry = basic_registry<entity>;
+
+/*! @brief Alias declaration for the most common use case. */
+using observer = basic_observer<entity>;
+
+/*! @brief Alias declaration for the most common use case. */
+using organizer = basic_organizer<entity>;
+
+/*! @brief Alias declaration for the most common use case. */
+using handle = basic_handle<entity>;
+
+/*! @brief Alias declaration for the most common use case. */
+using const_handle = basic_handle<const entity>;
+
+/**
+ * @brief Alias declaration for the most common use case.
+ * @tparam Args Other template parameters.
+ */
+template<typename... Args>
+using handle_view = basic_handle<entity, Args...>;
+
+/**
+ * @brief Alias declaration for the most common use case.
+ * @tparam Args Other template parameters.
+ */
+template<typename... Args>
+using const_handle_view = basic_handle<const entity, Args...>;
+
+/*! @brief Alias declaration for the most common use case. */
+using snapshot = basic_snapshot<entity>;
+
+/*! @brief Alias declaration for the most common use case. */
+using snapshot_loader = basic_snapshot_loader<entity>;
+
+/*! @brief Alias declaration for the most common use case. */
+using continuous_loader = basic_continuous_loader<entity>;
+
+/**
+ * @brief Alias declaration for the most common use case.
+ * @tparam Get Types of components iterated by the view.
+ * @tparam Exclude Types of components used to filter the view.
+ */
+template<typename Get, typename Exclude = exclude_t<>>
+using view = basic_view<entity, Get, Exclude>;
+
+/*! @brief Alias declaration for the most common use case. */
+using runtime_view = basic_runtime_view<sparse_set>;
+
+/**
+ * @brief Alias declaration for the most common use case.
+ * @tparam Args Other template parameters.
+ */
+template<typename... Args>
+using group = basic_group<entity, Args...>;
+
+} // namespace entt
+
+#endif

src/entt/entity/group.hpp

@@ -0,0 +1,905 @@
+#ifndef ENTT_ENTITY_GROUP_HPP
+#define ENTT_ENTITY_GROUP_HPP
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+#include "../core/iterator.hpp"
+#include "../core/type_traits.hpp"
+#include "component.hpp"
+#include "entity.hpp"
+#include "fwd.hpp"
+#include "sparse_set.hpp"
+#include "storage.hpp"
+#include "utility.hpp"
+
+namespace entt {
+
+/**
+ * @brief Group.
+ *
+ * Primary template isn't defined on purpose. All the specializations give a
+ * compile-time error, but for a few reasonable cases.
+ */
+template<typename, typename, typename, typename>
+class basic_group;
+
+/**
+ * @brief Non-owning group.
+ *
+ * A non-owning group returns all entities and only the entities that have at
+ * least the given components. Moreover, it's guaranteed that the entity list
+ * is tightly packed in memory for fast iterations.
+ *
+ * @b Important
+ *
+ * Iterators aren't invalidated if:
+ *
+ * * New instances of the given components are created and assigned to entities.
+ * * The entity currently pointed is modified (as an example, if one of the
+ *   given components is removed from the entity to which the iterator points).
+ * * The entity currently pointed is destroyed.
+ *
+ * In all other cases, modifying the pools iterated by the group in any way
+ * invalidates all the iterators and using them results in undefined behavior.
+ *
+ * @note
+ * Groups share references to the underlying data structures of the registry
+ * that generated them. Therefore any change to the entities and to the
+ * components made by means of the registry are immediately reflected by all the
+ * groups.<br/>
+ * Moreover, sorting a non-owning group affects all the instances of the same
+ * group (it means that users don't have to call `sort` on each instance to sort
+ * all of them because they _share_ entities and components).
+ *
+ * @warning
+ * Lifetime of a group must not overcome that of the registry that generated it.
+ * In any other case, attempting to use a group results in undefined behavior.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Get Type of components observed by the group.
+ * @tparam Exclude Types of components used to filter the group.
+ */
+template<typename Entity, typename... Get, typename... Exclude>
+class basic_group<Entity, owned_t<>, get_t<Get...>, exclude_t<Exclude...>> {
+    /*! @brief A registry is allowed to create groups. */
+    friend class basic_registry<Entity>;
+
+    template<typename Comp>
+    using storage_type = constness_as_t<typename storage_traits<Entity, std::remove_const_t<Comp>>::storage_type, Comp>;
+
+    using basic_common_type = std::common_type_t<typename storage_type<Get>::base_type...>;
+
+    struct extended_group_iterator final {
+        using difference_type = std::ptrdiff_t;
+        using value_type = decltype(std::tuple_cat(std::tuple<Entity>{}, std::declval<basic_group>().get({})));
+        using pointer = input_iterator_pointer<value_type>;
+        using reference = value_type;
+        using iterator_category = std::input_iterator_tag;
+
+        extended_group_iterator() = default;
+
+        extended_group_iterator(typename basic_common_type::iterator from, const std::tuple<storage_type<Get> *...> &args)
+            : it{from},
+              pools{args} {}
+
+        extended_group_iterator &operator++() ENTT_NOEXCEPT {
+            return ++it, *this;
+        }
+
+        extended_group_iterator operator++(int) ENTT_NOEXCEPT {
+            extended_group_iterator orig = *this;
+            return ++(*this), orig;
+        }
+
+        [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
+            const auto entt = *it;
+            return std::tuple_cat(std::make_tuple(entt), std::get<storage_type<Get> *>(pools)->get_as_tuple(entt)...);
+        }
+
+        [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
+            return operator*();
+        }
+
+        [[nodiscard]] bool operator==(const extended_group_iterator &other) const ENTT_NOEXCEPT {
+            return other.it == it;
+        }
+
+        [[nodiscard]] bool operator!=(const extended_group_iterator &other) const ENTT_NOEXCEPT {
+            return !(*this == other);
+        }
+
+    private:
+        typename basic_common_type::iterator it;
+        std::tuple<storage_type<Get> *...> pools;
+    };
+
+    basic_group(basic_common_type &ref, storage_type<Get> &...gpool) ENTT_NOEXCEPT
+        : handler{&ref},
+          pools{&gpool...} {}
+
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+    /*! @brief Common type among all storage types. */
+    using base_type = basic_common_type;
+    /*! @brief Random access iterator type. */
+    using iterator = typename base_type::iterator;
+    /*! @brief Reversed iterator type. */
+    using reverse_iterator = typename base_type::reverse_iterator;
+    /*! @brief Iterable group type. */
+    using iterable = iterable_adaptor<extended_group_iterator>;
+
+    /*! @brief Default constructor to use to create empty, invalid groups. */
+    basic_group() ENTT_NOEXCEPT
+        : handler{} {}
+
+    /**
+     * @brief Returns a const reference to the underlying handler.
+     * @return A const reference to the underlying handler.
+     */
+    const base_type &handle() const ENTT_NOEXCEPT {
+        return *handler;
+    }
+
+    /**
+     * @brief Returns the storage for a given component type.
+     * @tparam Comp Type of component of which to return the storage.
+     * @return The storage for the given component type.
+     */
+    template<typename Comp>
+    [[nodiscard]] decltype(auto) storage() const ENTT_NOEXCEPT {
+        return *std::get<storage_type<Comp> *>(pools);
+    }
+
+    /**
+     * @brief Returns the storage for a given component type.
+     * @tparam Comp Index of component of which to return the storage.
+     * @return The storage for the given component type.
+     */
+    template<std::size_t Comp>
+    [[nodiscard]] decltype(auto) storage() const ENTT_NOEXCEPT {
+        return *std::get<Comp>(pools);
+    }
+
+    /**
+     * @brief Returns the number of entities that have the given components.
+     * @return Number of entities that have the given components.
+     */
+    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
+        return *this ? handler->size() : size_type{};
+    }
+
+    /**
+     * @brief Returns the number of elements that a group has currently
+     * allocated space for.
+     * @return Capacity of the group.
+     */
+    [[nodiscard]] size_type capacity() const ENTT_NOEXCEPT {
+        return *this ? handler->capacity() : size_type{};
+    }
+
+    /*! @brief Requests the removal of unused capacity. */
+    void shrink_to_fit() {
+        if(*this) {
+            handler->shrink_to_fit();
+        }
+    }
+
+    /**
+     * @brief Checks whether a group is empty.
+     * @return True if the group is empty, false otherwise.
+     */
+    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
+        return !*this || handler->empty();
+    }
+
+    /**
+     * @brief Returns an iterator to the first entity of the group.
+     *
+     * The returned iterator points to the first entity of the group. If the
+     * group is empty, the returned iterator will be equal to `end()`.
+     *
+     * @return An iterator to the first entity of the group.
+     */
+    [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
+        return *this ? handler->begin() : iterator{};
+    }
+
+    /**
+     * @brief Returns an iterator that is past the last entity of the group.
+     *
+     * The returned iterator points to the entity following the last entity of
+     * the group. Attempting to dereference the returned iterator results in
+     * undefined behavior.
+     *
+     * @return An iterator to the entity following the last entity of the
+     * group.
+     */
+    [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
+        return *this ? handler->end() : iterator{};
+    }
+
+    /**
+     * @brief Returns an iterator to the first entity of the reversed group.
+     *
+     * The returned iterator points to the first entity of the reversed group.
+     * If the group is empty, the returned iterator will be equal to `rend()`.
+     *
+     * @return An iterator to the first entity of the reversed group.
+     */
+    [[nodiscard]] reverse_iterator rbegin() const ENTT_NOEXCEPT {
+        return *this ? handler->rbegin() : reverse_iterator{};
+    }
+
+    /**
+     * @brief Returns an iterator that is past the last entity of the reversed
+     * group.
+     *
+     * The returned iterator points to the entity following the last entity of
+     * the reversed group. Attempting to dereference the returned iterator
+     * results in undefined behavior.
+     *
+     * @return An iterator to the entity following the last entity of the
+     * reversed group.
+     */
+    [[nodiscard]] reverse_iterator rend() const ENTT_NOEXCEPT {
+        return *this ? handler->rend() : reverse_iterator{};
+    }
+
+    /**
+     * @brief Returns the first entity of the group, if any.
+     * @return The first entity of the group if one exists, the null entity
+     * otherwise.
+     */
+    [[nodiscard]] entity_type front() const ENTT_NOEXCEPT {
+        const auto it = begin();
+        return it != end() ? *it : null;
+    }
+
+    /**
+     * @brief Returns the last entity of the group, if any.
+     * @return The last entity of the group if one exists, the null entity
+     * otherwise.
+     */
+    [[nodiscard]] entity_type back() const ENTT_NOEXCEPT {
+        const auto it = rbegin();
+        return it != rend() ? *it : null;
+    }
+
+    /**
+     * @brief Finds an entity.
+     * @param entt A valid identifier.
+     * @return An iterator to the given entity if it's found, past the end
+     * iterator otherwise.
+     */
+    [[nodiscard]] iterator find(const entity_type entt) const ENTT_NOEXCEPT {
+        const auto it = *this ? handler->find(entt) : iterator{};
+        return it != end() && *it == entt ? it : end();
+    }
+
+    /**
+     * @brief Returns the identifier that occupies the given position.
+     * @param pos Position of the element to return.
+     * @return The identifier that occupies the given position.
+     */
+    [[nodiscard]] entity_type operator[](const size_type pos) const {
+        return begin()[pos];
+    }
+
+    /**
+     * @brief Checks if a group is properly initialized.
+     * @return True if the group is properly initialized, false otherwise.
+     */
+    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
+        return handler != nullptr;
+    }
+
+    /**
+     * @brief Checks if a group contains an entity.
+     * @param entt A valid identifier.
+     * @return True if the group contains the given entity, false otherwise.
+     */
+    [[nodiscard]] bool contains(const entity_type entt) const ENTT_NOEXCEPT {
+        return *this && handler->contains(entt);
+    }
+
+    /**
+     * @brief Returns the components assigned to the given entity.
+     *
+     * Prefer this function instead of `registry::get` during iterations. It has
+     * far better performance than its counterpart.
+     *
+     * @warning
+     * Attempting to use an invalid component type results in a compilation
+     * error. Attempting to use an entity that doesn't belong to the group
+     * results in undefined behavior.
+     *
+     * @tparam Comp Types of components to get.
+     * @param entt A valid identifier.
+     * @return The components assigned to the entity.
+     */
+    template<typename... Comp>
+    [[nodiscard]] decltype(auto) get(const entity_type entt) const {
+        ENTT_ASSERT(contains(entt), "Group does not contain entity");
+
+        if constexpr(sizeof...(Comp) == 0) {
+            return std::tuple_cat(std::get<storage_type<Get> *>(pools)->get_as_tuple(entt)...);
+        } else if constexpr(sizeof...(Comp) == 1) {
+            return (std::get<storage_type<Comp> *>(pools)->get(entt), ...);
+        } else {
+            return std::tuple_cat(std::get<storage_type<Comp> *>(pools)->get_as_tuple(entt)...);
+        }
+    }
+
+    /**
+     * @brief Iterates entities and components and applies the given function
+     * object to them.
+     *
+     * The function object is invoked for each entity. It is provided with the
+     * entity itself and a set of references to non-empty components. The
+     * _constness_ of the components is as requested.<br/>
+     * The signature of the function must be equivalent to one of the following
+     * forms:
+     *
+     * @code{.cpp}
+     * void(const entity_type, Type &...);
+     * void(Type &...);
+     * @endcode
+     *
+     * @note
+     * Empty types aren't explicitly instantiated and therefore they are never
+     * returned during iterations.
+     *
+     * @tparam Func Type of the function object to invoke.
+     * @param func A valid function object.
+     */
+    template<typename Func>
+    void each(Func func) const {
+        for(const auto entt: *this) {
+            if constexpr(is_applicable_v<Func, decltype(std::tuple_cat(std::tuple<entity_type>{}, std::declval<basic_group>().get({})))>) {
+                std::apply(func, std::tuple_cat(std::make_tuple(entt), get(entt)));
+            } else {
+                std::apply(func, get(entt));
+            }
+        }
+    }
+
+    /**
+     * @brief Returns an iterable object to use to _visit_ a group.
+     *
+     * The iterable object returns tuples that contain the current entity and a
+     * set of references to its non-empty components. The _constness_ of the
+     * components is as requested.
+     *
+     * @note
+     * Empty types aren't explicitly instantiated and therefore they are never
+     * returned during iterations.
+     *
+     * @return An iterable object to use to _visit_ the group.
+     */
+    [[nodiscard]] iterable each() const ENTT_NOEXCEPT {
+        return handler ? iterable{extended_group_iterator{handler->begin(), pools}, extended_group_iterator{handler->end(), pools}}
+                       : iterable{extended_group_iterator{{}, pools}, extended_group_iterator{{}, pools}};
+    }
+
+    /**
+     * @brief Sort a group according to the given comparison function.
+     *
+     * Sort the group so that iterating it with a couple of iterators returns
+     * entities and components in the expected order. See `begin` and `end` for
+     * more details.
+     *
+     * The comparison function object must return `true` if the first element
+     * is _less_ than the second one, `false` otherwise. The signature of the
+     * comparison function should be equivalent to one of the following:
+     *
+     * @code{.cpp}
+     * bool(std::tuple<Component &...>, std::tuple<Component &...>);
+     * bool(const Component &..., const Component &...);
+     * bool(const Entity, const Entity);
+     * @endcode
+     *
+     * Where `Component` are such that they are iterated by the group.<br/>
+     * Moreover, the comparison function object shall induce a
+     * _strict weak ordering_ on the values.
+     *
+     * The sort function object 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.
+     *
+     * @tparam Comp Optional types of components to compare.
+     * @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 algo A valid sort function object.
+     * @param args Arguments to forward to the sort function object, if any.
+     */
+    template<typename... Comp, typename Compare, typename Sort = std_sort, typename... Args>
+    void sort(Compare compare, Sort algo = Sort{}, Args &&...args) {
+        if(*this) {
+            if constexpr(sizeof...(Comp) == 0) {
+                static_assert(std::is_invocable_v<Compare, const entity_type, const entity_type>, "Invalid comparison function");
+                handler->sort(std::move(compare), std::move(algo), std::forward<Args>(args)...);
+            } else {
+                auto comp = [this, &compare](const entity_type lhs, const entity_type rhs) {
+                    if constexpr(sizeof...(Comp) == 1) {
+                        return compare((std::get<storage_type<Comp> *>(pools)->get(lhs), ...), (std::get<storage_type<Comp> *>(pools)->get(rhs), ...));
+                    } else {
+                        return compare(std::forward_as_tuple(std::get<storage_type<Comp> *>(pools)->get(lhs)...), std::forward_as_tuple(std::get<storage_type<Comp> *>(pools)->get(rhs)...));
+                    }
+                };
+
+                handler->sort(std::move(comp), std::move(algo), std::forward<Args>(args)...);
+            }
+        }
+    }
+
+    /**
+     * @brief Sort the shared pool of entities according to the given component.
+     *
+     * Non-owning groups of the same type share with the registry a pool of
+     * entities with its own order that doesn't depend on the order of any pool
+     * of components. Users can order the underlying data structure so that it
+     * respects the order of the pool of the given component.
+     *
+     * @note
+     * The shared pool of entities and thus its order is affected by the changes
+     * to each and every pool that it tracks. Therefore changes to those pools
+     * can quickly ruin the order imposed to the pool of entities shared between
+     * the non-owning groups.
+     *
+     * @tparam Comp Type of component to use to impose the order.
+     */
+    template<typename Comp>
+    void sort() const {
+        if(*this) {
+            handler->respect(*std::get<storage_type<Comp> *>(pools));
+        }
+    }
+
+private:
+    base_type *const handler;
+    const std::tuple<storage_type<Get> *...> pools;
+};
+
+/**
+ * @brief Owning group.
+ *
+ * Owning groups return all entities and only the entities that have at least
+ * the given components. Moreover:
+ *
+ * * It's guaranteed that the entity list is tightly packed in memory for fast
+ *   iterations.
+ * * It's guaranteed that the lists of owned components are tightly packed in
+ *   memory for even faster iterations and to allow direct access.
+ * * They stay true to the order of the owned components and all instances have
+ *   the same order in memory.
+ *
+ * The more types of components are owned by a group, the faster it is to
+ * iterate them.
+ *
+ * @b Important
+ *
+ * Iterators aren't invalidated if:
+ *
+ * * New instances of the given components are created and assigned to entities.
+ * * The entity currently pointed is modified (as an example, if one of the
+ *   given components is removed from the entity to which the iterator points).
+ * * The entity currently pointed is destroyed.
+ *
+ * In all other cases, modifying the pools iterated by the group in any way
+ * invalidates all the iterators and using them results in undefined behavior.
+ *
+ * @note
+ * Groups share references to the underlying data structures of the registry
+ * that generated them. Therefore any change to the entities and to the
+ * components made by means of the registry are immediately reflected by all the
+ * groups.
+ * Moreover, sorting an owning group affects all the instance of the same group
+ * (it means that users don't have to call `sort` on each instance to sort all
+ * of them because they share the underlying data structure).
+ *
+ * @warning
+ * Lifetime of a group must not overcome that of the registry that generated it.
+ * In any other case, attempting to use a group results in undefined behavior.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Owned Types of components owned by the group.
+ * @tparam Get Types of components observed by the group.
+ * @tparam Exclude Types of components used to filter the group.
+ */
+template<typename Entity, typename... Owned, typename... Get, typename... Exclude>
+class basic_group<Entity, owned_t<Owned...>, get_t<Get...>, exclude_t<Exclude...>> {
+    /*! @brief A registry is allowed to create groups. */
+    friend class basic_registry<Entity>;
+
+    template<typename Comp>
+    using storage_type = constness_as_t<typename storage_traits<Entity, std::remove_const_t<Comp>>::storage_type, Comp>;
+
+    using basic_common_type = std::common_type_t<typename storage_type<Owned>::base_type..., typename storage_type<Get>::base_type...>;
+
+    class extended_group_iterator final {
+        template<typename Type>
+        auto index_to_element(storage_type<Type> &cpool) const {
+            if constexpr(ignore_as_empty_v<std::remove_const_t<Type>>) {
+                return std::make_tuple();
+            } else {
+                return std::forward_as_tuple(cpool.rbegin()[it.index()]);
+            }
+        }
+
+    public:
+        using difference_type = std::ptrdiff_t;
+        using value_type = decltype(std::tuple_cat(std::tuple<Entity>{}, std::declval<basic_group>().get({})));
+        using pointer = input_iterator_pointer<value_type>;
+        using reference = value_type;
+        using iterator_category = std::input_iterator_tag;
+
+        extended_group_iterator() = default;
+
+        template<typename... Other>
+        extended_group_iterator(typename basic_common_type::iterator from, const std::tuple<storage_type<Owned> *..., storage_type<Get> *...> &cpools)
+            : it{from},
+              pools{cpools} {}
+
+        extended_group_iterator &operator++() ENTT_NOEXCEPT {
+            return ++it, *this;
+        }
+
+        extended_group_iterator operator++(int) ENTT_NOEXCEPT {
+            extended_group_iterator orig = *this;
+            return ++(*this), orig;
+        }
+
+        [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
+            return std::tuple_cat(
+                std::make_tuple(*it),
+                index_to_element<Owned>(*std::get<storage_type<Owned> *>(pools))...,
+                std::get<storage_type<Get> *>(pools)->get_as_tuple(*it)...);
+        }
+
+        [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
+            return operator*();
+        }
+
+        [[nodiscard]] bool operator==(const extended_group_iterator &other) const ENTT_NOEXCEPT {
+            return other.it == it;
+        }
+
+        [[nodiscard]] bool operator!=(const extended_group_iterator &other) const ENTT_NOEXCEPT {
+            return !(*this == other);
+        }
+
+    private:
+        typename basic_common_type::iterator it;
+        std::tuple<storage_type<Owned> *..., storage_type<Get> *...> pools;
+    };
+
+    basic_group(const std::size_t &extent, storage_type<Owned> &...opool, storage_type<Get> &...gpool) ENTT_NOEXCEPT
+        : pools{&opool..., &gpool...},
+          length{&extent} {}
+
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+    /*! @brief Common type among all storage types. */
+    using base_type = basic_common_type;
+    /*! @brief Random access iterator type. */
+    using iterator = typename base_type::iterator;
+    /*! @brief Reversed iterator type. */
+    using reverse_iterator = typename base_type::reverse_iterator;
+    /*! @brief Iterable group type. */
+    using iterable = iterable_adaptor<extended_group_iterator>;
+
+    /*! @brief Default constructor to use to create empty, invalid groups. */
+    basic_group() ENTT_NOEXCEPT
+        : length{} {}
+
+    /**
+     * @brief Returns the storage for a given component type.
+     * @tparam Comp Type of component of which to return the storage.
+     * @return The storage for the given component type.
+     */
+    template<typename Comp>
+    [[nodiscard]] decltype(auto) storage() const ENTT_NOEXCEPT {
+        return *std::get<storage_type<Comp> *>(pools);
+    }
+
+    /**
+     * @brief Returns the storage for a given component type.
+     * @tparam Comp Index of component of which to return the storage.
+     * @return The storage for the given component type.
+     */
+    template<std::size_t Comp>
+    [[nodiscard]] decltype(auto) storage() const ENTT_NOEXCEPT {
+        return *std::get<Comp>(pools);
+    }
+
+    /**
+     * @brief Returns the number of entities that have the given components.
+     * @return Number of entities that have the given components.
+     */
+    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
+        return *this ? *length : size_type{};
+    }
+
+    /**
+     * @brief Checks whether a group is empty.
+     * @return True if the group is empty, false otherwise.
+     */
+    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
+        return !*this || !*length;
+    }
+
+    /**
+     * @brief Returns an iterator to the first entity of the group.
+     *
+     * The returned iterator points to the first entity of the group. If the
+     * group is empty, the returned iterator will be equal to `end()`.
+     *
+     * @return An iterator to the first entity of the group.
+     */
+    [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
+        return *this ? (std::get<0>(pools)->base_type::end() - *length) : iterator{};
+    }
+
+    /**
+     * @brief Returns an iterator that is past the last entity of the group.
+     *
+     * The returned iterator points to the entity following the last entity of
+     * the group. Attempting to dereference the returned iterator results in
+     * undefined behavior.
+     *
+     * @return An iterator to the entity following the last entity of the
+     * group.
+     */
+    [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
+        return *this ? std::get<0>(pools)->base_type::end() : iterator{};
+    }
+
+    /**
+     * @brief Returns an iterator to the first entity of the reversed group.
+     *
+     * The returned iterator points to the first entity of the reversed group.
+     * If the group is empty, the returned iterator will be equal to `rend()`.
+     *
+     * @return An iterator to the first entity of the reversed group.
+     */
+    [[nodiscard]] reverse_iterator rbegin() const ENTT_NOEXCEPT {
+        return *this ? std::get<0>(pools)->base_type::rbegin() : reverse_iterator{};
+    }
+
+    /**
+     * @brief Returns an iterator that is past the last entity of the reversed
+     * group.
+     *
+     * The returned iterator points to the entity following the last entity of
+     * the reversed group. Attempting to dereference the returned iterator
+     * results in undefined behavior.
+     *
+     * @return An iterator to the entity following the last entity of the
+     * reversed group.
+     */
+    [[nodiscard]] reverse_iterator rend() const ENTT_NOEXCEPT {
+        return *this ? (std::get<0>(pools)->base_type::rbegin() + *length) : reverse_iterator{};
+    }
+
+    /**
+     * @brief Returns the first entity of the group, if any.
+     * @return The first entity of the group if one exists, the null entity
+     * otherwise.
+     */
+    [[nodiscard]] entity_type front() const ENTT_NOEXCEPT {
+        const auto it = begin();
+        return it != end() ? *it : null;
+    }
+
+    /**
+     * @brief Returns the last entity of the group, if any.
+     * @return The last entity of the group if one exists, the null entity
+     * otherwise.
+     */
+    [[nodiscard]] entity_type back() const ENTT_NOEXCEPT {
+        const auto it = rbegin();
+        return it != rend() ? *it : null;
+    }
+
+    /**
+     * @brief Finds an entity.
+     * @param entt A valid identifier.
+     * @return An iterator to the given entity if it's found, past the end
+     * iterator otherwise.
+     */
+    [[nodiscard]] iterator find(const entity_type entt) const ENTT_NOEXCEPT {
+        const auto it = *this ? std::get<0>(pools)->find(entt) : iterator{};
+        return it != end() && it >= begin() && *it == entt ? it : end();
+    }
+
+    /**
+     * @brief Returns the identifier that occupies the given position.
+     * @param pos Position of the element to return.
+     * @return The identifier that occupies the given position.
+     */
+    [[nodiscard]] entity_type operator[](const size_type pos) const {
+        return begin()[pos];
+    }
+
+    /**
+     * @brief Checks if a group is properly initialized.
+     * @return True if the group is properly initialized, false otherwise.
+     */
+    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
+        return length != nullptr;
+    }
+
+    /**
+     * @brief Checks if a group contains an entity.
+     * @param entt A valid identifier.
+     * @return True if the group contains the given entity, false otherwise.
+     */
+    [[nodiscard]] bool contains(const entity_type entt) const ENTT_NOEXCEPT {
+        return *this && std::get<0>(pools)->contains(entt) && (std::get<0>(pools)->index(entt) < (*length));
+    }
+
+    /**
+     * @brief Returns the components assigned to the given entity.
+     *
+     * Prefer this function instead of `registry::get` during iterations. It has
+     * far better performance than its counterpart.
+     *
+     * @warning
+     * Attempting to use an invalid component type results in a compilation
+     * error. Attempting to use an entity that doesn't belong to the group
+     * results in undefined behavior.
+     *
+     * @tparam Comp Types of components to get.
+     * @param entt A valid identifier.
+     * @return The components assigned to the entity.
+     */
+    template<typename... Comp>
+    [[nodiscard]] decltype(auto) get(const entity_type entt) const {
+        ENTT_ASSERT(contains(entt), "Group does not contain entity");
+
+        if constexpr(sizeof...(Comp) == 0) {
+            return std::tuple_cat(std::get<storage_type<Owned> *>(pools)->get_as_tuple(entt)..., std::get<storage_type<Get> *>(pools)->get_as_tuple(entt)...);
+        } else if constexpr(sizeof...(Comp) == 1) {
+            return (std::get<storage_type<Comp> *>(pools)->get(entt), ...);
+        } else {
+            return std::tuple_cat(std::get<storage_type<Comp> *>(pools)->get_as_tuple(entt)...);
+        }
+    }
+
+    /**
+     * @brief Iterates entities and components and applies the given function
+     * object to them.
+     *
+     * The function object is invoked for each entity. It is provided with the
+     * entity itself and a set of references to non-empty components. The
+     * _constness_ of the components is as requested.<br/>
+     * The signature of the function must be equivalent to one of the following
+     * forms:
+     *
+     * @code{.cpp}
+     * void(const entity_type, Type &...);
+     * void(Type &...);
+     * @endcode
+     *
+     * @note
+     * Empty types aren't explicitly instantiated and therefore they are never
+     * returned during iterations.
+     *
+     * @tparam Func Type of the function object to invoke.
+     * @param func A valid function object.
+     */
+    template<typename Func>
+    void each(Func func) const {
+        for(auto args: each()) {
+            if constexpr(is_applicable_v<Func, decltype(std::tuple_cat(std::tuple<entity_type>{}, std::declval<basic_group>().get({})))>) {
+                std::apply(func, args);
+            } else {
+                std::apply([&func](auto, auto &&...less) { func(std::forward<decltype(less)>(less)...); }, args);
+            }
+        }
+    }
+
+    /**
+     * @brief Returns an iterable object to use to _visit_ a group.
+     *
+     * The iterable object returns tuples that contain the current entity and a
+     * set of references to its non-empty components. The _constness_ of the
+     * components is as requested.
+     *
+     * @note
+     * Empty types aren't explicitly instantiated and therefore they are never
+     * returned during iterations.
+     *
+     * @return An iterable object to use to _visit_ the group.
+     */
+    [[nodiscard]] iterable each() const ENTT_NOEXCEPT {
+        iterator last = length ? std::get<0>(pools)->basic_common_type::end() : iterator{};
+        return {extended_group_iterator{last - *length, pools}, extended_group_iterator{last, pools}};
+    }
+
+    /**
+     * @brief Sort a group according to the given comparison function.
+     *
+     * Sort the group so that iterating it with a couple of iterators returns
+     * entities and components in the expected order. See `begin` and `end` for
+     * more details.
+     *
+     * The comparison function object must return `true` if the first element
+     * is _less_ than the second one, `false` otherwise. The signature of the
+     * comparison function should be equivalent to one of the following:
+     *
+     * @code{.cpp}
+     * bool(std::tuple<Component &...>, std::tuple<Component &...>);
+     * bool(const Component &, const Component &);
+     * bool(const Entity, const Entity);
+     * @endcode
+     *
+     * Where `Component` are either owned types or not but still such that they
+     * are iterated by the group.<br/>
+     * Moreover, the comparison function object shall induce a
+     * _strict weak ordering_ on the values.
+     *
+     * The sort function object 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.
+     *
+     * @tparam Comp Optional types of components to compare.
+     * @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 algo A valid sort function object.
+     * @param args Arguments to forward to the sort function object, if any.
+     */
+    template<typename... Comp, typename Compare, typename Sort = std_sort, typename... Args>
+    void sort(Compare compare, Sort algo = Sort{}, Args &&...args) const {
+        auto *cpool = std::get<0>(pools);
+
+        if constexpr(sizeof...(Comp) == 0) {
+            static_assert(std::is_invocable_v<Compare, const entity_type, const entity_type>, "Invalid comparison function");
+            cpool->sort_n(*length, std::move(compare), std::move(algo), std::forward<Args>(args)...);
+        } else {
+            auto comp = [this, &compare](const entity_type lhs, const entity_type rhs) {
+                if constexpr(sizeof...(Comp) == 1) {
+                    return compare((std::get<storage_type<Comp> *>(pools)->get(lhs), ...), (std::get<storage_type<Comp> *>(pools)->get(rhs), ...));
+                } else {
+                    return compare(std::forward_as_tuple(std::get<storage_type<Comp> *>(pools)->get(lhs)...), std::forward_as_tuple(std::get<storage_type<Comp> *>(pools)->get(rhs)...));
+                }
+            };
+
+            cpool->sort_n(*length, std::move(comp), std::move(algo), std::forward<Args>(args)...);
+        }
+
+        [this](auto *head, auto *...other) {
+            for(auto next = *length; next; --next) {
+                const auto pos = next - 1;
+                [[maybe_unused]] const auto entt = head->data()[pos];
+                (other->swap_elements(other->data()[pos], entt), ...);
+            }
+        }(std::get<storage_type<Owned> *>(pools)...);
+    }
+
+private:
+    const std::tuple<storage_type<Owned> *..., storage_type<Get> *...> pools;
+    const size_type *const length;
+};
+
+} // namespace entt
+
+#endif

src/entt/entity/handle.hpp

@@ -0,0 +1,340 @@
+#ifndef ENTT_ENTITY_HANDLE_HPP
+#define ENTT_ENTITY_HANDLE_HPP
+
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+#include "../core/type_traits.hpp"
+#include "fwd.hpp"
+#include "registry.hpp"
+
+namespace entt {
+
+/**
+ * @brief Non-owning handle to an entity.
+ *
+ * Tiny wrapper around a registry and an entity.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Type Types to which to restrict the scope of a handle.
+ */
+template<typename Entity, typename... Type>
+struct basic_handle {
+    /*! @brief Type of registry accepted by the handle. */
+    using registry_type = constness_as_t<basic_registry<std::remove_const_t<Entity>>, Entity>;
+    /*! @brief Underlying entity identifier. */
+    using entity_type = typename registry_type::entity_type;
+    /*! @brief Underlying version type. */
+    using version_type = typename registry_type::version_type;
+    /*! @brief Unsigned integer type. */
+    using size_type = typename registry_type::size_type;
+
+    /*! @brief Constructs an invalid handle. */
+    basic_handle() ENTT_NOEXCEPT
+        : reg{},
+          entt{null} {}
+
+    /**
+     * @brief Constructs a handle from a given registry and entity.
+     * @param ref An instance of the registry class.
+     * @param value A valid identifier.
+     */
+    basic_handle(registry_type &ref, entity_type value) ENTT_NOEXCEPT
+        : reg{&ref},
+          entt{value} {}
+
+    /**
+     * @brief Constructs a const handle from a non-const one.
+     * @tparam Other A valid entity type (see entt_traits for more details).
+     * @tparam Args Scope of the handle to construct.
+     * @return A const handle referring to the same registry and the same
+     * entity.
+     */
+    template<typename Other, typename... Args>
+    operator basic_handle<Other, Args...>() const ENTT_NOEXCEPT {
+        static_assert(std::is_same_v<Other, Entity> || std::is_same_v<std::remove_const_t<Other>, Entity>, "Invalid conversion between different handles");
+        static_assert((sizeof...(Type) == 0 || ((sizeof...(Args) != 0 && sizeof...(Args) <= sizeof...(Type)) && ... && (type_list_contains_v<type_list<Type...>, Args>))), "Invalid conversion between different handles");
+
+        return reg ? basic_handle<Other, Args...>{*reg, entt} : basic_handle<Other, Args...>{};
+    }
+
+    /**
+     * @brief Converts a handle to its underlying entity.
+     * @return The contained identifier.
+     */
+    [[nodiscard]] operator entity_type() const ENTT_NOEXCEPT {
+        return entity();
+    }
+
+    /**
+     * @brief Checks if a handle refers to non-null registry pointer and entity.
+     * @return True if the handle refers to non-null registry and entity, false otherwise.
+     */
+    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
+        return reg && reg->valid(entt);
+    }
+
+    /**
+     * @brief Checks if a handle refers to a valid entity or not.
+     * @return True if the handle refers to a valid entity, false otherwise.
+     */
+    [[nodiscard]] bool valid() const {
+        return reg->valid(entt);
+    }
+
+    /**
+     * @brief Returns a pointer to the underlying registry, if any.
+     * @return A pointer to the underlying registry, if any.
+     */
+    [[nodiscard]] registry_type *registry() const ENTT_NOEXCEPT {
+        return reg;
+    }
+
+    /**
+     * @brief Returns the entity associated with a handle.
+     * @return The entity associated with the handle.
+     */
+    [[nodiscard]] entity_type entity() const ENTT_NOEXCEPT {
+        return entt;
+    }
+
+    /**
+     * @brief Destroys the entity associated with a handle.
+     * @sa basic_registry::destroy
+     */
+    void destroy() {
+        reg->destroy(entt);
+    }
+
+    /**
+     * @brief Destroys the entity associated with a handle.
+     * @sa basic_registry::destroy
+     * @param version A desired version upon destruction.
+     */
+    void destroy(const version_type version) {
+        reg->destroy(entt, version);
+    }
+
+    /**
+     * @brief Assigns the given component to a handle.
+     * @sa basic_registry::emplace
+     * @tparam Component Type of component to create.
+     * @tparam Args Types of arguments to use to construct the component.
+     * @param args Parameters to use to initialize the component.
+     * @return A reference to the newly created component.
+     */
+    template<typename Component, typename... Args>
+    decltype(auto) emplace(Args &&...args) const {
+        static_assert(((sizeof...(Type) == 0) || ... || std::is_same_v<Component, Type>), "Invalid type");
+        return reg->template emplace<Component>(entt, std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Assigns or replaces the given component for a handle.
+     * @sa basic_registry::emplace_or_replace
+     * @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>
+    decltype(auto) emplace_or_replace(Args &&...args) const {
+        static_assert(((sizeof...(Type) == 0) || ... || std::is_same_v<Component, Type>), "Invalid type");
+        return reg->template emplace_or_replace<Component>(entt, std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Patches the given component for a handle.
+     * @sa basic_registry::patch
+     * @tparam Component Type of component to patch.
+     * @tparam Func Types of the function objects to invoke.
+     * @param func Valid function objects.
+     * @return A reference to the patched component.
+     */
+    template<typename Component, typename... Func>
+    decltype(auto) patch(Func &&...func) const {
+        static_assert(((sizeof...(Type) == 0) || ... || std::is_same_v<Component, Type>), "Invalid type");
+        return reg->template patch<Component>(entt, std::forward<Func>(func)...);
+    }
+
+    /**
+     * @brief Replaces the given component for a handle.
+     * @sa basic_registry::replace
+     * @tparam Component Type of component to 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 component being replaced.
+     */
+    template<typename Component, typename... Args>
+    decltype(auto) replace(Args &&...args) const {
+        static_assert(((sizeof...(Type) == 0) || ... || std::is_same_v<Component, Type>), "Invalid type");
+        return reg->template replace<Component>(entt, std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Removes the given components from a handle.
+     * @sa basic_registry::remove
+     * @tparam Component Types of components to remove.
+     * @return The number of components actually removed.
+     */
+    template<typename... Component>
+    size_type remove() const {
+        static_assert(sizeof...(Type) == 0 || (type_list_contains_v<type_list<Type...>, Component> && ...), "Invalid type");
+        return reg->template remove<Component...>(entt);
+    }
+
+    /**
+     * @brief Erases the given components from a handle.
+     * @sa basic_registry::erase
+     * @tparam Component Types of components to erase.
+     */
+    template<typename... Component>
+    void erase() const {
+        static_assert(sizeof...(Type) == 0 || (type_list_contains_v<type_list<Type...>, Component> && ...), "Invalid type");
+        reg->template erase<Component...>(entt);
+    }
+
+    /**
+     * @brief Checks if a handle has all the given components.
+     * @sa basic_registry::all_of
+     * @tparam Component Components for which to perform the check.
+     * @return True if the handle has all the components, false otherwise.
+     */
+    template<typename... Component>
+    [[nodiscard]] decltype(auto) all_of() const {
+        return reg->template all_of<Component...>(entt);
+    }
+
+    /**
+     * @brief Checks if a handle has at least one of the given components.
+     * @sa basic_registry::any_of
+     * @tparam Component Components for which to perform the check.
+     * @return True if the handle has at least one of the given components,
+     * false otherwise.
+     */
+    template<typename... Component>
+    [[nodiscard]] decltype(auto) any_of() const {
+        return reg->template any_of<Component...>(entt);
+    }
+
+    /**
+     * @brief Returns references to the given components for a handle.
+     * @sa basic_registry::get
+     * @tparam Component Types of components to get.
+     * @return References to the components owned by the handle.
+     */
+    template<typename... Component>
+    [[nodiscard]] decltype(auto) get() const {
+        static_assert(sizeof...(Type) == 0 || (type_list_contains_v<type_list<Type...>, Component> && ...), "Invalid type");
+        return reg->template get<Component...>(entt);
+    }
+
+    /**
+     * @brief Returns a reference to the given component for a handle.
+     * @sa basic_registry::get_or_emplace
+     * @tparam Component Type of component to get.
+     * @tparam Args Types of arguments to use to construct the component.
+     * @param args Parameters to use to initialize the component.
+     * @return Reference to the component owned by the handle.
+     */
+    template<typename Component, typename... Args>
+    [[nodiscard]] decltype(auto) get_or_emplace(Args &&...args) const {
+        static_assert(((sizeof...(Type) == 0) || ... || std::is_same_v<Component, Type>), "Invalid type");
+        return reg->template get_or_emplace<Component>(entt, std::forward<Args>(args)...);
+    }
+
+    /**
+     * @brief Returns pointers to the given components for a handle.
+     * @sa basic_registry::try_get
+     * @tparam Component Types of components to get.
+     * @return Pointers to the components owned by the handle.
+     */
+    template<typename... Component>
+    [[nodiscard]] auto try_get() const {
+        static_assert(sizeof...(Type) == 0 || (type_list_contains_v<type_list<Type...>, Component> && ...), "Invalid type");
+        return reg->template try_get<Component...>(entt);
+    }
+
+    /**
+     * @brief Checks if a handle has components assigned.
+     * @return True if the handle has no components assigned, false otherwise.
+     */
+    [[nodiscard]] bool orphan() const {
+        return reg->orphan(entt);
+    }
+
+    /**
+     * @brief Visits a handle and returns the pools for its components.
+     *
+     * The signature of the function should be equivalent to the following:
+     *
+     * @code{.cpp}
+     * void(id_type, const basic_sparse_set<entity_type> &);
+     * @endcode
+     *
+     * Returned pools are those that contain the entity associated with the
+     * handle.
+     *
+     * @tparam Func Type of the function object to invoke.
+     * @param func A valid function object.
+     */
+    template<typename Func>
+    void visit(Func &&func) const {
+        for(auto [id, storage]: reg->storage()) {
+            if(storage.contains(entt)) {
+                func(id, storage);
+            }
+        }
+    }
+
+private:
+    registry_type *reg;
+    entity_type entt;
+};
+
+/**
+ * @brief Compares two handles.
+ * @tparam Args Scope of the first handle.
+ * @tparam Other Scope of the second handle.
+ * @param lhs A valid handle.
+ * @param rhs A valid handle.
+ * @return True if both handles refer to the same registry and the same
+ * entity, false otherwise.
+ */
+template<typename... Args, typename... Other>
+[[nodiscard]] bool operator==(const basic_handle<Args...> &lhs, const basic_handle<Other...> &rhs) ENTT_NOEXCEPT {
+    return lhs.registry() == rhs.registry() && lhs.entity() == rhs.entity();
+}
+
+/**
+ * @brief Compares two handles.
+ * @tparam Args Scope of the first handle.
+ * @tparam Other Scope of the second handle.
+ * @param lhs A valid handle.
+ * @param rhs A valid handle.
+ * @return False if both handles refer to the same registry and the same
+ * entity, true otherwise.
+ */
+template<typename... Args, typename... Other>
+[[nodiscard]] bool operator!=(const basic_handle<Args...> &lhs, const basic_handle<Other...> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+/**
+ * @brief Deduction guide.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+basic_handle(basic_registry<Entity> &, Entity) -> basic_handle<Entity>;
+
+/**
+ * @brief Deduction guide.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+basic_handle(const basic_registry<Entity> &, Entity) -> basic_handle<const Entity>;
+
+} // namespace entt
+
+#endif

src/entt/entity/helper.hpp

@@ -0,0 +1,156 @@
+#ifndef ENTT_ENTITY_HELPER_HPP
+#define ENTT_ENTITY_HELPER_HPP
+
+#include <type_traits>
+#include "../config/config.h"
+#include "../core/fwd.hpp"
+#include "../core/type_traits.hpp"
+#include "../signal/delegate.hpp"
+#include "fwd.hpp"
+#include "registry.hpp"
+
+namespace entt {
+
+/**
+ * @brief Converts a registry to a view.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+struct as_view {
+    /*! @brief Underlying entity identifier. */
+    using entity_type = std::remove_const_t<Entity>;
+    /*! @brief Type of registry to convert. */
+    using registry_type = constness_as_t<basic_registry<entity_type>, Entity>;
+
+    /**
+     * @brief Constructs a converter for a given registry.
+     * @param source A valid reference to a registry.
+     */
+    as_view(registry_type &source) ENTT_NOEXCEPT: reg{source} {}
+
+    /**
+     * @brief Conversion function from a registry to a view.
+     * @tparam Exclude Types of components used to filter the view.
+     * @tparam Component Type of components used to construct the view.
+     * @return A newly created view.
+     */
+    template<typename Exclude, typename... Component>
+    operator basic_view<entity_type, get_t<Component...>, Exclude>() const {
+        return reg.template view<Component...>(Exclude{});
+    }
+
+private:
+    registry_type &reg;
+};
+
+/**
+ * @brief Deduction guide.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+as_view(basic_registry<Entity> &) -> as_view<Entity>;
+
+/**
+ * @brief Deduction guide.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+as_view(const basic_registry<Entity> &) -> as_view<const Entity>;
+
+/**
+ * @brief Converts a registry to a group.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+struct as_group {
+    /*! @brief Underlying entity identifier. */
+    using entity_type = std::remove_const_t<Entity>;
+    /*! @brief Type of registry to convert. */
+    using registry_type = constness_as_t<basic_registry<entity_type>, Entity>;
+
+    /**
+     * @brief Constructs a converter for a given registry.
+     * @param source A valid reference to a registry.
+     */
+    as_group(registry_type &source) ENTT_NOEXCEPT: reg{source} {}
+
+    /**
+     * @brief Conversion function from a registry to a group.
+     * @tparam Get Types of components observed by the group.
+     * @tparam Exclude Types of components used to filter the group.
+     * @tparam Owned Types of components owned by the group.
+     * @return A newly created group.
+     */
+    template<typename Get, typename Exclude, typename... Owned>
+    operator basic_group<entity_type, owned_t<Owned...>, Get, Exclude>() const {
+        if constexpr(std::is_const_v<registry_type>) {
+            return reg.template group_if_exists<Owned...>(Get{}, Exclude{});
+        } else {
+            return reg.template group<Owned...>(Get{}, Exclude{});
+        }
+    }
+
+private:
+    registry_type &reg;
+};
+
+/**
+ * @brief Deduction guide.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+as_group(basic_registry<Entity> &) -> as_group<Entity>;
+
+/**
+ * @brief Deduction guide.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+as_group(const basic_registry<Entity> &) -> as_group<const Entity>;
+
+/**
+ * @brief Helper to create a listener that directly invokes a member function.
+ * @tparam Member Member function to invoke on a component of the given type.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @param reg A registry that contains the given entity and its components.
+ * @param entt Entity from which to get the component.
+ */
+template<auto Member, typename Entity = entity>
+void invoke(basic_registry<Entity> &reg, const Entity entt) {
+    static_assert(std::is_member_function_pointer_v<decltype(Member)>, "Invalid pointer to non-static member function");
+    delegate<void(basic_registry<Entity> &, const Entity)> func;
+    func.template connect<Member>(reg.template get<member_class_t<decltype(Member)>>(entt));
+    func(reg, entt);
+}
+
+/**
+ * @brief Returns the entity associated with a given component.
+ *
+ * @warning
+ * Currently, this function only works correctly with the default pool as it
+ * makes assumptions about how the components are laid out.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Component Type of component.
+ * @param reg A registry that contains the given entity and its components.
+ * @param instance A valid component instance.
+ * @return The entity associated with the given component.
+ */
+template<typename Entity, typename Component>
+Entity to_entity(const basic_registry<Entity> &reg, const Component &instance) {
+    const auto &storage = reg.template storage<Component>();
+    const typename basic_registry<Entity>::base_type &base = storage;
+    const auto *addr = std::addressof(instance);
+
+    for(auto it = base.rbegin(), last = base.rend(); it < last; it += ENTT_PACKED_PAGE) {
+        if(const auto dist = (addr - std::addressof(storage.get(*it))); dist >= 0 && dist < ENTT_PACKED_PAGE) {
+            return *(it + dist);
+        }
+    }
+
+    return null;
+}
+
+} // namespace entt
+
+#endif

src/entt/entity/observer.hpp

@@ -0,0 +1,436 @@
+#ifndef ENTT_ENTITY_OBSERVER_HPP
+#define ENTT_ENTITY_OBSERVER_HPP
+
+#include <cstddef>
+#include <cstdint>
+#include <limits>
+#include <type_traits>
+#include <utility>
+#include "../config/config.h"
+#include "../core/type_traits.hpp"
+#include "../signal/delegate.hpp"
+#include "entity.hpp"
+#include "fwd.hpp"
+#include "registry.hpp"
+#include "storage.hpp"
+#include "utility.hpp"
+
+namespace entt {
+
+/*! @brief Grouping matcher. */
+template<typename...>
+struct matcher {};
+
+/**
+ * @brief Collector.
+ *
+ * Primary template isn't defined on purpose. All the specializations give a
+ * compile-time error, but for a few reasonable cases.
+ */
+template<typename...>
+struct basic_collector;
+
+/**
+ * @brief Collector.
+ *
+ * A collector contains a set of rules (literally, matchers) to use to track
+ * entities.<br/>
+ * Its main purpose is to generate a descriptor that allows an observer to know
+ * how to connect to a registry.
+ */
+template<>
+struct basic_collector<> {
+    /**
+     * @brief Adds a grouping matcher to the collector.
+     * @tparam AllOf Types of components tracked by the matcher.
+     * @tparam NoneOf Types of components used to filter out entities.
+     * @return The updated collector.
+     */
+    template<typename... AllOf, typename... NoneOf>
+    static constexpr auto group(exclude_t<NoneOf...> = {}) ENTT_NOEXCEPT {
+        return basic_collector<matcher<type_list<>, type_list<>, type_list<NoneOf...>, AllOf...>>{};
+    }
+
+    /**
+     * @brief Adds an observing matcher to the collector.
+     * @tparam AnyOf Type of component for which changes should be detected.
+     * @return The updated collector.
+     */
+    template<typename AnyOf>
+    static constexpr auto update() ENTT_NOEXCEPT {
+        return basic_collector<matcher<type_list<>, type_list<>, AnyOf>>{};
+    }
+};
+
+/**
+ * @brief Collector.
+ * @copydetails basic_collector<>
+ * @tparam Reject Untracked types used to filter out entities.
+ * @tparam Require Untracked types required by the matcher.
+ * @tparam Rule Specific details of the current matcher.
+ * @tparam Other Other matchers.
+ */
+template<typename... Reject, typename... Require, typename... Rule, typename... Other>
+struct basic_collector<matcher<type_list<Reject...>, type_list<Require...>, Rule...>, Other...> {
+    /*! @brief Current matcher. */
+    using current_type = matcher<type_list<Reject...>, type_list<Require...>, Rule...>;
+
+    /**
+     * @brief Adds a grouping matcher to the collector.
+     * @tparam AllOf Types of components tracked by the matcher.
+     * @tparam NoneOf Types of components used to filter out entities.
+     * @return The updated collector.
+     */
+    template<typename... AllOf, typename... NoneOf>
+    static constexpr auto group(exclude_t<NoneOf...> = {}) ENTT_NOEXCEPT {
+        return basic_collector<matcher<type_list<>, type_list<>, type_list<NoneOf...>, AllOf...>, current_type, Other...>{};
+    }
+
+    /**
+     * @brief Adds an observing matcher to the collector.
+     * @tparam AnyOf Type of component for which changes should be detected.
+     * @return The updated collector.
+     */
+    template<typename AnyOf>
+    static constexpr auto update() ENTT_NOEXCEPT {
+        return basic_collector<matcher<type_list<>, type_list<>, AnyOf>, current_type, Other...>{};
+    }
+
+    /**
+     * @brief Updates the filter of the last added matcher.
+     * @tparam AllOf Types of components required by the matcher.
+     * @tparam NoneOf Types of components used to filter out entities.
+     * @return The updated collector.
+     */
+    template<typename... AllOf, typename... NoneOf>
+    static constexpr auto where(exclude_t<NoneOf...> = {}) ENTT_NOEXCEPT {
+        using extended_type = matcher<type_list<Reject..., NoneOf...>, type_list<Require..., AllOf...>, Rule...>;
+        return basic_collector<extended_type, Other...>{};
+    }
+};
+
+/*! @brief Variable template used to ease the definition of collectors. */
+inline constexpr basic_collector<> collector{};
+
+/**
+ * @brief Observer.
+ *
+ * An observer returns all the entities and only the entities that fit the
+ * requirements of at least one matcher. Moreover, it's guaranteed that the
+ * entity list is tightly packed in memory for fast iterations.<br/>
+ * In general, observers don't stay true to the order of any set of components.
+ *
+ * Observers work mainly with two types of matchers, provided through a
+ * collector:
+ *
+ * * Observing matcher: an observer will return at least all the living entities
+ *   for which one or more of the given components have been updated and not yet
+ *   destroyed.
+ * * Grouping matcher: an observer will return at least all the living entities
+ *   that would have entered the given group if it existed and that would have
+ *   not yet left it.
+ *
+ * If an entity respects the requirements of multiple matchers, it will be
+ * returned once and only once by the observer in any case.
+ *
+ * Matchers support also filtering by means of a _where_ clause that accepts
+ * both a list of types and an exclusion list.<br/>
+ * Whenever a matcher finds that an entity matches its requirements, the
+ * condition of the filter is verified before to register the entity itself.
+ * Moreover, a registered entity isn't returned by the observer if the condition
+ * set by the filter is broken in the meantime.
+ *
+ * @b Important
+ *
+ * Iterators aren't invalidated if:
+ *
+ * * New instances of the given components are created and assigned to entities.
+ * * The entity currently pointed is modified (as an example, if one of the
+ *   given components is removed from the entity to which the iterator points).
+ * * The entity currently pointed is destroyed.
+ *
+ * In all the other cases, modifying the pools of the given components in any
+ * way invalidates all the iterators and using them results in undefined
+ * behavior.
+ *
+ * @warning
+ * Lifetime of an observer doesn't necessarily have to overcome that of the
+ * registry to which it is connected. However, the observer must be disconnected
+ * from the registry before being destroyed to avoid crashes due to dangling
+ * pointers.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class basic_observer {
+    using payload_type = std::uint32_t;
+
+    template<typename>
+    struct matcher_handler;
+
+    template<typename... Reject, typename... Require, typename AnyOf>
+    struct matcher_handler<matcher<type_list<Reject...>, type_list<Require...>, AnyOf>> {
+        template<std::size_t Index>
+        static void maybe_valid_if(basic_observer &obs, basic_registry<Entity> &reg, const Entity entt) {
+            if(reg.template all_of<Require...>(entt) && !reg.template any_of<Reject...>(entt)) {
+                if(!obs.storage.contains(entt)) {
+                    obs.storage.emplace(entt);
+                }
+
+                obs.storage.get(entt) |= (1 << Index);
+            }
+        }
+
+        template<std::size_t Index>
+        static void discard_if(basic_observer &obs, basic_registry<Entity> &, const Entity entt) {
+            if(obs.storage.contains(entt) && !(obs.storage.get(entt) &= (~(1 << Index)))) {
+                obs.storage.erase(entt);
+            }
+        }
+
+        template<std::size_t Index>
+        static void connect(basic_observer &obs, basic_registry<Entity> &reg) {
+            (reg.template on_destroy<Require>().template connect<&discard_if<Index>>(obs), ...);
+            (reg.template on_construct<Reject>().template connect<&discard_if<Index>>(obs), ...);
+            reg.template on_update<AnyOf>().template connect<&maybe_valid_if<Index>>(obs);
+            reg.template on_destroy<AnyOf>().template connect<&discard_if<Index>>(obs);
+        }
+
+        static void disconnect(basic_observer &obs, basic_registry<Entity> &reg) {
+            (reg.template on_destroy<Require>().disconnect(obs), ...);
+            (reg.template on_construct<Reject>().disconnect(obs), ...);
+            reg.template on_update<AnyOf>().disconnect(obs);
+            reg.template on_destroy<AnyOf>().disconnect(obs);
+        }
+    };
+
+    template<typename... Reject, typename... Require, typename... NoneOf, typename... AllOf>
+    struct matcher_handler<matcher<type_list<Reject...>, type_list<Require...>, type_list<NoneOf...>, AllOf...>> {
+        template<std::size_t Index, typename... Ignore>
+        static void maybe_valid_if(basic_observer &obs, basic_registry<Entity> &reg, const Entity entt) {
+            auto condition = [&reg, entt]() {
+                if constexpr(sizeof...(Ignore) == 0) {
+                    return reg.template all_of<AllOf..., Require...>(entt) && !reg.template any_of<NoneOf..., Reject...>(entt);
+                } else {
+                    return reg.template all_of<AllOf..., Require...>(entt) && ((std::is_same_v<Ignore..., NoneOf> || !reg.template any_of<NoneOf>(entt)) && ...) && !reg.template any_of<Reject...>(entt);
+                }
+            };
+
+            if(condition()) {
+                if(!obs.storage.contains(entt)) {
+                    obs.storage.emplace(entt);
+                }
+
+                obs.storage.get(entt) |= (1 << Index);
+            }
+        }
+
+        template<std::size_t Index>
+        static void discard_if(basic_observer &obs, basic_registry<Entity> &, const Entity entt) {
+            if(obs.storage.contains(entt) && !(obs.storage.get(entt) &= (~(1 << Index)))) {
+                obs.storage.erase(entt);
+            }
+        }
+
+        template<std::size_t Index>
+        static void connect(basic_observer &obs, basic_registry<Entity> &reg) {
+            (reg.template on_destroy<Require>().template connect<&discard_if<Index>>(obs), ...);
+            (reg.template on_construct<Reject>().template connect<&discard_if<Index>>(obs), ...);
+            (reg.template on_construct<AllOf>().template connect<&maybe_valid_if<Index>>(obs), ...);
+            (reg.template on_destroy<NoneOf>().template connect<&maybe_valid_if<Index, NoneOf>>(obs), ...);
+            (reg.template on_destroy<AllOf>().template connect<&discard_if<Index>>(obs), ...);
+            (reg.template on_construct<NoneOf>().template connect<&discard_if<Index>>(obs), ...);
+        }
+
+        static void disconnect(basic_observer &obs, basic_registry<Entity> &reg) {
+            (reg.template on_destroy<Require>().disconnect(obs), ...);
+            (reg.template on_construct<Reject>().disconnect(obs), ...);
+            (reg.template on_construct<AllOf>().disconnect(obs), ...);
+            (reg.template on_destroy<NoneOf>().disconnect(obs), ...);
+            (reg.template on_destroy<AllOf>().disconnect(obs), ...);
+            (reg.template on_construct<NoneOf>().disconnect(obs), ...);
+        }
+    };
+
+    template<typename... Matcher>
+    static void disconnect(basic_registry<Entity> &reg, basic_observer &obs) {
+        (matcher_handler<Matcher>::disconnect(obs, reg), ...);
+    }
+
+    template<typename... Matcher, std::size_t... Index>
+    void connect(basic_registry<Entity> &reg, std::index_sequence<Index...>) {
+        static_assert(sizeof...(Matcher) < std::numeric_limits<payload_type>::digits, "Too many matchers");
+        (matcher_handler<Matcher>::template connect<Index>(*this, reg), ...);
+        release.template connect<&basic_observer::disconnect<Matcher...>>(reg);
+    }
+
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+    /*! @brief Random access iterator type. */
+    using iterator = typename basic_sparse_set<Entity>::iterator;
+
+    /*! @brief Default constructor. */
+    basic_observer()
+        : release{},
+          storage{} {}
+
+    /*! @brief Default copy constructor, deleted on purpose. */
+    basic_observer(const basic_observer &) = delete;
+    /*! @brief Default move constructor, deleted on purpose. */
+    basic_observer(basic_observer &&) = delete;
+
+    /**
+     * @brief Creates an observer and connects it to a given registry.
+     * @tparam Matcher Types of matchers to use to initialize the observer.
+     * @param reg A valid reference to a registry.
+     */
+    template<typename... Matcher>
+    basic_observer(basic_registry<entity_type> &reg, basic_collector<Matcher...>)
+        : basic_observer{} {
+        connect<Matcher...>(reg, std::index_sequence_for<Matcher...>{});
+    }
+
+    /*! @brief Default destructor. */
+    ~basic_observer() = default;
+
+    /**
+     * @brief Default copy assignment operator, deleted on purpose.
+     * @return This observer.
+     */
+    basic_observer &operator=(const basic_observer &) = delete;
+
+    /**
+     * @brief Default move assignment operator, deleted on purpose.
+     * @return This observer.
+     */
+    basic_observer &operator=(basic_observer &&) = delete;
+
+    /**
+     * @brief Connects an observer to a given registry.
+     * @tparam Matcher Types of matchers to use to initialize the observer.
+     * @param reg A valid reference to a registry.
+     */
+    template<typename... Matcher>
+    void connect(basic_registry<entity_type> &reg, basic_collector<Matcher...>) {
+        disconnect();
+        connect<Matcher...>(reg, std::index_sequence_for<Matcher...>{});
+        storage.clear();
+    }
+
+    /*! @brief Disconnects an observer from the registry it keeps track of. */
+    void disconnect() {
+        if(release) {
+            release(*this);
+            release.reset();
+        }
+    }
+
+    /**
+     * @brief Returns the number of elements in an observer.
+     * @return Number of elements.
+     */
+    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
+        return storage.size();
+    }
+
+    /**
+     * @brief Checks whether an observer is empty.
+     * @return True if the observer is empty, false otherwise.
+     */
+    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
+        return storage.empty();
+    }
+
+    /**
+     * @brief Direct access to the list of entities of the observer.
+     *
+     * The returned pointer is such that range `[data(), data() + size())` is
+     * always a valid range, even if the container is empty.
+     *
+     * @note
+     * Entities are in the reverse order as returned by the `begin`/`end`
+     * iterators.
+     *
+     * @return A pointer to the array of entities.
+     */
+    [[nodiscard]] const entity_type *data() const ENTT_NOEXCEPT {
+        return storage.data();
+    }
+
+    /**
+     * @brief Returns an iterator to the first entity of the observer.
+     *
+     * The returned iterator points to the first entity of the observer. If the
+     * container is empty, the returned iterator will be equal to `end()`.
+     *
+     * @return An iterator to the first entity of the observer.
+     */
+    [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
+        return storage.basic_sparse_set<entity_type>::begin();
+    }
+
+    /**
+     * @brief Returns an iterator that is past the last entity of the observer.
+     *
+     * The returned iterator points to the entity following the last entity of
+     * the observer. Attempting to dereference the returned iterator results in
+     * undefined behavior.
+     *
+     * @return An iterator to the entity following the last entity of the
+     * observer.
+     */
+    [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
+        return storage.basic_sparse_set<entity_type>::end();
+    }
+
+    /*! @brief Clears the underlying container. */
+    void clear() ENTT_NOEXCEPT {
+        storage.clear();
+    }
+
+    /**
+     * @brief Iterates entities and applies the given function object to them.
+     *
+     * The function object is invoked for each entity.<br/>
+     * The signature of the function must be equivalent to the following form:
+     *
+     * @code{.cpp}
+     * void(const entity_type);
+     * @endcode
+     *
+     * @tparam Func Type of the function object to invoke.
+     * @param func A valid function object.
+     */
+    template<typename Func>
+    void each(Func func) const {
+        for(const auto entity: *this) {
+            func(entity);
+        }
+    }
+
+    /**
+     * @brief Iterates entities and applies the given function object to them,
+     * then clears the observer.
+     *
+     * @sa each
+     *
+     * @tparam Func Type of the function object to invoke.
+     * @param func A valid function object.
+     */
+    template<typename Func>
+    void each(Func func) {
+        std::as_const(*this).each(std::move(func));
+        clear();
+    }
+
+private:
+    delegate<void(basic_observer &)> release;
+    basic_storage<entity_type, payload_type> storage;
+};
+
+} // namespace entt
+
+#endif

src/entt/entity/organizer.hpp

@@ -0,0 +1,484 @@
+#ifndef ENTT_ENTITY_ORGANIZER_HPP
+#define ENTT_ENTITY_ORGANIZER_HPP
+
+#include <algorithm>
+#include <cstddef>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "../container/dense_map.hpp"
+#include "../core/type_info.hpp"
+#include "../core/type_traits.hpp"
+#include "../core/utility.hpp"
+#include "fwd.hpp"
+#include "helper.hpp"
+
+namespace entt {
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename>
+struct is_view: std::false_type {};
+
+template<typename Entity, typename... Component, typename... Exclude>
+struct is_view<basic_view<Entity, get_t<Component...>, exclude_t<Exclude...>>>: std::true_type {};
+
+template<typename Type>
+inline constexpr bool is_view_v = is_view<Type>::value;
+
+template<typename Type, typename Override>
+struct unpack_type {
+    using ro = std::conditional_t<
+        type_list_contains_v<Override, std::add_const_t<Type>> || (std::is_const_v<Type> && !type_list_contains_v<Override, std::remove_const_t<Type>>),
+        type_list<std::remove_const_t<Type>>,
+        type_list<>>;
+
+    using rw = std::conditional_t<
+        type_list_contains_v<Override, std::remove_const_t<Type>> || (!std::is_const_v<Type> && !type_list_contains_v<Override, std::add_const_t<Type>>),
+        type_list<Type>,
+        type_list<>>;
+};
+
+template<typename Entity, typename... Override>
+struct unpack_type<basic_registry<Entity>, type_list<Override...>> {
+    using ro = type_list<>;
+    using rw = type_list<>;
+};
+
+template<typename Entity, typename... Override>
+struct unpack_type<const basic_registry<Entity>, type_list<Override...>>
+    : unpack_type<basic_registry<Entity>, type_list<Override...>> {};
+
+template<typename Entity, typename... Component, typename... Exclude, typename... Override>
+struct unpack_type<basic_view<Entity, get_t<Component...>, exclude_t<Exclude...>>, type_list<Override...>> {
+    using ro = type_list_cat_t<type_list<Exclude...>, typename unpack_type<Component, type_list<Override...>>::ro...>;
+    using rw = type_list_cat_t<typename unpack_type<Component, type_list<Override...>>::rw...>;
+};
+
+template<typename Entity, typename... Component, typename... Exclude, typename... Override>
+struct unpack_type<const basic_view<Entity, get_t<Component...>, exclude_t<Exclude...>>, type_list<Override...>>
+    : unpack_type<basic_view<Entity, get_t<Component...>, exclude_t<Exclude...>>, type_list<Override...>> {};
+
+template<typename, typename>
+struct resource_traits;
+
+template<typename... Args, typename... Req>
+struct resource_traits<type_list<Args...>, type_list<Req...>> {
+    using args = type_list<std::remove_const_t<Args>...>;
+    using ro = type_list_cat_t<typename unpack_type<Args, type_list<Req...>>::ro..., typename unpack_type<Req, type_list<>>::ro...>;
+    using rw = type_list_cat_t<typename unpack_type<Args, type_list<Req...>>::rw..., typename unpack_type<Req, type_list<>>::rw...>;
+};
+
+template<typename... Req, typename Ret, typename... Args>
+resource_traits<type_list<std::remove_reference_t<Args>...>, type_list<Req...>> free_function_to_resource_traits(Ret (*)(Args...));
+
+template<typename... Req, typename Ret, typename Type, typename... Args>
+resource_traits<type_list<std::remove_reference_t<Args>...>, type_list<Req...>> constrained_function_to_resource_traits(Ret (*)(Type &, Args...));
+
+template<typename... Req, typename Ret, typename Class, typename... Args>
+resource_traits<type_list<std::remove_reference_t<Args>...>, type_list<Req...>> constrained_function_to_resource_traits(Ret (Class::*)(Args...));
+
+template<typename... Req, typename Ret, typename Class, typename... Args>
+resource_traits<type_list<std::remove_reference_t<Args>...>, type_list<Req...>> constrained_function_to_resource_traits(Ret (Class::*)(Args...) const);
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Utility class for creating a static task graph.
+ *
+ * This class offers minimal support (but sufficient in many cases) for creating
+ * an execution graph from functions and their requirements on resources.<br/>
+ * Note that the resulting tasks aren't executed in any case. This isn't the
+ * goal of the tool. Instead, they are returned to the user in the form of a
+ * graph that allows for safe execution.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class basic_organizer final {
+    using callback_type = void(const void *, basic_registry<Entity> &);
+    using prepare_type = void(basic_registry<Entity> &);
+    using dependency_type = std::size_t(const bool, const type_info **, const std::size_t);
+
+    struct vertex_data final {
+        std::size_t ro_count{};
+        std::size_t rw_count{};
+        const char *name{};
+        const void *payload{};
+        callback_type *callback{};
+        dependency_type *dependency;
+        prepare_type *prepare{};
+        const type_info *info{};
+    };
+
+    template<typename Type>
+    [[nodiscard]] static decltype(auto) extract(basic_registry<Entity> &reg) {
+        if constexpr(std::is_same_v<Type, basic_registry<Entity>>) {
+            return reg;
+        } else if constexpr(internal::is_view_v<Type>) {
+            return as_view{reg};
+        } else {
+            return reg.ctx().template emplace<std::remove_reference_t<Type>>();
+        }
+    }
+
+    template<typename... Args>
+    [[nodiscard]] static auto to_args(basic_registry<Entity> &reg, type_list<Args...>) {
+        return std::tuple<decltype(extract<Args>(reg))...>(extract<Args>(reg)...);
+    }
+
+    template<typename... Type>
+    static std::size_t fill_dependencies(type_list<Type...>, [[maybe_unused]] const type_info **buffer, [[maybe_unused]] const std::size_t count) {
+        if constexpr(sizeof...(Type) == 0u) {
+            return {};
+        } else {
+            const type_info *info[sizeof...(Type)]{&type_id<Type>()...};
+            const auto length = (std::min)(count, sizeof...(Type));
+            std::copy_n(info, length, buffer);
+            return length;
+        }
+    }
+
+    template<typename... RO, typename... RW>
+    void track_dependencies(std::size_t index, const bool requires_registry, type_list<RO...>, type_list<RW...>) {
+        dependencies[type_hash<basic_registry<Entity>>::value()].emplace_back(index, requires_registry || (sizeof...(RO) + sizeof...(RW) == 0u));
+        (dependencies[type_hash<RO>::value()].emplace_back(index, false), ...);
+        (dependencies[type_hash<RW>::value()].emplace_back(index, true), ...);
+    }
+
+    [[nodiscard]] std::vector<bool> adjacency_matrix() {
+        const auto length = vertices.size();
+        std::vector<bool> edges(length * length, false);
+
+        // creates the adjacency matrix
+        for(const auto &deps: dependencies) {
+            const auto last = deps.second.cend();
+            auto it = deps.second.cbegin();
+
+            while(it != last) {
+                if(it->second) {
+                    // rw item
+                    if(auto curr = it++; it != last) {
+                        if(it->second) {
+                            edges[curr->first * length + it->first] = true;
+                        } else {
+                            if(const auto next = std::find_if(it, last, [](const auto &elem) { return elem.second; }); next != last) {
+                                for(; it != next; ++it) {
+                                    edges[curr->first * length + it->first] = true;
+                                    edges[it->first * length + next->first] = true;
+                                }
+                            } else {
+                                for(; it != next; ++it) {
+                                    edges[curr->first * length + it->first] = true;
+                                }
+                            }
+                        }
+                    }
+                } else {
+                    // ro item, possibly only on first iteration
+                    if(const auto next = std::find_if(it, last, [](const auto &elem) { return elem.second; }); next != last) {
+                        for(; it != next; ++it) {
+                            edges[it->first * length + next->first] = true;
+                        }
+                    } else {
+                        it = last;
+                    }
+                }
+            }
+        }
+
+        // computes the transitive closure
+        for(std::size_t vk{}; vk < length; ++vk) {
+            for(std::size_t vi{}; vi < length; ++vi) {
+                for(std::size_t vj{}; vj < length; ++vj) {
+                    edges[vi * length + vj] = edges[vi * length + vj] || (edges[vi * length + vk] && edges[vk * length + vj]);
+                }
+            }
+        }
+
+        // applies the transitive reduction
+        for(std::size_t vert{}; vert < length; ++vert) {
+            edges[vert * length + vert] = false;
+        }
+
+        for(std::size_t vj{}; vj < length; ++vj) {
+            for(std::size_t vi{}; vi < length; ++vi) {
+                if(edges[vi * length + vj]) {
+                    for(std::size_t vk{}; vk < length; ++vk) {
+                        if(edges[vj * length + vk]) {
+                            edges[vi * length + vk] = false;
+                        }
+                    }
+                }
+            }
+        }
+
+        return edges;
+    }
+
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+    /*! @brief Raw task function type. */
+    using function_type = callback_type;
+
+    /*! @brief Vertex type of a task graph defined as an adjacency list. */
+    struct vertex {
+        /**
+         * @brief Constructs a vertex of the task graph.
+         * @param vtype True if the vertex is a top-level one, false otherwise.
+         * @param data The data associated with the vertex.
+         * @param edges The indices of the children in the adjacency list.
+         */
+        vertex(const bool vtype, vertex_data data, std::vector<std::size_t> edges)
+            : is_top_level{vtype},
+              node{std::move(data)},
+              reachable{std::move(edges)} {}
+
+        /**
+         * @brief Fills a buffer with the type info objects for the writable
+         * resources of a vertex.
+         * @param buffer A buffer pre-allocated by the user.
+         * @param length The length of the user-supplied buffer.
+         * @return The number of type info objects written to the buffer.
+         */
+        size_type ro_dependency(const type_info **buffer, const std::size_t length) const ENTT_NOEXCEPT {
+            return node.dependency(false, buffer, length);
+        }
+
+        /**
+         * @brief Fills a buffer with the type info objects for the read-only
+         * resources of a vertex.
+         * @param buffer A buffer pre-allocated by the user.
+         * @param length The length of the user-supplied buffer.
+         * @return The number of type info objects written to the buffer.
+         */
+        size_type rw_dependency(const type_info **buffer, const std::size_t length) const ENTT_NOEXCEPT {
+            return node.dependency(true, buffer, length);
+        }
+
+        /**
+         * @brief Returns the number of read-only resources of a vertex.
+         * @return The number of read-only resources of the vertex.
+         */
+        size_type ro_count() const ENTT_NOEXCEPT {
+            return node.ro_count;
+        }
+
+        /**
+         * @brief Returns the number of writable resources of a vertex.
+         * @return The number of writable resources of the vertex.
+         */
+        size_type rw_count() const ENTT_NOEXCEPT {
+            return node.rw_count;
+        }
+
+        /**
+         * @brief Checks if a vertex is also a top-level one.
+         * @return True if the vertex is a top-level one, false otherwise.
+         */
+        bool top_level() const ENTT_NOEXCEPT {
+            return is_top_level;
+        }
+
+        /**
+         * @brief Returns a type info object associated with a vertex.
+         * @return A properly initialized type info object.
+         */
+        const type_info &info() const ENTT_NOEXCEPT {
+            return *node.info;
+        }
+
+        /**
+         * @brief Returns a user defined name associated with a vertex, if any.
+         * @return The user defined name associated with the vertex, if any.
+         */
+        const char *name() const ENTT_NOEXCEPT {
+            return node.name;
+        }
+
+        /**
+         * @brief Returns the function associated with a vertex.
+         * @return The function associated with the vertex.
+         */
+        function_type *callback() const ENTT_NOEXCEPT {
+            return node.callback;
+        }
+
+        /**
+         * @brief Returns the payload associated with a vertex, if any.
+         * @return The payload associated with the vertex, if any.
+         */
+        const void *data() const ENTT_NOEXCEPT {
+            return node.payload;
+        }
+
+        /**
+         * @brief Returns the list of nodes reachable from a given vertex.
+         * @return The list of nodes reachable from the vertex.
+         */
+        const std::vector<std::size_t> &children() const ENTT_NOEXCEPT {
+            return reachable;
+        }
+
+        /**
+         * @brief Prepares a registry and assures that all required resources
+         * are properly instantiated before using them.
+         * @param reg A valid registry.
+         */
+        void prepare(basic_registry<entity_type> &reg) const {
+            node.prepare ? node.prepare(reg) : void();
+        }
+
+    private:
+        bool is_top_level;
+        vertex_data node;
+        std::vector<std::size_t> reachable;
+    };
+
+    /**
+     * @brief Adds a free function to the task list.
+     * @tparam Candidate Function to add to the task list.
+     * @tparam Req Additional requirements and/or override resource access mode.
+     * @param name Optional name to associate with the task.
+     */
+    template<auto Candidate, typename... Req>
+    void emplace(const char *name = nullptr) {
+        using resource_type = decltype(internal::free_function_to_resource_traits<Req...>(Candidate));
+        constexpr auto requires_registry = type_list_contains_v<typename resource_type::args, basic_registry<entity_type>>;
+
+        callback_type *callback = +[](const void *, basic_registry<entity_type> &reg) {
+            std::apply(Candidate, to_args(reg, typename resource_type::args{}));
+        };
+
+        vertex_data vdata{
+            resource_type::ro::size,
+            resource_type::rw::size,
+            name,
+            nullptr,
+            callback,
+            +[](const bool rw, const type_info **buffer, const std::size_t length) { return rw ? fill_dependencies(typename resource_type::rw{}, buffer, length) : fill_dependencies(typename resource_type::ro{}, buffer, length); },
+            +[](basic_registry<entity_type> &reg) { void(to_args(reg, typename resource_type::args{})); },
+            &type_id<std::integral_constant<decltype(Candidate), Candidate>>()};
+
+        track_dependencies(vertices.size(), requires_registry, typename resource_type::ro{}, typename resource_type::rw{});
+        vertices.push_back(std::move(vdata));
+    }
+
+    /**
+     * @brief Adds a free function with payload or a member function with an
+     * instance to the task list.
+     * @tparam Candidate Function or member to add to the task list.
+     * @tparam Req Additional requirements and/or override resource access mode.
+     * @tparam Type Type of class or type of payload.
+     * @param value_or_instance A valid object that fits the purpose.
+     * @param name Optional name to associate with the task.
+     */
+    template<auto Candidate, typename... Req, typename Type>
+    void emplace(Type &value_or_instance, const char *name = nullptr) {
+        using resource_type = decltype(internal::constrained_function_to_resource_traits<Req...>(Candidate));
+        constexpr auto requires_registry = type_list_contains_v<typename resource_type::args, basic_registry<entity_type>>;
+
+        callback_type *callback = +[](const void *payload, basic_registry<entity_type> &reg) {
+            Type *curr = static_cast<Type *>(const_cast<constness_as_t<void, Type> *>(payload));
+            std::apply(Candidate, std::tuple_cat(std::forward_as_tuple(*curr), to_args(reg, typename resource_type::args{})));
+        };
+
+        vertex_data vdata{
+            resource_type::ro::size,
+            resource_type::rw::size,
+            name,
+            &value_or_instance,
+            callback,
+            +[](const bool rw, const type_info **buffer, const std::size_t length) { return rw ? fill_dependencies(typename resource_type::rw{}, buffer, length) : fill_dependencies(typename resource_type::ro{}, buffer, length); },
+            +[](basic_registry<entity_type> &reg) { void(to_args(reg, typename resource_type::args{})); },
+            &type_id<std::integral_constant<decltype(Candidate), Candidate>>()};
+
+        track_dependencies(vertices.size(), requires_registry, typename resource_type::ro{}, typename resource_type::rw{});
+        vertices.push_back(std::move(vdata));
+    }
+
+    /**
+     * @brief Adds an user defined function with optional payload to the task
+     * list.
+     * @tparam Req Additional requirements and/or override resource access mode.
+     * @param func Function to add to the task list.
+     * @param payload User defined arbitrary data.
+     * @param name Optional name to associate with the task.
+     */
+    template<typename... Req>
+    void emplace(function_type *func, const void *payload = nullptr, const char *name = nullptr) {
+        using resource_type = internal::resource_traits<type_list<>, type_list<Req...>>;
+        track_dependencies(vertices.size(), true, typename resource_type::ro{}, typename resource_type::rw{});
+
+        vertex_data vdata{
+            resource_type::ro::size,
+            resource_type::rw::size,
+            name,
+            payload,
+            func,
+            +[](const bool rw, const type_info **buffer, const std::size_t length) { return rw ? fill_dependencies(typename resource_type::rw{}, buffer, length) : fill_dependencies(typename resource_type::ro{}, buffer, length); },
+            nullptr,
+            &type_id<void>()};
+
+        vertices.push_back(std::move(vdata));
+    }
+
+    /**
+     * @brief Generates a task graph for the current content.
+     * @return The adjacency list of the task graph.
+     */
+    std::vector<vertex> graph() {
+        const auto edges = adjacency_matrix();
+
+        // creates the adjacency list
+        std::vector<vertex> adjacency_list{};
+        adjacency_list.reserve(vertices.size());
+
+        for(std::size_t col{}, length = vertices.size(); col < length; ++col) {
+            std::vector<std::size_t> reachable{};
+            const auto row = col * length;
+            bool is_top_level = true;
+
+            for(std::size_t next{}; next < length; ++next) {
+                if(edges[row + next]) {
+                    reachable.push_back(next);
+                }
+            }
+
+            for(std::size_t next{}; next < length && is_top_level; ++next) {
+                is_top_level = !edges[next * length + col];
+            }
+
+            adjacency_list.emplace_back(is_top_level, vertices[col], std::move(reachable));
+        }
+
+        return adjacency_list;
+    }
+
+    /*! @brief Erases all elements from a container. */
+    void clear() {
+        dependencies.clear();
+        vertices.clear();
+    }
+
+private:
+    dense_map<id_type, std::vector<std::pair<std::size_t, bool>>, identity> dependencies;
+    std::vector<vertex_data> vertices;
+};
+
+} // namespace entt
+
+#endif

src/entt/entity/runtime_view.hpp

@@ -0,0 +1,272 @@
+#ifndef ENTT_ENTITY_RUNTIME_VIEW_HPP
+#define ENTT_ENTITY_RUNTIME_VIEW_HPP
+
+#include <algorithm>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "../config/config.h"
+#include "entity.hpp"
+#include "fwd.hpp"
+#include "sparse_set.hpp"
+
+namespace entt {
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename Set>
+class runtime_view_iterator final {
+    using iterator_type = typename Set::iterator;
+
+    [[nodiscard]] bool valid() const {
+        return (!tombstone_check || *it != tombstone)
+               && std::all_of(++pools->begin(), pools->end(), [entt = *it](const auto *curr) { return curr->contains(entt); })
+               && std::none_of(filter->cbegin(), filter->cend(), [entt = *it](const auto *curr) { return curr && curr->contains(entt); });
+    }
+
+public:
+    using difference_type = typename iterator_type::difference_type;
+    using value_type = typename iterator_type::value_type;
+    using pointer = typename iterator_type::pointer;
+    using reference = typename iterator_type::reference;
+    using iterator_category = std::bidirectional_iterator_tag;
+
+    runtime_view_iterator() ENTT_NOEXCEPT
+        : pools{},
+          filter{},
+          it{},
+          tombstone_check{} {}
+
+    runtime_view_iterator(const std::vector<const Set *> &cpools, const std::vector<const Set *> &ignore, iterator_type curr) ENTT_NOEXCEPT
+        : pools{&cpools},
+          filter{&ignore},
+          it{curr},
+          tombstone_check{pools->size() == 1u && (*pools)[0u]->policy() == deletion_policy::in_place} {
+        if(it != (*pools)[0]->end() && !valid()) {
+            ++(*this);
+        }
+    }
+
+    runtime_view_iterator &operator++() {
+        while(++it != (*pools)[0]->end() && !valid()) {}
+        return *this;
+    }
+
+    runtime_view_iterator operator++(int) {
+        runtime_view_iterator orig = *this;
+        return ++(*this), orig;
+    }
+
+    runtime_view_iterator &operator--() {
+        while(--it != (*pools)[0]->begin() && !valid()) {}
+        return *this;
+    }
+
+    runtime_view_iterator operator--(int) {
+        runtime_view_iterator orig = *this;
+        return operator--(), orig;
+    }
+
+    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
+        return it.operator->();
+    }
+
+    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
+        return *operator->();
+    }
+
+    [[nodiscard]] bool operator==(const runtime_view_iterator &other) const ENTT_NOEXCEPT {
+        return it == other.it;
+    }
+
+    [[nodiscard]] bool operator!=(const runtime_view_iterator &other) const ENTT_NOEXCEPT {
+        return !(*this == other);
+    }
+
+private:
+    const std::vector<const Set *> *pools;
+    const std::vector<const Set *> *filter;
+    iterator_type it;
+    bool tombstone_check;
+};
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Runtime view implementation.
+ *
+ * Primary template isn't defined on purpose. All the specializations give a
+ * compile-time error, but for a few reasonable cases.
+ */
+template<typename>
+struct basic_runtime_view;
+
+/**
+ * @brief Generic runtime view.
+ *
+ * Runtime views iterate over those entities that have at least all the given
+ * components in their bags. During initialization, a runtime view looks at the
+ * number of entities available for each component and picks up a reference to
+ * the smallest set of candidate entities in order to get a performance boost
+ * when iterate.<br/>
+ * Order of elements during iterations are highly dependent on the order of the
+ * underlying data structures. See sparse_set and its specializations for more
+ * details.
+ *
+ * @b Important
+ *
+ * Iterators aren't invalidated if:
+ *
+ * * New instances of the given components are created and assigned to entities.
+ * * The entity currently pointed is modified (as an example, if one of the
+ *   given components is removed from the entity to which the iterator points).
+ * * The entity currently pointed is destroyed.
+ *
+ * In all the other cases, modifying the pools of the given components in any
+ * way invalidates all the iterators and using them results in undefined
+ * behavior.
+ *
+ * @note
+ * Views share references to the underlying data structures of the registry that
+ * generated them. Therefore any change to the entities and to the components
+ * made by means of the registry are immediately reflected by the views, unless
+ * a pool was missing when the view was built (in this case, the view won't
+ * have a valid reference and won't be updated accordingly).
+ *
+ * @warning
+ * Lifetime of a view must not overcome that of the registry that generated it.
+ * In any other case, attempting to use a view results in undefined behavior.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Allocator Type of allocator used to manage memory and elements.
+ */
+template<typename Entity, typename Allocator>
+struct basic_runtime_view<basic_sparse_set<Entity, Allocator>> {
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+    /*! @brief Common type among all storage types. */
+    using base_type = basic_sparse_set<Entity, Allocator>;
+    /*! @brief Bidirectional iterator type. */
+    using iterator = internal::runtime_view_iterator<base_type>;
+
+    /*! @brief Default constructor to use to create empty, invalid views. */
+    basic_runtime_view() ENTT_NOEXCEPT
+        : pools{},
+          filter{} {}
+
+    /**
+     * @brief Appends an opaque storage object to a runtime view.
+     * @param base An opaque reference to a storage object.
+     * @return This runtime view.
+     */
+    basic_runtime_view &iterate(const base_type &base) {
+        if(pools.empty() || !(base.size() < pools[0u]->size())) {
+            pools.push_back(&base);
+        } else {
+            pools.push_back(std::exchange(pools[0u], &base));
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Adds an opaque storage object as a filter of a runtime view.
+     * @param base An opaque reference to a storage object.
+     * @return This runtime view.
+     */
+    basic_runtime_view &exclude(const base_type &base) {
+        filter.push_back(&base);
+        return *this;
+    }
+
+    /**
+     * @brief Estimates the number of entities iterated by the view.
+     * @return Estimated number of entities iterated by the view.
+     */
+    [[nodiscard]] size_type size_hint() const {
+        return pools.empty() ? size_type{} : pools.front()->size();
+    }
+
+    /**
+     * @brief Returns an iterator to the first entity that has the given
+     * components.
+     *
+     * The returned iterator points to the first entity that has the given
+     * components. If the view is empty, the returned iterator will be equal to
+     * `end()`.
+     *
+     * @return An iterator to the first entity that has the given components.
+     */
+    [[nodiscard]] iterator begin() const {
+        return pools.empty() ? iterator{} : iterator{pools, filter, pools[0]->begin()};
+    }
+
+    /**
+     * @brief Returns an iterator that is past the last entity that has the
+     * given components.
+     *
+     * The returned iterator points to the entity following the last entity that
+     * has the given components. Attempting to dereference the returned iterator
+     * results in undefined behavior.
+     *
+     * @return An iterator to the entity following the last entity that has the
+     * given components.
+     */
+    [[nodiscard]] iterator end() const {
+        return pools.empty() ? iterator{} : iterator{pools, filter, pools[0]->end()};
+    }
+
+    /**
+     * @brief Checks if a view contains an entity.
+     * @param entt A valid identifier.
+     * @return True if the view contains the given entity, false otherwise.
+     */
+    [[nodiscard]] bool contains(const entity_type entt) const {
+        return !pools.empty()
+               && std::all_of(pools.cbegin(), pools.cend(), [entt](const auto *curr) { return curr->contains(entt); })
+               && std::none_of(filter.cbegin(), filter.cend(), [entt](const auto *curr) { return curr && curr->contains(entt); });
+    }
+
+    /**
+     * @brief Iterates entities and applies the given function object to them.
+     *
+     * The function object is invoked for each entity. It is provided only with
+     * the entity itself. To get the components, users can use the registry with
+     * which the view was built.<br/>
+     * The signature of the function should be equivalent to the following:
+     *
+     * @code{.cpp}
+     * void(const entity_type);
+     * @endcode
+     *
+     * @tparam Func Type of the function object to invoke.
+     * @param func A valid function object.
+     */
+    template<typename Func>
+    void each(Func func) const {
+        for(const auto entity: *this) {
+            func(entity);
+        }
+    }
+
+private:
+    std::vector<const base_type *> pools;
+    std::vector<const base_type *> filter;
+};
+
+} // namespace entt
+
+#endif

src/entt/entity/sigh_storage_mixin.hpp

@@ -0,0 +1,177 @@
+#ifndef ENTT_ENTITY_SIGH_STORAGE_MIXIN_HPP
+#define ENTT_ENTITY_SIGH_STORAGE_MIXIN_HPP
+
+#include <utility>
+#include "../config/config.h"
+#include "../core/any.hpp"
+#include "../signal/sigh.hpp"
+#include "fwd.hpp"
+
+namespace entt {
+
+/**
+ * @brief Mixin type used to add signal support to storage types.
+ *
+ * The function type of a listener is equivalent to:
+ *
+ * @code{.cpp}
+ * void(basic_registry<entity_type> &, entity_type);
+ * @endcode
+ *
+ * This applies to all signals made available.
+ *
+ * @tparam Type The type of the underlying storage.
+ */
+template<typename Type>
+class sigh_storage_mixin final: public Type {
+    using basic_iterator = typename Type::basic_iterator;
+
+    template<typename Func>
+    void notify_destruction(basic_iterator first, basic_iterator last, Func func) {
+        ENTT_ASSERT(owner != nullptr, "Invalid pointer to registry");
+
+        for(; first != last; ++first) {
+            const auto entt = *first;
+            destruction.publish(*owner, entt);
+            const auto it = Type::find(entt);
+            func(it, it + 1u);
+        }
+    }
+
+    void swap_and_pop(basic_iterator first, basic_iterator last) final {
+        notify_destruction(std::move(first), std::move(last), [this](auto... args) { Type::swap_and_pop(args...); });
+    }
+
+    void in_place_pop(basic_iterator first, basic_iterator last) final {
+        notify_destruction(std::move(first), std::move(last), [this](auto... args) { Type::in_place_pop(args...); });
+    }
+
+    basic_iterator try_emplace(const typename Type::entity_type entt, const bool force_back, const void *value) final {
+        ENTT_ASSERT(owner != nullptr, "Invalid pointer to registry");
+        Type::try_emplace(entt, force_back, value);
+        construction.publish(*owner, entt);
+        return Type::find(entt);
+    }
+
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = typename Type::entity_type;
+
+    /*! @brief Inherited constructors. */
+    using Type::Type;
+
+    /**
+     * @brief Returns a sink object.
+     *
+     * The sink returned by this function can be used to receive notifications
+     * whenever a new instance is created and assigned to an entity.<br/>
+     * Listeners are invoked after the object has been assigned to the entity.
+     *
+     * @sa sink
+     *
+     * @return A temporary sink object.
+     */
+    [[nodiscard]] auto on_construct() ENTT_NOEXCEPT {
+        return sink{construction};
+    }
+
+    /**
+     * @brief Returns a sink object.
+     *
+     * The sink returned by this function can be used to receive notifications
+     * whenever an instance is explicitly updated.<br/>
+     * Listeners are invoked after the object has been updated.
+     *
+     * @sa sink
+     *
+     * @return A temporary sink object.
+     */
+    [[nodiscard]] auto on_update() ENTT_NOEXCEPT {
+        return sink{update};
+    }
+
+    /**
+     * @brief Returns a sink object.
+     *
+     * The sink returned by this function can be used to receive notifications
+     * whenever an instance is removed from an entity and thus destroyed.<br/>
+     * Listeners are invoked before the object has been removed from the entity.
+     *
+     * @sa sink
+     *
+     * @return A temporary sink object.
+     */
+    [[nodiscard]] auto on_destroy() ENTT_NOEXCEPT {
+        return sink{destruction};
+    }
+
+    /**
+     * @brief Assigns entities to a storage.
+     * @tparam Args Types of arguments to use to construct the object.
+     * @param entt A valid identifier.
+     * @param args Parameters to use to initialize the object.
+     * @return A reference to the newly created object.
+     */
+    template<typename... Args>
+    decltype(auto) emplace(const entity_type entt, Args &&...args) {
+        ENTT_ASSERT(owner != nullptr, "Invalid pointer to registry");
+        Type::emplace(entt, std::forward<Args>(args)...);
+        construction.publish(*owner, entt);
+        return this->get(entt);
+    }
+
+    /**
+     * @brief Patches the given instance for an entity.
+     * @tparam Func Types of the function objects to invoke.
+     * @param entt A valid identifier.
+     * @param func Valid function objects.
+     * @return A reference to the patched instance.
+     */
+    template<typename... Func>
+    decltype(auto) patch(const entity_type entt, Func &&...func) {
+        ENTT_ASSERT(owner != nullptr, "Invalid pointer to registry");
+        Type::patch(entt, std::forward<Func>(func)...);
+        update.publish(*owner, entt);
+        return this->get(entt);
+    }
+
+    /**
+     * @brief Assigns entities to a storage.
+     * @tparam It Type of input iterator.
+     * @tparam Args Types of arguments to use to construct the objects assigned
+     * to the entities.
+     * @param first An iterator to the first element of the range of entities.
+     * @param last An iterator past the last element of the range of entities.
+     * @param args Parameters to use to initialize the objects assigned to the
+     * entities.
+     */
+    template<typename It, typename... Args>
+    void insert(It first, It last, Args &&...args) {
+        ENTT_ASSERT(owner != nullptr, "Invalid pointer to registry");
+        Type::insert(first, last, std::forward<Args>(args)...);
+
+        for(auto it = construction.empty() ? last : first; it != last; ++it) {
+            construction.publish(*owner, *it);
+        }
+    }
+
+    /**
+     * @brief Forwards variables to mixins, if any.
+     * @param value A variable wrapped in an opaque container.
+     */
+    void bind(any value) ENTT_NOEXCEPT final {
+        auto *reg = any_cast<basic_registry<entity_type>>(&value);
+        owner = reg ? reg : owner;
+        Type::bind(std::move(value));
+    }
+
+private:
+    sigh<void(basic_registry<entity_type> &, const entity_type)> construction{};
+    sigh<void(basic_registry<entity_type> &, const entity_type)> destruction{};
+    sigh<void(basic_registry<entity_type> &, const entity_type)> update{};
+    basic_registry<entity_type> *owner{};
+};
+
+} // namespace entt
+
+#endif

src/entt/entity/snapshot.hpp

@@ -0,0 +1,561 @@
+#ifndef ENTT_ENTITY_SNAPSHOT_HPP
+#define ENTT_ENTITY_SNAPSHOT_HPP
+
+#include <array>
+#include <cstddef>
+#include <iterator>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "../config/config.h"
+#include "../container/dense_map.hpp"
+#include "../core/type_traits.hpp"
+#include "component.hpp"
+#include "entity.hpp"
+#include "fwd.hpp"
+#include "registry.hpp"
+
+namespace entt {
+
+/**
+ * @brief Utility class to create snapshots from a registry.
+ *
+ * A _snapshot_ can be either a dump of the entire registry or a narrower
+ * selection of components of interest.<br/>
+ * This type can be used in both cases if provided with a correctly configured
+ * output archive.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class basic_snapshot {
+    using entity_traits = entt_traits<Entity>;
+
+    template<typename Component, typename Archive, typename It>
+    void get(Archive &archive, std::size_t sz, It first, It last) const {
+        const auto view = reg->template view<std::add_const_t<Component>>();
+        archive(typename entity_traits::entity_type(sz));
+
+        while(first != last) {
+            const auto entt = *(first++);
+
+            if(reg->template all_of<Component>(entt)) {
+                std::apply(archive, std::tuple_cat(std::make_tuple(entt), view.get(entt)));
+            }
+        }
+    }
+
+    template<typename... Component, typename Archive, typename It, std::size_t... Index>
+    void component(Archive &archive, It first, It last, std::index_sequence<Index...>) const {
+        std::array<std::size_t, sizeof...(Index)> size{};
+        auto begin = first;
+
+        while(begin != last) {
+            const auto entt = *(begin++);
+            ((reg->template all_of<Component>(entt) ? ++size[Index] : 0u), ...);
+        }
+
+        (get<Component>(archive, size[Index], first, last), ...);
+    }
+
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+
+    /**
+     * @brief Constructs an instance that is bound to a given registry.
+     * @param source A valid reference to a registry.
+     */
+    basic_snapshot(const basic_registry<entity_type> &source) ENTT_NOEXCEPT
+        : reg{&source} {}
+
+    /*! @brief Default move constructor. */
+    basic_snapshot(basic_snapshot &&) ENTT_NOEXCEPT = default;
+
+    /*! @brief Default move assignment operator. @return This snapshot. */
+    basic_snapshot &operator=(basic_snapshot &&) ENTT_NOEXCEPT = default;
+
+    /**
+     * @brief Puts aside all the entities from the underlying registry.
+     *
+     * Entities are serialized along with their versions. Destroyed entities are
+     * taken in consideration as well by this function.
+     *
+     * @tparam Archive Type of output archive.
+     * @param archive A valid reference to an output archive.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename Archive>
+    const basic_snapshot &entities(Archive &archive) const {
+        const auto sz = reg->size();
+
+        archive(typename entity_traits::entity_type(sz + 1u));
+        archive(reg->released());
+
+        for(auto first = reg->data(), last = first + sz; first != last; ++first) {
+            archive(*first);
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Puts aside the given components.
+     *
+     * Each instance is serialized together with the entity to which it belongs.
+     * Entities are serialized along with their versions.
+     *
+     * @tparam Component Types of components to serialize.
+     * @tparam Archive Type of output archive.
+     * @param archive A valid reference to an output archive.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename... Component, typename Archive>
+    const basic_snapshot &component(Archive &archive) const {
+        if constexpr(sizeof...(Component) == 1u) {
+            const auto view = reg->template view<const Component...>();
+            (component<Component>(archive, view.rbegin(), view.rend()), ...);
+            return *this;
+        } else {
+            (component<Component>(archive), ...);
+            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 basic_snapshot &component(Archive &archive, It first, It last) const {
+        component<Component...>(archive, first, last, std::index_sequence_for<Component...>{});
+        return *this;
+    }
+
+private:
+    const basic_registry<entity_type> *reg;
+};
+
+/**
+ * @brief Utility class to restore a snapshot as a whole.
+ *
+ * A snapshot loader requires that the destination registry be empty and loads
+ * all the data at once while keeping intact the identifiers that the entities
+ * originally had.<br/>
+ * An example of use is the implementation of a save/restore utility.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class basic_snapshot_loader {
+    using entity_traits = entt_traits<Entity>;
+
+    template<typename Type, typename Archive>
+    void assign(Archive &archive) const {
+        typename entity_traits::entity_type length{};
+        entity_type entt;
+
+        archive(length);
+
+        if constexpr(ignore_as_empty_v<Type>) {
+            while(length--) {
+                archive(entt);
+                const auto entity = reg->valid(entt) ? entt : reg->create(entt);
+                ENTT_ASSERT(entity == entt, "Entity not available for use");
+                reg->template emplace<Type>(entt);
+            }
+        } else {
+            Type instance;
+
+            while(length--) {
+                archive(entt, instance);
+                const auto entity = reg->valid(entt) ? entt : reg->create(entt);
+                ENTT_ASSERT(entity == entt, "Entity not available for use");
+                reg->template emplace<Type>(entt, std::move(instance));
+            }
+        }
+    }
+
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+
+    /**
+     * @brief Constructs an instance that is bound to a given registry.
+     * @param source A valid reference to a registry.
+     */
+    basic_snapshot_loader(basic_registry<entity_type> &source) ENTT_NOEXCEPT
+        : reg{&source} {
+        // restoring a snapshot as a whole requires a clean registry
+        ENTT_ASSERT(reg->empty(), "Registry must be empty");
+    }
+
+    /*! @brief Default move constructor. */
+    basic_snapshot_loader(basic_snapshot_loader &&) ENTT_NOEXCEPT = default;
+
+    /*! @brief Default move assignment operator. @return This loader. */
+    basic_snapshot_loader &operator=(basic_snapshot_loader &&) ENTT_NOEXCEPT = default;
+
+    /**
+     * @brief Restores entities that were in use during serialization.
+     *
+     * This function restores the entities that were in use during serialization
+     * and gives them the versions they originally had.
+     *
+     * @tparam Archive Type of input archive.
+     * @param archive A valid reference to an input archive.
+     * @return A valid loader to continue restoring data.
+     */
+    template<typename Archive>
+    const basic_snapshot_loader &entities(Archive &archive) const {
+        typename entity_traits::entity_type length{};
+
+        archive(length);
+        std::vector<entity_type> all(length);
+
+        for(std::size_t pos{}; pos < length; ++pos) {
+            archive(all[pos]);
+        }
+
+        reg->assign(++all.cbegin(), all.cend(), all[0u]);
+
+        return *this;
+    }
+
+    /**
+     * @brief Restores components and assigns them to the right entities.
+     *
+     * The template parameter list must be exactly the same used during
+     * serialization. In the event that the entity to which the component is
+     * assigned doesn't exist yet, the loader will take care to create it with
+     * the version it originally had.
+     *
+     * @tparam Component Types of components to restore.
+     * @tparam Archive Type of input archive.
+     * @param archive A valid reference to an input archive.
+     * @return A valid loader to continue restoring data.
+     */
+    template<typename... Component, typename Archive>
+    const basic_snapshot_loader &component(Archive &archive) const {
+        (assign<Component>(archive), ...);
+        return *this;
+    }
+
+    /**
+     * @brief Destroys those entities that have no components.
+     *
+     * In case all the entities were serialized but only part of the components
+     * was saved, it could happen that some of the entities have no components
+     * once restored.<br/>
+     * This functions helps to identify and destroy those entities.
+     *
+     * @return A valid loader to continue restoring data.
+     */
+    const basic_snapshot_loader &orphans() const {
+        reg->each([this](const auto entt) {
+            if(reg->orphan(entt)) {
+                reg->release(entt);
+            }
+        });
+
+        return *this;
+    }
+
+private:
+    basic_registry<entity_type> *reg;
+};
+
+/**
+ * @brief Utility class for _continuous loading_.
+ *
+ * A _continuous loader_ is designed to load data from a source registry to a
+ * (possibly) non-empty destination. The loader can accommodate in a registry
+ * more than one snapshot in a sort of _continuous loading_ that updates the
+ * destination one step at a time.<br/>
+ * Identifiers that entities originally had are not transferred to the target.
+ * Instead, the loader maps remote identifiers to local ones while restoring a
+ * snapshot.<br/>
+ * An example of use is the implementation of a client-server applications with
+ * the requirement of transferring somehow parts of the representation side to
+ * side.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ */
+template<typename Entity>
+class basic_continuous_loader {
+    using entity_traits = entt_traits<Entity>;
+
+    void destroy(Entity entt) {
+        if(const auto it = remloc.find(entt); it == remloc.cend()) {
+            const auto local = reg->create();
+            remloc.emplace(entt, std::make_pair(local, true));
+            reg->destroy(local);
+        }
+    }
+
+    void restore(Entity entt) {
+        const auto it = remloc.find(entt);
+
+        if(it == remloc.cend()) {
+            const auto local = reg->create();
+            remloc.emplace(entt, std::make_pair(local, true));
+        } else {
+            if(!reg->valid(remloc[entt].first)) {
+                remloc[entt].first = reg->create();
+            }
+
+            // set the dirty flag
+            remloc[entt].second = true;
+        }
+    }
+
+    template<typename Container>
+    auto update(int, Container &container) -> decltype(typename Container::mapped_type{}, void()) {
+        // map like container
+        Container other;
+
+        for(auto &&pair: container) {
+            using first_type = std::remove_const_t<typename std::decay_t<decltype(pair)>::first_type>;
+            using second_type = typename std::decay_t<decltype(pair)>::second_type;
+
+            if constexpr(std::is_same_v<first_type, entity_type> && std::is_same_v<second_type, entity_type>) {
+                other.emplace(map(pair.first), map(pair.second));
+            } else if constexpr(std::is_same_v<first_type, entity_type>) {
+                other.emplace(map(pair.first), std::move(pair.second));
+            } else {
+                static_assert(std::is_same_v<second_type, entity_type>, "Neither the key nor the value are of entity type");
+                other.emplace(std::move(pair.first), map(pair.second));
+            }
+        }
+
+        using std::swap;
+        swap(container, other);
+    }
+
+    template<typename Container>
+    auto update(char, Container &container) -> decltype(typename Container::value_type{}, void()) {
+        // vector like container
+        static_assert(std::is_same_v<typename Container::value_type, entity_type>, "Invalid value type");
+
+        for(auto &&entt: container) {
+            entt = map(entt);
+        }
+    }
+
+    template<typename Other, typename Type, typename Member>
+    void update([[maybe_unused]] Other &instance, [[maybe_unused]] Member Type::*member) {
+        if constexpr(!std::is_same_v<Other, Type>) {
+            return;
+        } else if constexpr(std::is_same_v<Member, entity_type>) {
+            instance.*member = map(instance.*member);
+        } else {
+            // maybe a container? let's try...
+            update(0, instance.*member);
+        }
+    }
+
+    template<typename Component>
+    void remove_if_exists() {
+        for(auto &&ref: remloc) {
+            const auto local = ref.second.first;
+
+            if(reg->valid(local)) {
+                reg->template remove<Component>(local);
+            }
+        }
+    }
+
+    template<typename Other, typename Archive, typename... Type, typename... Member>
+    void assign(Archive &archive, [[maybe_unused]] Member Type::*...member) {
+        typename entity_traits::entity_type length{};
+        entity_type entt;
+
+        archive(length);
+
+        if constexpr(ignore_as_empty_v<Other>) {
+            while(length--) {
+                archive(entt);
+                restore(entt);
+                reg->template emplace_or_replace<Other>(map(entt));
+            }
+        } else {
+            Other instance;
+
+            while(length--) {
+                archive(entt, instance);
+                (update(instance, member), ...);
+                restore(entt);
+                reg->template emplace_or_replace<Other>(map(entt), std::move(instance));
+            }
+        }
+    }
+
+public:
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+
+    /**
+     * @brief Constructs an instance that is bound to a given registry.
+     * @param source A valid reference to a registry.
+     */
+    basic_continuous_loader(basic_registry<entity_type> &source) ENTT_NOEXCEPT
+        : reg{&source} {}
+
+    /*! @brief Default move constructor. */
+    basic_continuous_loader(basic_continuous_loader &&) = default;
+
+    /*! @brief Default move assignment operator. @return This loader. */
+    basic_continuous_loader &operator=(basic_continuous_loader &&) = default;
+
+    /**
+     * @brief Restores entities that were in use during serialization.
+     *
+     * This function restores the entities that were in use during serialization
+     * and creates local counterparts for them if required.
+     *
+     * @tparam Archive Type of input archive.
+     * @param archive A valid reference to an input archive.
+     * @return A non-const reference to this loader.
+     */
+    template<typename Archive>
+    basic_continuous_loader &entities(Archive &archive) {
+        typename entity_traits::entity_type length{};
+        entity_type entt{};
+
+        archive(length);
+        // discards the head of the list of destroyed entities
+        archive(entt);
+
+        for(std::size_t pos{}, last = length - 1u; pos < last; ++pos) {
+            archive(entt);
+
+            if(const auto entity = entity_traits::to_entity(entt); entity == pos) {
+                restore(entt);
+            } else {
+                destroy(entt);
+            }
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Restores components and assigns them to the right entities.
+     *
+     * The template parameter list must be exactly the same used during
+     * serialization. In the event that the entity to which the component is
+     * assigned doesn't exist yet, the loader will take care to create a local
+     * counterpart for it.<br/>
+     * Members can be either data members of type entity_type or containers of
+     * entities. In both cases, the loader will visit them and update the
+     * entities by replacing each one with its local counterpart.
+     *
+     * @tparam Component Type of component to restore.
+     * @tparam Archive Type of input archive.
+     * @tparam Type Types of components to update with local counterparts.
+     * @tparam Member Types of members to update with their local counterparts.
+     * @param archive A valid reference to an input archive.
+     * @param member Members to update with their local counterparts.
+     * @return A non-const reference to this loader.
+     */
+    template<typename... Component, typename Archive, typename... Type, typename... Member>
+    basic_continuous_loader &component(Archive &archive, Member Type::*...member) {
+        (remove_if_exists<Component>(), ...);
+        (assign<Component>(archive, member...), ...);
+        return *this;
+    }
+
+    /**
+     * @brief Helps to purge entities that no longer have a conterpart.
+     *
+     * Users should invoke this member function after restoring each snapshot,
+     * unless they know exactly what they are doing.
+     *
+     * @return A non-const reference to this loader.
+     */
+    basic_continuous_loader &shrink() {
+        auto it = remloc.begin();
+
+        while(it != remloc.cend()) {
+            const auto local = it->second.first;
+            bool &dirty = it->second.second;
+
+            if(dirty) {
+                dirty = false;
+                ++it;
+            } else {
+                if(reg->valid(local)) {
+                    reg->destroy(local);
+                }
+
+                it = remloc.erase(it);
+            }
+        }
+
+        return *this;
+    }
+
+    /**
+     * @brief Destroys those entities that have no components.
+     *
+     * In case all the entities were serialized but only part of the components
+     * was saved, it could happen that some of the entities have no components
+     * once restored.<br/>
+     * This functions helps to identify and destroy those entities.
+     *
+     * @return A non-const reference to this loader.
+     */
+    basic_continuous_loader &orphans() {
+        reg->each([this](const auto entt) {
+            if(reg->orphan(entt)) {
+                reg->release(entt);
+            }
+        });
+
+        return *this;
+    }
+
+    /**
+     * @brief Tests if a loader knows about a given entity.
+     * @param entt A valid identifier.
+     * @return True if `entity` is managed by the loader, false otherwise.
+     */
+    [[nodiscard]] bool contains(entity_type entt) const ENTT_NOEXCEPT {
+        return (remloc.find(entt) != remloc.cend());
+    }
+
+    /**
+     * @brief Returns the identifier to which an entity refers.
+     * @param entt A valid identifier.
+     * @return The local identifier if any, the null entity otherwise.
+     */
+    [[nodiscard]] entity_type map(entity_type entt) const ENTT_NOEXCEPT {
+        const auto it = remloc.find(entt);
+        entity_type other = null;
+
+        if(it != remloc.cend()) {
+            other = it->second.first;
+        }
+
+        return other;
+    }
+
+private:
+    dense_map<entity_type, std::pair<entity_type, bool>> remloc;
+    basic_registry<entity_type> *reg;
+};
+
+} // namespace entt
+
+#endif

src/entt/entity/storage.hpp

@@ -0,0 +1,910 @@
+#ifndef ENTT_ENTITY_STORAGE_HPP
+#define ENTT_ENTITY_STORAGE_HPP
+
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+#include <vector>
+#include "../config/config.h"
+#include "../core/compressed_pair.hpp"
+#include "../core/iterator.hpp"
+#include "../core/memory.hpp"
+#include "../core/type_info.hpp"
+#include "component.hpp"
+#include "entity.hpp"
+#include "fwd.hpp"
+#include "sigh_storage_mixin.hpp"
+#include "sparse_set.hpp"
+
+namespace entt {
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+namespace internal {
+
+template<typename Container>
+class storage_iterator final {
+    friend storage_iterator<const Container>;
+
+    using container_type = std::remove_const_t<Container>;
+    using alloc_traits = std::allocator_traits<typename container_type::allocator_type>;
+    using comp_traits = component_traits<typename container_type::value_type>;
+
+    using iterator_traits = std::iterator_traits<std::conditional_t<
+        std::is_const_v<Container>,
+        typename alloc_traits::template rebind_traits<typename std::pointer_traits<typename container_type::value_type>::element_type>::const_pointer,
+        typename alloc_traits::template rebind_traits<typename std::pointer_traits<typename container_type::value_type>::element_type>::pointer>>;
+
+public:
+    using value_type = typename iterator_traits::value_type;
+    using pointer = typename iterator_traits::pointer;
+    using reference = typename iterator_traits::reference;
+    using difference_type = typename iterator_traits::difference_type;
+    using iterator_category = std::random_access_iterator_tag;
+
+    storage_iterator() ENTT_NOEXCEPT = default;
+
+    storage_iterator(Container *ref, difference_type idx) ENTT_NOEXCEPT
+        : packed{ref},
+          offset{idx} {}
+
+    template<bool Const = std::is_const_v<Container>, typename = std::enable_if_t<Const>>
+    storage_iterator(const storage_iterator<std::remove_const_t<Container>> &other) ENTT_NOEXCEPT
+        : packed{other.packed},
+          offset{other.offset} {}
+
+    storage_iterator &operator++() ENTT_NOEXCEPT {
+        return --offset, *this;
+    }
+
+    storage_iterator operator++(int) ENTT_NOEXCEPT {
+        storage_iterator orig = *this;
+        return ++(*this), orig;
+    }
+
+    storage_iterator &operator--() ENTT_NOEXCEPT {
+        return ++offset, *this;
+    }
+
+    storage_iterator operator--(int) ENTT_NOEXCEPT {
+        storage_iterator orig = *this;
+        return operator--(), orig;
+    }
+
+    storage_iterator &operator+=(const difference_type value) ENTT_NOEXCEPT {
+        offset -= value;
+        return *this;
+    }
+
+    storage_iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
+        storage_iterator copy = *this;
+        return (copy += value);
+    }
+
+    storage_iterator &operator-=(const difference_type value) ENTT_NOEXCEPT {
+        return (*this += -value);
+    }
+
+    storage_iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
+        return (*this + -value);
+    }
+
+    [[nodiscard]] reference operator[](const difference_type value) const ENTT_NOEXCEPT {
+        const auto pos = index() - value;
+        return (*packed)[pos / comp_traits::page_size][fast_mod(pos, comp_traits::page_size)];
+    }
+
+    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
+        const auto pos = index();
+        return (*packed)[pos / comp_traits::page_size] + fast_mod(pos, comp_traits::page_size);
+    }
+
+    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
+        return *operator->();
+    }
+
+    [[nodiscard]] difference_type index() const ENTT_NOEXCEPT {
+        return offset - 1;
+    }
+
+private:
+    Container *packed;
+    difference_type offset;
+};
+
+template<typename CLhs, typename CRhs>
+[[nodiscard]] std::ptrdiff_t operator-(const storage_iterator<CLhs> &lhs, const storage_iterator<CRhs> &rhs) ENTT_NOEXCEPT {
+    return rhs.index() - lhs.index();
+}
+
+template<typename CLhs, typename CRhs>
+[[nodiscard]] bool operator==(const storage_iterator<CLhs> &lhs, const storage_iterator<CRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.index() == rhs.index();
+}
+
+template<typename CLhs, typename CRhs>
+[[nodiscard]] bool operator!=(const storage_iterator<CLhs> &lhs, const storage_iterator<CRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+template<typename CLhs, typename CRhs>
+[[nodiscard]] bool operator<(const storage_iterator<CLhs> &lhs, const storage_iterator<CRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.index() > rhs.index();
+}
+
+template<typename CLhs, typename CRhs>
+[[nodiscard]] bool operator>(const storage_iterator<CLhs> &lhs, const storage_iterator<CRhs> &rhs) ENTT_NOEXCEPT {
+    return lhs.index() < rhs.index();
+}
+
+template<typename CLhs, typename CRhs>
+[[nodiscard]] bool operator<=(const storage_iterator<CLhs> &lhs, const storage_iterator<CRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs > rhs);
+}
+
+template<typename CLhs, typename CRhs>
+[[nodiscard]] bool operator>=(const storage_iterator<CLhs> &lhs, const storage_iterator<CRhs> &rhs) ENTT_NOEXCEPT {
+    return !(lhs < rhs);
+}
+
+template<typename It, typename... Other>
+class extended_storage_iterator final {
+    template<typename Iter, typename... Args>
+    friend class extended_storage_iterator;
+
+public:
+    using value_type = decltype(std::tuple_cat(std::make_tuple(*std::declval<It>()), std::forward_as_tuple(*std::declval<Other>()...)));
+    using pointer = input_iterator_pointer<value_type>;
+    using reference = value_type;
+    using difference_type = std::ptrdiff_t;
+    using iterator_category = std::input_iterator_tag;
+
+    extended_storage_iterator() = default;
+
+    extended_storage_iterator(It base, Other... other)
+        : it{base, other...} {}
+
+    template<typename... Args, typename = std::enable_if_t<(!std::is_same_v<Other, Args> && ...) && (std::is_constructible_v<Other, Args> && ...)>>
+    extended_storage_iterator(const extended_storage_iterator<It, Args...> &other)
+        : it{other.it} {}
+
+    extended_storage_iterator &operator++() ENTT_NOEXCEPT {
+        return ++std::get<It>(it), (++std::get<Other>(it), ...), *this;
+    }
+
+    extended_storage_iterator operator++(int) ENTT_NOEXCEPT {
+        extended_storage_iterator orig = *this;
+        return ++(*this), orig;
+    }
+
+    [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
+        return operator*();
+    }
+
+    [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
+        return {*std::get<It>(it), *std::get<Other>(it)...};
+    }
+
+    template<typename... CLhs, typename... CRhs>
+    friend bool operator==(const extended_storage_iterator<CLhs...> &, const extended_storage_iterator<CRhs...> &) ENTT_NOEXCEPT;
+
+private:
+    std::tuple<It, Other...> it;
+};
+
+template<typename... CLhs, typename... CRhs>
+[[nodiscard]] bool operator==(const extended_storage_iterator<CLhs...> &lhs, const extended_storage_iterator<CRhs...> &rhs) ENTT_NOEXCEPT {
+    return std::get<0>(lhs.it) == std::get<0>(rhs.it);
+}
+
+template<typename... CLhs, typename... CRhs>
+[[nodiscard]] bool operator!=(const extended_storage_iterator<CLhs...> &lhs, const extended_storage_iterator<CRhs...> &rhs) ENTT_NOEXCEPT {
+    return !(lhs == rhs);
+}
+
+} // namespace internal
+
+/**
+ * Internal details not to be documented.
+ * @endcond
+ */
+
+/**
+ * @brief Basic storage implementation.
+ *
+ * Internal data structures arrange elements to maximize performance. There are
+ * no guarantees that objects are returned in the insertion order when iterate
+ * a storage. Do not make assumption on the order in any case.
+ *
+ * @warning
+ * Empty types aren't explicitly instantiated. Therefore, many of the functions
+ * normally available for non-empty types will not be available for empty ones.
+ *
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Type Type of objects assigned to the entities.
+ * @tparam Allocator Type of allocator used to manage memory and elements.
+ */
+template<typename Entity, typename Type, typename Allocator, typename>
+class basic_storage: public basic_sparse_set<Entity, typename std::allocator_traits<Allocator>::template rebind_alloc<Entity>> {
+    static_assert(std::is_move_constructible_v<Type> && std::is_move_assignable_v<Type>, "The type must be at least move constructible/assignable");
+
+    using alloc_traits = std::allocator_traits<Allocator>;
+    static_assert(std::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
+    using underlying_type = basic_sparse_set<Entity, typename alloc_traits::template rebind_alloc<Entity>>;
+    using container_type = std::vector<typename alloc_traits::pointer, typename alloc_traits::template rebind_alloc<typename alloc_traits::pointer>>;
+    using comp_traits = component_traits<Type>;
+
+    [[nodiscard]] auto &element_at(const std::size_t pos) const {
+        return packed.first()[pos / comp_traits::page_size][fast_mod(pos, comp_traits::page_size)];
+    }
+
+    auto assure_at_least(const std::size_t pos) {
+        auto &&container = packed.first();
+        const auto idx = pos / comp_traits::page_size;
+
+        if(!(idx < container.size())) {
+            auto curr = container.size();
+            container.resize(idx + 1u, nullptr);
+
+            ENTT_TRY {
+                for(const auto last = container.size(); curr < last; ++curr) {
+                    container[curr] = alloc_traits::allocate(packed.second(), comp_traits::page_size);
+                }
+            }
+            ENTT_CATCH {
+                container.resize(curr);
+                ENTT_THROW;
+            }
+        }
+
+        return container[idx] + fast_mod(pos, comp_traits::page_size);
+    }
+
+    template<typename... Args>
+    auto emplace_element(const Entity entt, const bool force_back, Args &&...args) {
+        const auto it = base_type::try_emplace(entt, force_back);
+
+        ENTT_TRY {
+            auto elem = assure_at_least(static_cast<size_type>(it.index()));
+            entt::uninitialized_construct_using_allocator(to_address(elem), packed.second(), std::forward<Args>(args)...);
+        }
+        ENTT_CATCH {
+            if constexpr(comp_traits::in_place_delete) {
+                base_type::in_place_pop(it, it + 1u);
+            } else {
+                base_type::swap_and_pop(it, it + 1u);
+            }
+
+            ENTT_THROW;
+        }
+
+        return it;
+    }
+
+    void shrink_to_size(const std::size_t sz) {
+        for(auto pos = sz, length = base_type::size(); pos < length; ++pos) {
+            if constexpr(comp_traits::in_place_delete) {
+                if(base_type::at(pos) != tombstone) {
+                    std::destroy_at(std::addressof(element_at(pos)));
+                }
+            } else {
+                std::destroy_at(std::addressof(element_at(pos)));
+            }
+        }
+
+        auto &&container = packed.first();
+        auto page_allocator{packed.second()};
+        const auto from = (sz + comp_traits::page_size - 1u) / comp_traits::page_size;
+
+        for(auto pos = from, last = container.size(); pos < last; ++pos) {
+            alloc_traits::deallocate(page_allocator, container[pos], comp_traits::page_size);
+        }
+
+        container.resize(from);
+    }
+
+private:
+    const void *get_at(const std::size_t pos) const final {
+        return std::addressof(element_at(pos));
+    }
+
+    void swap_at(const std::size_t lhs, const std::size_t rhs) final {
+        using std::swap;
+        swap(element_at(lhs), element_at(rhs));
+    }
+
+    void move_element(const std::size_t from, const std::size_t to) final {
+        auto &elem = element_at(from);
+        entt::uninitialized_construct_using_allocator(to_address(assure_at_least(to)), packed.second(), std::move(elem));
+        std::destroy_at(std::addressof(elem));
+    }
+
+protected:
+    /**
+     * @brief Erases elements from a storage.
+     * @param first An iterator to the first element to erase.
+     * @param last An iterator past the last element to erase.
+     */
+    void swap_and_pop(typename underlying_type::basic_iterator first, typename underlying_type::basic_iterator last) override {
+        for(; first != last; ++first) {
+            auto &elem = element_at(base_type::size() - 1u);
+            // destroying on exit allows reentrant destructors
+            [[maybe_unused]] auto unused = std::exchange(element_at(static_cast<size_type>(first.index())), std::move(elem));
+            std::destroy_at(std::addressof(elem));
+            base_type::swap_and_pop(first, first + 1u);
+        }
+    }
+
+    /**
+     * @brief Erases elements from a storage.
+     * @param first An iterator to the first element to erase.
+     * @param last An iterator past the last element to erase.
+     */
+    void in_place_pop(typename underlying_type::basic_iterator first, typename underlying_type::basic_iterator last) override {
+        for(; first != last; ++first) {
+            base_type::in_place_pop(first, first + 1u);
+            std::destroy_at(std::addressof(element_at(static_cast<size_type>(first.index()))));
+        }
+    }
+
+    /**
+     * @brief Assigns an entity to a storage.
+     * @param entt A valid identifier.
+     * @param value Optional opaque value.
+     * @param force_back Force back insertion.
+     * @return Iterator pointing to the emplaced element.
+     */
+    typename underlying_type::basic_iterator try_emplace([[maybe_unused]] const Entity entt, const bool force_back, const void *value) override {
+        if(value) {
+            if constexpr(std::is_copy_constructible_v<value_type>) {
+                return emplace_element(entt, force_back, *static_cast<const value_type *>(value));
+            } else {
+                return base_type::end();
+            }
+        } else {
+            if constexpr(std::is_default_constructible_v<value_type>) {
+                return emplace_element(entt, force_back);
+            } else {
+                return base_type::end();
+            }
+        }
+    }
+
+public:
+    /*! @brief Base type. */
+    using base_type = underlying_type;
+    /*! @brief Allocator type. */
+    using allocator_type = Allocator;
+    /*! @brief Type of the objects assigned to entities. */
+    using value_type = Type;
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+    /*! @brief Pointer type to contained elements. */
+    using pointer = typename container_type::pointer;
+    /*! @brief Constant pointer type to contained elements. */
+    using const_pointer = typename alloc_traits::template rebind_traits<typename alloc_traits::const_pointer>::const_pointer;
+    /*! @brief Random access iterator type. */
+    using iterator = internal::storage_iterator<container_type>;
+    /*! @brief Constant random access iterator type. */
+    using const_iterator = internal::storage_iterator<const container_type>;
+    /*! @brief Reverse iterator type. */
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    /*! @brief Constant reverse iterator type. */
+    using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+    /*! @brief Extended iterable storage proxy. */
+    using iterable = iterable_adaptor<internal::extended_storage_iterator<typename base_type::iterator, iterator>>;
+    /*! @brief Constant extended iterable storage proxy. */
+    using const_iterable = iterable_adaptor<internal::extended_storage_iterator<typename base_type::const_iterator, const_iterator>>;
+
+    /*! @brief Default constructor. */
+    basic_storage()
+        : basic_storage{allocator_type{}} {}
+
+    /**
+     * @brief Constructs an empty storage with a given allocator.
+     * @param allocator The allocator to use.
+     */
+    explicit basic_storage(const allocator_type &allocator)
+        : base_type{type_id<value_type>(), deletion_policy{comp_traits::in_place_delete}, allocator},
+          packed{container_type{allocator}, allocator} {}
+
+    /**
+     * @brief Move constructor.
+     * @param other The instance to move from.
+     */
+    basic_storage(basic_storage &&other) ENTT_NOEXCEPT
+        : base_type{std::move(other)},
+          packed{std::move(other.packed)} {}
+
+    /**
+     * @brief Allocator-extended move constructor.
+     * @param other The instance to move from.
+     * @param allocator The allocator to use.
+     */
+    basic_storage(basic_storage &&other, const allocator_type &allocator) ENTT_NOEXCEPT
+        : base_type{std::move(other), allocator},
+          packed{container_type{std::move(other.packed.first()), allocator}, allocator} {
+        ENTT_ASSERT(alloc_traits::is_always_equal::value || packed.second() == other.packed.second(), "Copying a storage is not allowed");
+    }
+
+    /*! @brief Default destructor. */
+    ~basic_storage() override {
+        shrink_to_size(0u);
+    }
+
+    /**
+     * @brief Move assignment operator.
+     * @param other The instance to move from.
+     * @return This storage.
+     */
+    basic_storage &operator=(basic_storage &&other) ENTT_NOEXCEPT {
+        ENTT_ASSERT(alloc_traits::is_always_equal::value || packed.second() == other.packed.second(), "Copying a storage is not allowed");
+
+        shrink_to_size(0u);
+        base_type::operator=(std::move(other));
+        packed.first() = std::move(other.packed.first());
+        propagate_on_container_move_assignment(packed.second(), other.packed.second());
+        return *this;
+    }
+
+    /**
+     * @brief Exchanges the contents with those of a given storage.
+     * @param other Storage to exchange the content with.
+     */
+    void swap(basic_storage &other) {
+        using std::swap;
+        underlying_type::swap(other);
+        propagate_on_container_swap(packed.second(), other.packed.second());
+        swap(packed.first(), other.packed.first());
+    }
+
+    /**
+     * @brief Returns the associated allocator.
+     * @return The associated allocator.
+     */
+    [[nodiscard]] constexpr allocator_type get_allocator() const ENTT_NOEXCEPT {
+        return allocator_type{packed.second()};
+    }
+
+    /**
+     * @brief Increases the capacity of a storage.
+     *
+     * If the new capacity is greater than the current capacity, new storage is
+     * allocated, otherwise the method does nothing.
+     *
+     * @param cap Desired capacity.
+     */
+    void reserve(const size_type cap) override {
+        if(cap != 0u) {
+            base_type::reserve(cap);
+            assure_at_least(cap - 1u);
+        }
+    }
+
+    /**
+     * @brief Returns the number of elements that a storage has currently
+     * allocated space for.
+     * @return Capacity of the storage.
+     */
+    [[nodiscard]] size_type capacity() const ENTT_NOEXCEPT override {
+        return packed.first().size() * comp_traits::page_size;
+    }
+
+    /*! @brief Requests the removal of unused capacity. */
+    void shrink_to_fit() override {
+        base_type::shrink_to_fit();
+        shrink_to_size(base_type::size());
+    }
+
+    /**
+     * @brief Direct access to the array of objects.
+     * @return A pointer to the array of objects.
+     */
+    [[nodiscard]] const_pointer raw() const ENTT_NOEXCEPT {
+        return packed.first().data();
+    }
+
+    /*! @copydoc raw */
+    [[nodiscard]] pointer raw() ENTT_NOEXCEPT {
+        return packed.first().data();
+    }
+
+    /**
+     * @brief Returns an iterator to the beginning.
+     *
+     * The returned iterator points to the first instance of the internal array.
+     * If the storage is empty, the returned iterator will be equal to `end()`.
+     *
+     * @return An iterator to the first instance of the internal array.
+     */
+    [[nodiscard]] const_iterator cbegin() const ENTT_NOEXCEPT {
+        const auto pos = static_cast<typename iterator::difference_type>(base_type::size());
+        return const_iterator{&packed.first(), pos};
+    }
+
+    /*! @copydoc cbegin */
+    [[nodiscard]] const_iterator begin() const ENTT_NOEXCEPT {
+        return cbegin();
+    }
+
+    /*! @copydoc begin */
+    [[nodiscard]] iterator begin() ENTT_NOEXCEPT {
+        const auto pos = static_cast<typename iterator::difference_type>(base_type::size());
+        return iterator{&packed.first(), pos};
+    }
+
+    /**
+     * @brief Returns an iterator to the end.
+     *
+     * The returned iterator points to the element following the last instance
+     * of the internal array. Attempting to dereference the returned iterator
+     * results in undefined behavior.
+     *
+     * @return An iterator to the element following the last instance of the
+     * internal array.
+     */
+    [[nodiscard]] const_iterator cend() const ENTT_NOEXCEPT {
+        return const_iterator{&packed.first(), {}};
+    }
+
+    /*! @copydoc cend */
+    [[nodiscard]] const_iterator end() const ENTT_NOEXCEPT {
+        return cend();
+    }
+
+    /*! @copydoc end */
+    [[nodiscard]] iterator end() ENTT_NOEXCEPT {
+        return iterator{&packed.first(), {}};
+    }
+
+    /**
+     * @brief Returns a reverse iterator to the beginning.
+     *
+     * The returned iterator points to the first instance of the reversed
+     * internal array. If the storage is empty, the returned iterator will be
+     * equal to `rend()`.
+     *
+     * @return An iterator to the first instance of the reversed internal array.
+     */
+    [[nodiscard]] const_reverse_iterator crbegin() const ENTT_NOEXCEPT {
+        return std::make_reverse_iterator(cend());
+    }
+
+    /*! @copydoc crbegin */
+    [[nodiscard]] const_reverse_iterator rbegin() const ENTT_NOEXCEPT {
+        return crbegin();
+    }
+
+    /*! @copydoc rbegin */
+    [[nodiscard]] reverse_iterator rbegin() ENTT_NOEXCEPT {
+        return std::make_reverse_iterator(end());
+    }
+
+    /**
+     * @brief Returns a reverse iterator to the end.
+     *
+     * The returned iterator points to the element following the last instance
+     * of the reversed internal array. Attempting to dereference the returned
+     * iterator results in undefined behavior.
+     *
+     * @return An iterator to the element following the last instance of the
+     * reversed internal array.
+     */
+    [[nodiscard]] const_reverse_iterator crend() const ENTT_NOEXCEPT {
+        return std::make_reverse_iterator(cbegin());
+    }
+
+    /*! @copydoc crend */
+    [[nodiscard]] const_reverse_iterator rend() const ENTT_NOEXCEPT {
+        return crend();
+    }
+
+    /*! @copydoc rend */
+    [[nodiscard]] reverse_iterator rend() ENTT_NOEXCEPT {
+        return std::make_reverse_iterator(begin());
+    }
+
+    /**
+     * @brief Returns the object assigned to an entity.
+     *
+     * @warning
+     * Attempting to use an entity that doesn't belong to the storage results in
+     * undefined behavior.
+     *
+     * @param entt A valid identifier.
+     * @return The object assigned to the entity.
+     */
+    [[nodiscard]] const value_type &get(const entity_type entt) const ENTT_NOEXCEPT {
+        return element_at(base_type::index(entt));
+    }
+
+    /*! @copydoc get */
+    [[nodiscard]] value_type &get(const entity_type entt) ENTT_NOEXCEPT {
+        return const_cast<value_type &>(std::as_const(*this).get(entt));
+    }
+
+    /**
+     * @brief Returns the object assigned to an entity as a tuple.
+     * @param entt A valid identifier.
+     * @return The object assigned to the entity as a tuple.
+     */
+    [[nodiscard]] std::tuple<const value_type &> get_as_tuple(const entity_type entt) const ENTT_NOEXCEPT {
+        return std::forward_as_tuple(get(entt));
+    }
+
+    /*! @copydoc get_as_tuple */
+    [[nodiscard]] std::tuple<value_type &> get_as_tuple(const entity_type entt) ENTT_NOEXCEPT {
+        return std::forward_as_tuple(get(entt));
+    }
+
+    /**
+     * @brief Assigns an entity to a storage and constructs its object.
+     *
+     * @warning
+     * Attempting to use an entity that already belongs to the storage results
+     * in undefined behavior.
+     *
+     * @tparam Args Types of arguments to use to construct the object.
+     * @param entt A valid identifier.
+     * @param args Parameters to use to construct an object for the entity.
+     * @return A reference to the newly created object.
+     */
+    template<typename... Args>
+    value_type &emplace(const entity_type entt, Args &&...args) {
+        if constexpr(std::is_aggregate_v<value_type>) {
+            const auto it = emplace_element(entt, false, Type{std::forward<Args>(args)...});
+            return element_at(static_cast<size_type>(it.index()));
+        } else {
+            const auto it = emplace_element(entt, false, std::forward<Args>(args)...);
+            return element_at(static_cast<size_type>(it.index()));
+        }
+    }
+
+    /**
+     * @brief Updates the instance assigned to a given entity in-place.
+     * @tparam Func Types of the function objects to invoke.
+     * @param entt A valid identifier.
+     * @param func Valid function objects.
+     * @return A reference to the updated instance.
+     */
+    template<typename... Func>
+    value_type &patch(const entity_type entt, Func &&...func) {
+        const auto idx = base_type::index(entt);
+        auto &elem = element_at(idx);
+        (std::forward<Func>(func)(elem), ...);
+        return elem;
+    }
+
+    /**
+     * @brief Assigns one or more entities to a storage and constructs their
+     * objects from a given instance.
+     *
+     * @warning
+     * Attempting to assign an entity that already belongs to the storage
+     * results in undefined behavior.
+     *
+     * @tparam It Type of input iterator.
+     * @param first An iterator to the first element of the range of entities.
+     * @param last An iterator past the last element of the range of entities.
+     * @param value An instance of the object to construct.
+     */
+    template<typename It>
+    void insert(It first, It last, const value_type &value = {}) {
+        for(; first != last; ++first) {
+            emplace_element(*first, true, value);
+        }
+    }
+
+    /**
+     * @brief Assigns one or more entities to a storage and constructs their
+     * objects from a given range.
+     *
+     * @sa construct
+     *
+     * @tparam EIt Type of input iterator.
+     * @tparam CIt Type of input iterator.
+     * @param first An iterator to the first element of the range of entities.
+     * @param last An iterator past the last element of the range of entities.
+     * @param from An iterator to the first element of the range of objects.
+     */
+    template<typename EIt, typename CIt, typename = std::enable_if_t<std::is_same_v<typename std::iterator_traits<CIt>::value_type, value_type>>>
+    void insert(EIt first, EIt last, CIt from) {
+        for(; first != last; ++first, ++from) {
+            emplace_element(*first, true, *from);
+        }
+    }
+
+    /**
+     * @brief Returns an iterable object to use to _visit_ a storage.
+     *
+     * The iterable object returns a tuple that contains the current entity and
+     * a reference to its component.
+     *
+     * @return An iterable object to use to _visit_ the storage.
+     */
+    [[nodiscard]] iterable each() ENTT_NOEXCEPT {
+        return {internal::extended_storage_iterator{base_type::begin(), begin()}, internal::extended_storage_iterator{base_type::end(), end()}};
+    }
+
+    /*! @copydoc each */
+    [[nodiscard]] const_iterable each() const ENTT_NOEXCEPT {
+        return {internal::extended_storage_iterator{base_type::cbegin(), cbegin()}, internal::extended_storage_iterator{base_type::cend(), cend()}};
+    }
+
+private:
+    compressed_pair<container_type, allocator_type> packed;
+};
+
+/*! @copydoc basic_storage */
+template<typename Entity, typename Type, typename Allocator>
+class basic_storage<Entity, Type, Allocator, std::enable_if_t<ignore_as_empty_v<Type>>>
+    : public basic_sparse_set<Entity, typename std::allocator_traits<Allocator>::template rebind_alloc<Entity>> {
+    using alloc_traits = std::allocator_traits<Allocator>;
+    static_assert(std::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");
+    using underlying_type = basic_sparse_set<Entity, typename alloc_traits::template rebind_alloc<Entity>>;
+    using comp_traits = component_traits<Type>;
+
+public:
+    /*! @brief Base type. */
+    using base_type = underlying_type;
+    /*! @brief Allocator type. */
+    using allocator_type = Allocator;
+    /*! @brief Type of the objects assigned to entities. */
+    using value_type = Type;
+    /*! @brief Underlying entity identifier. */
+    using entity_type = Entity;
+    /*! @brief Unsigned integer type. */
+    using size_type = std::size_t;
+    /*! @brief Extended iterable storage proxy. */
+    using iterable = iterable_adaptor<internal::extended_storage_iterator<typename base_type::iterator>>;
+    /*! @brief Constant extended iterable storage proxy. */
+    using const_iterable = iterable_adaptor<internal::extended_storage_iterator<typename base_type::const_iterator>>;
+
+    /*! @brief Default constructor. */
+    basic_storage()
+        : basic_storage{allocator_type{}} {}
+
+    /**
+     * @brief Constructs an empty container with a given allocator.
+     * @param allocator The allocator to use.
+     */
+    explicit basic_storage(const allocator_type &allocator)
+        : base_type{type_id<value_type>(), deletion_policy{comp_traits::in_place_delete}, allocator} {}
+
+    /**
+     * @brief Move constructor.
+     * @param other The instance to move from.
+     */
+    basic_storage(basic_storage &&other) ENTT_NOEXCEPT = default;
+
+    /**
+     * @brief Allocator-extended move constructor.
+     * @param other The instance to move from.
+     * @param allocator The allocator to use.
+     */
+    basic_storage(basic_storage &&other, const allocator_type &allocator) ENTT_NOEXCEPT
+        : base_type{std::move(other), allocator} {}
+
+    /**
+     * @brief Move assignment operator.
+     * @param other The instance to move from.
+     * @return This storage.
+     */
+    basic_storage &operator=(basic_storage &&other) ENTT_NOEXCEPT = default;
+
+    /**
+     * @brief Returns the associated allocator.
+     * @return The associated allocator.
+     */
+    [[nodiscard]] constexpr allocator_type get_allocator() const ENTT_NOEXCEPT {
+        return allocator_type{base_type::get_allocator()};
+    }
+
+    /**
+     * @brief Returns the object assigned to an entity, that is `void`.
+     *
+     * @warning
+     * Attempting to use an entity that doesn't belong to the storage results in
+     * undefined behavior.
+     *
+     * @param entt A valid identifier.
+     */
+    void get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
+        ENTT_ASSERT(base_type::contains(entt), "Storage does not contain entity");
+    }
+
+    /**
+     * @brief Returns an empty tuple.
+     *
+     * @warning
+     * Attempting to use an entity that doesn't belong to the storage results in
+     * undefined behavior.
+     *
+     * @param entt A valid identifier.
+     * @return Returns an empty tuple.
+     */
+    [[nodiscard]] std::tuple<> get_as_tuple([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
+        ENTT_ASSERT(base_type::contains(entt), "Storage does not contain entity");
+        return std::tuple{};
+    }
+
+    /**
+     * @brief Assigns an entity to a storage and constructs its object.
+     *
+     * @warning
+     * Attempting to use an entity that already belongs to the storage results
+     * in undefined behavior.
+     *
+     * @tparam Args Types of arguments to use to construct the object.
+     * @param entt A valid identifier.
+     */
+    template<typename... Args>
+    void emplace(const entity_type entt, Args &&...) {
+        base_type::try_emplace(entt, false);
+    }
+
+    /**
+     * @brief Updates the instance assigned to a given entity in-place.
+     * @tparam Func Types of the function objects to invoke.
+     * @param entt A valid identifier.
+     * @param func Valid function objects.
+     */
+    template<typename... Func>
+    void patch([[maybe_unused]] const entity_type entt, Func &&...func) {
+        ENTT_ASSERT(base_type::contains(entt), "Storage does not contain entity");
+        (std::forward<Func>(func)(), ...);
+    }
+
+    /**
+     * @brief Assigns entities to a storage.
+     * @tparam It Type of input iterator.
+     * @tparam Args Types of optional arguments.
+     * @param first An iterator to the first element of the range of entities.
+     * @param last An iterator past the last element of the range of entities.
+     */
+    template<typename It, typename... Args>
+    void insert(It first, It last, Args &&...) {
+        for(; first != last; ++first) {
+            base_type::try_emplace(*first, true);
+        }
+    }
+
+    /**
+     * @brief Returns an iterable object to use to _visit_ a storage.
+     *
+     * The iterable object returns a tuple that contains the current entity.
+     *
+     * @return An iterable object to use to _visit_ the storage.
+     */
+    [[nodiscard]] iterable each() ENTT_NOEXCEPT {
+        return {internal::extended_storage_iterator{base_type::begin()}, internal::extended_storage_iterator{base_type::end()}};
+    }
+
+    /*! @copydoc each */
+    [[nodiscard]] const_iterable each() const ENTT_NOEXCEPT {
+        return {internal::extended_storage_iterator{base_type::cbegin()}, internal::extended_storage_iterator{base_type::cend()}};
+    }
+};
+
+/**
+ * @brief Provides a common way to access certain properties of storage types.
+ * @tparam Entity A valid entity type (see entt_traits for more details).
+ * @tparam Type Type of objects managed by the storage class.
+ */
+template<typename Entity, typename Type, typename = void>
+struct storage_traits {
+    /*! @brief Resulting type after component-to-storage conversion. */
+    using storage_type = sigh_storage_mixin<basic_storage<Entity, Type>>;
+};
+
+} // namespace entt
+
+#endif

src/entt/entity/traits.hpp

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