registry: removed useless check

very useful in CI/CD pipelines

.github/FUNDING.yml

@@ -1,6 +1,6 @@
 # These are supported funding model platforms
 
-github: # [skypjack] available only for those enrolled in the github sponsor program
+github: skypjack
 patreon: skypjack
 open_collective: # Replace with a single Open Collective username
 ko_fi: # Replace with a single Ko-fi username

.github/workflows/build.yml

@@ -0,0 +1,75 @@
+name: build
+
+on: [push, pull_request]
+
+jobs:
+
+  linux:
+    timeout-minutes: 10
+
+    strategy:
+      matrix:
+        compiler: [g++, clang++]
+
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      env:
+        CXX: ${{ matrix.compiler }}
+      run: |
+        cmake -DBUILD_TESTING=ON -DBUILD_LIB=ON ..
+        make -j4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 5 -C Debug -j4
+
+  windows:
+    timeout-minutes: 10
+
+    strategy:
+      matrix:
+        os: [windows-latest, windows-2016]
+        toolset: [clang-cl, default]
+        include:
+          - toolset: clang-cl
+            toolset_option: -T"ClangCl"
+        exclude:
+          - os: windows-2016
+            toolset: clang-cl
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      run: |
+        cmake -DBUILD_TESTING=ON -DBUILD_LIB=ON ${{ matrix.toolset_option }} ..
+        cmake --build . -j 4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 5 -C Debug -j4
+
+  macos:
+    timeout-minutes: 10
+    runs-on: macOS-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      run: |
+        cmake -DBUILD_TESTING=ON -DBUILD_LIB=ON ..
+        make -j4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 5 -C Debug -j4

.github/workflows/coverage.yml

@@ -0,0 +1,33 @@
+name: coverage
+
+on: [push, pull_request]
+
+jobs:
+
+  codecov:
+    timeout-minutes: 10
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Compile tests
+      working-directory: build
+      env:
+        CXXFLAGS: "-O0 --coverage -fno-inline -fno-inline-small-functions -fno-default-inline"
+        CXX: g++
+      run: |
+        cmake -DBUILD_TESTING=ON -DBUILD_LIB=ON ..
+        make -j4
+    - name: Run tests
+      working-directory: build
+      env:
+        CTEST_OUTPUT_ON_FAILURE: 1
+      run: ctest --timeout 5 -C Debug -j4
+    - name: Upload coverage to Codecov
+      working-directory: build
+      env:
+        CODECOV_TOKEN: ${{ secrets.CODECOV_TOKEN }}
+      run: |
+        wget https://codecov.io/bash -O codecov
+        chmod +x codecov
+        ./codecov -t $CODECOV_TOKEN -B $GITHUB_REF -s test/

.github/workflows/deploy.yml

@@ -0,0 +1,40 @@
+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

.gitignore

@@ -1,8 +1,10 @@
-*.user
+# Conan
 conan/test_package/build
 
 # IDEs
+*.user
 .idea
+.vscode
 
 # Bazel
 /bazel-*

.travis.yml

@@ -1,97 +0,0 @@
-language: cpp
-dist: trusty
-sudo: false
-
-env:
-  global:
-    - CONAN_USERNAME="skypjack"
-    - CONAN_PACKAGE_NAME="entt"
-    - CONAN_HEADER_ONLY="True"
-    - NON_CONAN_DEPLOYMENT="True"
-
-conan-buildsteps: &conan-buildsteps
-  before_install:
-    # use this step if you desire to manipulate CONAN variables programmatically
-    - NON_CONAN_DEPLOYMENT="False"
-  install:
-    - chmod +x ./conan/ci/install.sh
-    - ./conan/ci/install.sh
-  script:
-    - chmod +x ./conan/ci/build.sh
-    - ./conan/ci/build.sh
-  # the following are dummies to overwrite default build steps
-  before_script:
-    - true
-  after_success:
-    - true
-  if: tag IS present
-conan-linux: &conan-linux
-  os: linux
-  sudo: required
-  language: python
-  python: "3.6"
-  services:
-    - docker
-  <<: *conan-buildsteps
-
-matrix:
-  include:
-  - 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-6.0']
-        packages: ['clang-6.0', 'g++-7']
-    env: COMPILER=clang++-6.0
-  - os: osx
-    osx_image: xcode10
-    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
-  # Conan testing and uploading
-  - <<: *conan-linux
-    env: CONAN_GCC_VERSIONS=8 CONAN_DOCKER_IMAGE=conanio/gcc8
-
-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 -DBUILD_TESTING=ON -DBUILD_LIB=ON .. && make -j4
-- CTEST_OUTPUT_ON_FAILURE=1 ctest --timeout 5 -C Debug -j4
-
-deploy:
-  provider: script
-  script: scripts/update_packages.sh $TRAVIS_TAG
-  on:
-    tags: true
-    condition: “$NON_CONAN_DEPLOYMENT = “True”

AUTHORS

@@ -15,12 +15,16 @@ dBagrat
 djarek
 DonKult
 drglove
+eliasdaler
 eugeneko
 gale83
 ghost
+grdowns
 Green-Sky
+Innokentiy-Alaytsev
 Kerndog73
 Lawrencemm
+markand
 mhammerc
 Milerius
 morbo84
@@ -29,9 +33,13 @@ NixAJ
 Paolo-Oliverio
 pgruenbacher
 prowolf
+stefanofiorentino
+suVrik
+szunhammer
 The5-1
 vblanco20-1
 willtunnels
 WizardIke
 w1th0utnam3
+xissburg
 zaucy

BUILD.bazel

@@ -1,9 +1,15 @@
-load("//bazel:copts.bzl", "entt_copts")
+_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 = entt_copts,
+    copts = select({
+      "@bazel_tools//src/conditions:windows": _msvc_copts,
+      "@bazel_tools//src/conditions:windows_msvc": _msvc_copts,
+      "@bazel_tools//src/conditions:windows_msys": _msvc_copts,
+      "//conditions:default": _gcc_copts,
+    }),
 )

CMakeLists.txt

@@ -2,7 +2,7 @@
 # EnTT
 #
 
-cmake_minimum_required(VERSION 3.7.2)
+cmake_minimum_required(VERSION 3.12.4)
 
 #
 # Building in-tree is not allowed (we take care of your craziness).
@@ -12,37 +12,44 @@ 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()
 
+#
+# Read project version
+#
+
+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 3.1.1)
-
-include(GNUInstallDirs)
+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 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-2019 ${PROJECT_AUTHOR} <${PROJECT_AUTHOR_EMAIL}>")
-message("*")
+message(VERBOSE "*")
+message(VERBOSE "* ${PROJECT_NAME} v${PROJECT_VERSION} (${CMAKE_BUILD_TYPE})")
+message(VERBOSE "* Copyright (c) 2017-2020 Michele Caini <michele.caini@gmail.com>")
+message(VERBOSE "*")
 
 option(USE_LIBCPP "Use libc++ by adding -stdlib=libc++ flag if availbale." ON)
 option(USE_ASAN "Use address sanitizer by adding -fsanitize=address -fno-omit-frame-pointer flags" OFF)
-option(USE_COMPILE_OPTIONS "Use compile options from EnTT." ON)
 
 #
 # Compiler stuff
 #
 
-if(NOT MSVC AND USE_LIBCPP)
+if(NOT WIN32 AND USE_LIBCPP)
     include(CheckCXXSourceCompiles)
     include(CMakePushCheckState)
 
@@ -56,7 +63,7 @@ if(NOT MSVC AND USE_LIBCPP)
     " HAS_LIBCPP)
 
     if(NOT HAS_LIBCPP)
-        message(WARNING "The option USE_LIBCPP is set (by default) but libc++ is not available. The flag will not be added to the target.")
+        message(VERBOSE "The option USE_LIBCPP is set (by default) but libc++ is not available. The flag will not be added to the target.")
     endif()
 
     cmake_pop_check_state()
@@ -66,36 +73,21 @@ endif()
 # Add EnTT target
 #
 
-add_library(EnTT INTERFACE)
+include(GNUInstallDirs)
 
-configure_file(${EnTT_SOURCE_DIR}/cmake/in/version.h.in ${EnTT_SOURCE_DIR}/src/entt/config/version.h @ONLY)
+add_library(EnTT INTERFACE)
+add_library(EnTT::EnTT ALIAS EnTT)
 
 target_include_directories(
-    EnTT INTERFACE
-    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/src>
-    $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
-)
-
-target_compile_definitions(
     EnTT
-    INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:DEBUG>
-    INTERFACE $<$<AND:$<CONFIG:Release>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:RELEASE>
+    INTERFACE
+        $<BUILD_INTERFACE:${EnTT_SOURCE_DIR}/src>
+        $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>
 )
 
 if(USE_ASAN)
-    target_compile_options(EnTT INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-fsanitize=address -fno-omit-frame-pointer>)
-    target_link_libraries(EnTT INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-fsanitize=address -fno-omit-frame-pointer>)
-endif()
-
-if(USE_COMPILE_OPTIONS)
-    target_compile_options(
-        EnTT
-        INTERFACE $<$<AND:$<CONFIG:Debug>,$<NOT:$<CXX_COMPILER_ID:MSVC>>>:-O0 -g>
-        # it seems that -O3 ruins a bit the performance when using clang ...
-        INTERFACE $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:Clang>>:-O2>
-        # ... on the other side, GCC is incredibly comfortable with it.
-        INTERFACE $<$<AND:$<CONFIG:Release>,$<CXX_COMPILER_ID:GNU>>:-O3>
-    )
+    target_compile_options(EnTT INTERFACE $<$<CONFIG:Debug>:-fsanitize=address -fno-omit-frame-pointer>)
+    target_link_libraries(EnTT INTERFACE $<$<CONFIG:Debug>:-fsanitize=address -fno-omit-frame-pointer>)
 endif()
 
 if(HAS_LIBCPP)
@@ -108,55 +100,48 @@ target_compile_features(EnTT INTERFACE cxx_std_17)
 # Install EnTT
 #
 
-if(${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-    set(CUSTOM_INSTALL_CONFIGDIR cmake)
-else()
-    set(CUSTOM_INSTALL_CONFIGDIR ${CMAKE_INSTALL_LIBDIR}/cmake/entt)
-endif()
-
-install(DIRECTORY src/ DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-install(TARGETS EnTT EXPORT EnTTTargets)
-
-export(EXPORT EnTTTargets FILE ${EnTT_BINARY_DIR}/EnTTTargets.cmake)
-
-install(
-    EXPORT EnTTTargets
-    FILE EnTTTargets.cmake
-    DESTINATION ${CUSTOM_INSTALL_CONFIGDIR}
-)
-
-#
-# Build tree package config file
-#
-
-configure_file(cmake/in/EnTTBuildConfig.cmake.in EnTTConfig.cmake @ONLY)
-
 include(CMakePackageConfigHelpers)
 
-#
-# Install tree package config file
-#
-
-configure_package_config_file(
-    cmake/in/EnTTConfig.cmake.in
-    ${CUSTOM_INSTALL_CONFIGDIR}/EnTTConfig.cmake
-    INSTALL_DESTINATION ${CUSTOM_INSTALL_CONFIGDIR}
-    PATH_VARS CMAKE_INSTALL_INCLUDEDIR
+install(
+    TARGETS EnTT
+    EXPORT EnTTTargets
+    ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
 )
 
 write_basic_package_version_file(
-    ${EnTT_BINARY_DIR}/EnTTConfigVersion.cmake
+    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
-        ${EnTT_BINARY_DIR}/${CUSTOM_INSTALL_CONFIGDIR}/EnTTConfig.cmake
-        ${EnTT_BINARY_DIR}/EnTTConfigVersion.cmake
-    DESTINATION ${CUSTOM_INSTALL_CONFIGDIR}
+        ${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)
 
 #
@@ -166,29 +151,9 @@ export(PACKAGE EnTT)
 option(BUILD_TESTING "Enable testing with ctest." OFF)
 
 if(BUILD_TESTING)
-    set(THREADS_PREFER_PTHREAD_FLAG ON)
-    find_package(Threads REQUIRED)
-
     option(FIND_GTEST_PACKAGE "Enable finding gtest package." OFF)
-
-    if(FIND_GTEST_PACKAGE)
-        find_package(GTest REQUIRED)
-    else()
-        # gtest, gtest_main, gmock and gmock_main targets are available from now on
-        set(GOOGLETEST_DEPS_DIR ${EnTT_SOURCE_DIR}/deps/googletest)
-        configure_file(${EnTT_SOURCE_DIR}/cmake/in/googletest.in ${GOOGLETEST_DEPS_DIR}/CMakeLists.txt)
-        execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY ${GOOGLETEST_DEPS_DIR})
-        execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${GOOGLETEST_DEPS_DIR})
-        set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-        add_subdirectory(${GOOGLETEST_DEPS_DIR}/src ${GOOGLETEST_DEPS_DIR}/build)
-        target_compile_features(gmock_main PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_FEATURES>)
-        target_compile_features(gmock PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_FEATURES>)
-        add_library(GTest::Main ALIAS gtest_main)
-    endif()
-
     option(BUILD_BENCHMARK "Build benchmark." OFF)
     option(BUILD_LIB "Build lib example." OFF)
-    option(BUILD_MOD "Build mod example." OFF)
     option(BUILD_SNAPSHOT "Build snapshot example." OFF)
 
     enable_testing()
@@ -214,13 +179,15 @@ endif()
 #
 
 add_custom_target(
-    entt_aob
+    aob
     SOURCES
-        appveyor.yml
+        .github/workflows/build.yml
+        .github/workflows/coverage.yml
+        .github/workflows/deploy.yml
+        .github/FUNDING.yml
         AUTHORS
         CONTRIBUTING.md
         LICENSE
         README.md
         TODO
-        .travis.yml
 )

LICENSE

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

README.md

@@ -3,13 +3,14 @@
 <!--
 @cond TURN_OFF_DOXYGEN
 -->
-[![GitHub version](https://badge.fury.io/gh/skypjack%2Fentt.svg)](http://badge.fury.io/gh/skypjack%2Fentt)
-[![LoC](https://tokei.rs/b1/github/skypjack/entt)](https://github.com/skypjack/entt)
-[![Build Status](https://travis-ci.org/skypjack/entt.svg?branch=master)](https://travis-ci.org/skypjack/entt)
-[![Build status](https://ci.appveyor.com/api/projects/status/rvhaabjmghg715ck?svg=true)](https://ci.appveyor.com/project/skypjack/entt)
-[![Coverage Status](https://coveralls.io/repos/github/skypjack/entt/badge.svg?branch=master)](https://coveralls.io/github/skypjack/entt?branch=master)
+[![GitHub version](https://badge.fury.io/gh/skypjack%2Fentt.svg)](https://github.com/skypjack/entt/releases)
+[![Build Status](https://github.com/skypjack/entt/workflows/build/badge.svg)](https://github.com/skypjack/entt/actions)
+[![Coverage](https://codecov.io/gh/skypjack/entt/branch/master/graph/badge.svg)](https://codecov.io/gh/skypjack/entt)
+[![Try online](https://img.shields.io/badge/try-online-brightgreen)](https://godbolt.org/z/cOUcm1)
 [![Gitter chat](https://badges.gitter.im/skypjack/entt.png)](https://gitter.im/skypjack/entt)
-[![Donate](https://img.shields.io/badge/Donate-PayPal-green.svg)](https://www.paypal.me/skypjack)
+[![Discord channel](https://img.shields.io/discord/707607951396962417?logo=discord)](https://discord.gg/5BjPWBd)
+[![Donate](https://img.shields.io/badge/donate-paypal-blue.svg)](https://www.paypal.me/skypjack)
+[![Patreon](https://img.shields.io/badge/become-patron-red.svg)](https://www.patreon.com/bePatron?c=1772573)
 
 `EnTT` is a header-only, tiny and easy to use library for game programming and
 much more written in **modern C++**, mainly known for its innovative
@@ -17,7 +18,9 @@ much more written in **modern C++**, mainly known for its innovative
 [Among others](https://github.com/skypjack/entt/wiki/EnTT-in-Action), it's used
 in [**Minecraft**](https://minecraft.net/en-us/attribution/) by Mojang and the
 [**ArcGIS Runtime SDKs**](https://developers.arcgis.com/arcgis-runtime/) by
-Esri. Open an issue or submit a PR if you don't see your project in the list!
+Esri.<br/>
+If you don't see your project in the list, please open an issue, submit a PR or
+add the [#entt](https://github.com/topics/entt) tag to your _topics_! :+1:
 
 ---
 
@@ -34,12 +37,11 @@ Check out the
 your answers may already be there.
 
 If you use `EnTT` and you want to say thanks or support the project, please
-**consider becoming a patron**:
-
-[![Patreon](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/bePatron?c=1772573)
-
-[Many thanks](https://skypjack.github.io/patreon/) to those who supported me and
-still support me today.
+**consider becoming a
+[sponsor](https://github.com/users/skypjack/sponsorship)**.<br/>
+You can help me make the difference.
+[Many thanks](https://skypjack.github.io/sponsorship/) to those who supported me
+and still support me today.
 
 # Table of Contents
 
@@ -57,9 +59,6 @@ still support me today.
 * [Contributors](#contributors)
 * [License](#license)
 * [Support](#support)
-  * [Patreon](#patreon)
-  * [Donation](#donation)
-  * [Hire me](#hire-me)
 <!--
 @endcond TURN_OFF_DOXYGEN
 -->
@@ -155,8 +154,8 @@ int main() {
 
     for(auto i = 0; i < 10; ++i) {
         auto entity = registry.create();
-        registry.assign<position>(entity, i * 1.f, i * 1.f);
-        if(i % 2 == 0) { registry.assign<velocity>(entity, i * .1f, i * .1f); }
+        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);
@@ -182,48 +181,30 @@ amazing set of features. And even more, of course.
 
 ## Performance
 
-As it stands right now, `EnTT` is just fast enough for my requirements when
-compared to my first choice (it was already amazingly fast actually).<br/>
-Below is a comparison between the two (both of them compiled with GCC 7.3.0 on a
-Dell XPS 13 from mid 2014):
+The proposed entity-component system is incredibly fast to iterate entities and
+components, this is a fact. Some compilers make a lot of optimizations because
+of how `EnTT` works, some others aren't that good. In general, if we consider
+real world cases, `EnTT` is somewhere between a bit and much faster than many of
+the other solutions around, although I couldn't check them all for obvious
+reasons.
 
-| Benchmark | EntityX (compile-time) | EnTT |
-|-----------|-------------|-------------|
-| Create 1M entities | 0.0147s | **0.0046s** |
-| Destroy 1M entities | 0.0053s | **0.0045s** |
-| 1M entities, one component | 0.0012s | **1.9e-07s** |
-| 1M entities, two components | 0.0012s | **3.8e-07s** |
-| 1M entities, two components<br/>Half of the entities have all the components | 0.0009s | **3.8e-07s** |
-| 1M entities, two components<br/>One of the entities has all the components | 0.0008s | **1.0e-06s** |
-| 1M entities, five components | 0.0010s | **7.0e-07s** |
-| 1M entities, ten components | 0.0011s | **1.2e-06s** |
-| 1M entities, ten components<br/>Half of the entities have all the components | 0.0010s | **1.2e-06s** |
-| 1M entities, ten components<br/>One of the entities has all the components | 0.0008s | **1.2e-06s** |
-| Sort 150k entities, one component<br/>Arrays are in reverse order | - | **0.0036s** |
-| Sort 150k entities, enforce permutation<br/>Arrays are in reverse order | - | **0.0005s** |
-| Sort 150k entities, one component<br/>Arrays are almost sorted, std::sort | - | **0.0035s** |
-| Sort 150k entities, one component<br/>Arrays are almost sorted, insertion sort | - | **0.0007s** |
+If you are interested, you can compile the `benchmark` test in release mode (to
+enable compiler optimizations, otherwise it would make little sense) by setting
+the `BUILD_BENCHMARK` option of `CMake` to `ON`, then evaluate yourself whether
+you're satisfied with the results or not.
 
-Note: The default version of `EntityX` (`master` branch) wasn't added to the
-comparison because it's already much slower than its compile-time counterpart.
-
-Pretty interesting results, aren't them? In fact, these benchmarks are the ones
-used by `EntityX` to show _how fast it is_. To be honest, they aren't so good
-and these results shouldn't be taken too seriously (indeed they are completely
-unrealistic).<br/>
-The proposed entity-component system is incredibly fast to iterate entities,
-this is a fact. The compiler can make a lot of optimizations because of how
-`EnTT` works, even more when components aren't used at all. This is exactly the
-case for these benchmarks. On the other hand, if we consider real world cases,
-`EnTT` is somewhere between a bit and much faster than the other solutions
-around when users also access the components and not just the entities, although
-it isn't as fast as reported by these benchmarks.<br/>
-This is why they are completely wrong and cannot be used to evaluate any of the
-entity-component-system libraries out there.
+Honestly I got tired of updating the README file whenever there is an
+improvement.<br/>
+There are already a lot of projects out there that use `EnTT` as a basis for
+comparison (this should already tell you a lot). Many of these benchmarks are
+completely wrong, many others are simply incomplete, good at omitting some
+information and using the wrong function to compare a given feature. Certainly
+there are also good ones but they age quickly if nobody updates them, especially
+when the library they are dealing with is actively developed.
 
 The choice to use `EnTT` should be based on its carefully designed API, its
-set of features and the general performance, not because some single benchmark
-shows it to be the fastest tool available.
+set of features and the general performance, **not** because some single
+benchmark shows it to be the fastest tool available.
 
 In the future I'll likely try to get even better performance while still adding
 new features, mainly for fun.<br/>
@@ -239,13 +220,11 @@ supports at least C++17.<br/>
 The requirements below are mandatory to compile the tests and to extract the
 documentation:
 
-* `CMake` version 3.2 or later.
+* `CMake` version 3.7 or later.
 * `Doxygen` version 1.8 or later.
 
-Alternatively, `Bazel` is also supported as a build system (credits to
-[zaucy](https://github.com/zaucy) who introduced what's required with
-[this](https://github.com/skypjack/entt/pull/291) pull request and offered to
-maintain it).<br/>
+Alternatively, [Bazel](https://bazel.build) is also supported as a build system
+(credits to [zaucy](https://github.com/zaucy) who offered to maintain it).<br/>
 In the documentation below I'll still refer to `CMake`, this being the official
 build system of the library.
 
@@ -291,8 +270,8 @@ The API reference will be created in HTML format within the directory
 @cond TURN_OFF_DOXYGEN
 -->
 It's also available [online](https://skypjack.github.io/entt/) for the latest
-version.<br/>
-Finally, there exists a [wiki](https://github.com/skypjack/entt/wiki) dedicated
+version, that is the last stable tag.<br/>
+Moreover, there exists a [wiki](https://github.com/skypjack/entt/wiki) dedicated
 to the project where users can find all related documentation pages.
 <!--
 @endcond TURN_OFF_DOXYGEN
@@ -317,16 +296,34 @@ Note that benchmarks are not part of this set.
 
 `EnTT` is available for some of the most known packaging tools. In particular:
 
-* [`Conan`](https://bintray.com/skypjack/conan/entt%3Askypjack/_latestVersion),
-  the C/C++ Package Manager for Developers.
+* [`Conan`](https://github.com/conan-io/conan-center-index), the C/C++ Package
+  Manager for Developers.
+
+* [`vcpkg`](https://github.com/Microsoft/vcpkg), Microsoft VC++ Packaging
+  Tool.<br/>
+  You can download and install `EnTT` in just a few simple steps:
+
+  ```
+  $ git clone https://github.com/Microsoft/vcpkg.git
+  $ cd vcpkg
+  $ ./bootstrap-vcpkg.sh
+  $ ./vcpkg integrate install
+  $ vcpkg install entt
+  ```
+
+  The `EnTT` port in `vcpkg` is kept up to date by Microsoft team members and
+  community contributors.<br/>
+  If the version is out of date, please
+  [create an issue or pull request](https://github.com/Microsoft/vcpkg) on the
+  `vcpkg` repository.
+
 * [`Homebrew`](https://github.com/skypjack/homebrew-entt), the missing package
   manager for macOS.<br/>
   Available as a homebrew formula. Just type the following to install it:
+
   ```
   brew install skypjack/entt/entt
   ```
-* [`vcpkg`](https://github.com/Microsoft/vcpkg/tree/master/ports/entt),
-  Microsoft VC++ Packaging Tool.
 
 Consider this list a work in progress and help me to make it longer.
 
@@ -375,8 +372,8 @@ know who has participated so far.
 
 # License
 
-Code and documentation Copyright (c) 2017-2019 Michele Caini.<br/>
-Logo Copyright (c) 2018-2019 Richard Caseres.
+Code and documentation Copyright (c) 2017-2020 Michele Caini.<br/>
+Logo Copyright (c) 2018-2020 Richard Caseres.
 
 Code released under
 [the MIT license](https://github.com/skypjack/entt/blob/master/LICENSE).
@@ -390,34 +387,10 @@ Logo released under
 -->
 # Support
 
-## Patreon
-
-Become a [patron](https://www.patreon.com/bePatron?c=1772573) and get access to
-extra content, help me spend more time on the projects you love and create new
-ones for you. Your support will help me to continue the work done so far and
-make it more professional and feature-rich every day.<br/>
-It takes very little to
-[become a patron](https://www.patreon.com/bePatron?c=1772573) and thus help the
-software you use every day. Don't miss the chance.
-
-## Donation
-
-Developing and maintaining `EnTT` takes some time and lots of coffee. I'd like
-to add more and more functionalities in future and turn it in a full-featured
-solution.<br/>
-If you want to support this project, you can offer me an espresso. I'm from
-Italy, we're used to turning the best coffee ever in code. If you find that
-it's not enough, feel free to support me the way you prefer.<br/>
-Take a look at the donation button at the top of the page for more details or
-just click [here](https://www.paypal.me/skypjack).
-
-## Hire me
-
-If you start using `EnTT` and need help, if you want a new feature and want me
-to give it the highest priority, if you have any other reason to contact me:
-do not hesitate. I'm available for hiring.<br/>
-Feel free to take a look at my [profile](https://github.com/skypjack) and
-contact me by mail.
+If you want to support this project, you can
+[offer me](https://github.com/users/skypjack/sponsorship) an espresso.<br/>
+If you find that it's not enough, feel free to
+[help me](https://www.paypal.me/skypjack) the way you prefer.
 <!--
 @endcond TURN_OFF_DOXYGEN
 -->

TODO

@@ -1,33 +1,25 @@
-* long term feature: templated generic vm
-* long term feature: shared_ptr less locator
-* long term feature: shared_ptr less resource cache
+* long term feature: shared_ptr less locator and resource cache
 * custom allocators and EnTT allocator-aware in general (long term feature, I don't actually need it at the moment) - see #22
 * debugging tools (#60): the issue online already contains interesting tips on this, look at it
-* runner proposal: https://en.wikipedia.org/wiki/Fork%E2%80%93join_model https://slide-rs.github.io/specs/03_dispatcher.html
-* work stealing job system (see #100)
-  - mt scheduler based on const awareness for types
-* meta: sort of meta view based on meta stuff to iterate entities, void * and meta info objects
-* allow for built-in parallel each if possible
-* allow to replace std:: with custom implementations
-* remove runtime views, welcome reflection and what about snapshot?
-* types defined at runtime that refer to the same compile-time type (but to different pools) are possible, the library is almost there
+* work stealing job system (see #100) + mt scheduler based on const awareness for types
+* meta: sort of meta view based on meta stuff to iterate entities, void * and meta info objects (remove runtime views, welcome reflection)
 * add opaque input iterators to views and groups that return tuples <entity, T &...> (proxy), multi-pass guaranteed
-* add fast lane for raw iterations, extend mt doc to describe allowed add/remove with pre-allocations on fast lanes
-* registry.each<T...>(first, last) by iterators, entities/components guaranteed
-* multi component registry::remove and some others?
-* built-in support for dual (or N-) buffering
-* allow for custom stomp functions
-* deprecate/replace snapshot
+* allow to replace std:: with custom implementations
+* custom (decoupled) pools ==> N-buffering, shared components, multi-model, hibitsets, and so on
+* add examples (and credits) from @alanjfs :)
+* static reflection, hint: template<> meta_type_t<Type>: meta_descriptor<name, func..., props..., etc...> (see #342)
+* can we write a bool conv func for entt::entity that silently compares it to null?
+* is it possible to make 0 the entity null?
+* update documentation for meta, it contains less than half of the actual feature
 
-TODO
-* custom (decoupled) pools ==> double buffering, shared components, multi-model
-* make meta work across boundaries
-  - inline variables are fine here, only the head represents a problem
-  - we should always resolve by looking into the list of types when working across boundaries, no direct resolve
-* nested groups: AB/ABC/ABCD/... (hints: sort, check functions)
-* snapshot rework/deprecation
-  * create(hint: entity) -> force-create
-  * assign<T...>(first, last)
-* use unordered_map for named pools and context variables:
-  * use direct access (pool-like) also for context variables
-  * improves multi-stomp
+Next:
+* make it easier to hook into the type system and describe how to do that to eg auto-generate meta types on first use
+* review multi component views to reduce instantiations once empty types are gone...
+* add observer functions aside observer class
+
+* WIP:
+ - introduce the component iterators for non-contiguous collections of entities (multi component views, observers, user defined collections)
+
+* WIP: snapshot rework
+ - snapshot: support for range-based archives
+ - update documentation to describe alternatives

WORKSPACE

@@ -1,41 +1 @@
 workspace(name = "com_github_skypjack_entt")
-
-load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
-
-http_archive(
-    name = "com_google_googletest",
-    strip_prefix = "googletest-release-1.8.1",
-    url = "https://github.com/google/googletest/archive/release-1.8.1.tar.gz",
-    sha256 = "9bf1fe5182a604b4135edc1a425ae356c9ad15e9b23f9f12a02e80184c3a249c",
-)
-
-http_archive(
-    name = "org_duktape",
-    url = "https://duktape.org/duktape-2.4.0.tar.xz",
-    strip_prefix = "duktape-2.4.0",
-    sha256 = "86a89307d1633b5cedb2c6e56dc86e92679fc34b05be551722d8cc69ab0771fc",
-    build_file_content = """
-cc_library(
-    name = "duktape",
-    visibility = ["//visibility:public"],
-    strip_include_prefix = "src",
-    hdrs = ["src/duktape.h", "src/duk_config.h"],
-    srcs = ["src/duktape.c", "src/duktape.h", "src/duk_config.h"],
-)
-    """,
-)
-
-http_archive(
-    name = "bazelregistry_cereal",
-    strip_prefix = "cereal-8629f40d932d57c5337d4557327f6f22436211b7",
-    url = "https://github.com/bazelregistry/cereal/archive/8629f40d932d57c5337d4557327f6f22436211b7.zip",
-    sha256 = "c983a7a2e16b153c3de022a0818d2f4836e510a3fc3bea9d3703de79f58a90a6",
-)
-
-# This is for bazelregistry_cereal
-http_archive(
-    name = "bazelregistry_rapidjson",
-    strip_prefix = "rapidjson-6b980984dacf689be8f65be823203b967c69da04",
-    url = "https://github.com/bazelregistry/rapidjson/archive/6b980984dacf689be8f65be823203b967c69da04.zip",
-    sha256 = "82187ba8de53bab3b4fb9e56d0bae81a96fa27a115e5a6ce14c70f0ef9338965",
-)

appveyor.yml

@@ -1,44 +0,0 @@
-# can use variables like {build} and {branch}
-version: 1.0.{build}
-
-skip_tags: true
-
-image:
-- Visual Studio 2019
-- Visual Studio 2017
-
-environment:
-  BUILD_DIR: "%APPVEYOR_BUILD_FOLDER%\\build"
-  CTEST_OUTPUT_ON_FAILURE: 1
-
-configuration:
-  - Debug
-
-matrix:
-  fast_finish: true
-
-for:
-  -
-    matrix:
-      only:
-        - image: Visual Studio 2019
-    environment:
-      CMAKE_GENERATOR: "Visual Studio 16 2019"
-  -
-    matrix:
-      only:
-        - image: Visual Studio 2017
-    environment:
-      CMAKE_GENERATOR: "Visual Studio 15 2017"
-
-before_build:
-  - cd %BUILD_DIR%
-  - cmake .. -DBUILD_TESTING=ON -DBUILD_LIB=ON -DCMAKE_CXX_FLAGS=/W1 -G"%CMAKE_GENERATOR%"
-
-after_build:
-  - ctest --timeout 5 -C Debug -j4
-
-build:
-  parallel: true
-  project: build/entt.sln
-  verbosity: minimal

bazel/BUILD.bazel

@@ -1 +0,0 @@
-exports_files(["copts.bzl"], visibility = ["//:__subpackages__"])

bazel/copts.bzl

@@ -1,10 +0,0 @@
-_msvc_copts = ["/std:c++17"]
-_gcc_copts = ["-std=c++17"]
-
-entt_copts = select({
-    # Windows
-    "@bazel_tools//src/conditions:windows": _msvc_copts,
-    "@bazel_tools//src/conditions:windows_msvc": _msvc_copts,
-    "@bazel_tools//src/conditions:windows_msys": _msvc_copts,
-    "//conditions:default": _gcc_copts,
-})

cmake/in/EnTTBuildConfig.cmake.in

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

cmake/in/EnTTConfig.cmake.in

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

cmake/in/cereal.in

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

cmake/in/duktape.in

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

cmake/in/googletest.in

@@ -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 master
-    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 ""
-)

cmake/in/version.h.in

@@ -1,11 +0,0 @@
-#ifndef ENTT_CONFIG_VERSION_H
-#define ENTT_CONFIG_VERSION_H
-
-
-#define ENTT_VERSION "@PROJECT_VERSION@"
-#define ENTT_VERSION_MAJOR @PROJECT_VERSION_MAJOR@
-#define ENTT_VERSION_MINOR @PROJECT_VERSION_MINOR@
-#define ENTT_VERSION_PATCH @PROJECT_VERSION_PATCH@
-
-
-#endif // ENTT_CONFIG_VERSION_H

conan/build.py

@@ -4,24 +4,19 @@ 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")
-    username = os.getenv("CONAN_USERNAME")
-    tag_version = os.getenv("CONAN_PACKAGE_VERSION", os.getenv("TRAVIS_TAG"))
-    package_version = tag_version.replace("v", "")
-    package_name_unset = "SET-CONAN_PACKAGE_NAME-OR-CONAN_REFERENCE"
-    package_name = os.getenv("CONAN_PACKAGE_NAME", package_name_unset)
+    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)
-    header_only = os.getenv("CONAN_HEADER_ONLY", False)
-    pure_c = os.getenv("CONAN_PURE_C", False)
-
     disable_shared = os.getenv("CONAN_DISABLE_SHARED_BUILD", "False")
-    if disable_shared == "True" and package_name == package_name_unset:
-        raise Exception("CONAN_DISABLE_SHARED_BUILD: True is only supported when you define CONAN_PACKAGE_NAME")
 
     builder = ConanMultiPackager(username=username,
                                  reference=reference,
@@ -31,10 +26,7 @@ if __name__ == "__main__":
                                  stable_branch_pattern=stable_branch_pattern,
                                  upload_only_when_stable=upload_only_when_stable,
                                  test_folder=test_folder)
-    if header_only == "False":
-        builder.add_common_builds(pure_c=pure_c)
-    else:
-        builder.add()
+    builder.add()
 
     filtered_builds = []
     for settings, options, env_vars, build_requires, reference in builder.items:

conan/test_package/test_package.cpp

@@ -43,8 +43,8 @@ int main() {
 
     for(auto i = 0; i < 10; ++i) {
         auto entity = registry.create();
-        registry.assign<position>(entity, i * 1.f, i * 1.f);
-        if(i % 2 == 0) { registry.assign<velocity>(entity, i * .1f, i * .1f); }
+        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);

deps/.gitignore

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

docs/CMakeLists.txt

@@ -2,6 +2,7 @@
 # Doxygen configuration (documentation)
 #
 
+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})
@@ -13,16 +14,6 @@ add_custom_target(
     COMMAND ${DOXYGEN_EXECUTABLE} ${CMAKE_CURRENT_BINARY_DIR}/doxy.cfg
     WORKING_DIRECTORY ${EnTT_SOURCE_DIR}
     VERBATIM
-    SOURCES doxy.in
-)
-
-install(
-    DIRECTORY ${DOXY_OUTPUT_DIRECTORY}/html
-    DESTINATION share/${PROJECT_NAME}-${PROJECT_VERSION}/
-)
-
-add_custom_target(
-    docs_aob
     SOURCES
         dox/extra.dox
         md/core.md
@@ -33,6 +24,13 @@ add_custom_target(
         md/locator.md
         md/meta.md
         md/process.md
+        md/references.md
         md/resource.md
         md/signal.md
+        doxy.in
+)
+
+install(
+    DIRECTORY ${DOXY_OUTPUT_DIRECTORY}/html
+    DESTINATION share/${PROJECT_NAME}-${PROJECT_VERSION}/
 )

docs/doxy.in

@@ -1,4 +1,4 @@
-# Doxyfile 1.8.13
+# Doxyfile 1.8.16
 
 # 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
@@ -226,7 +244,12 @@ 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                =
 
@@ -264,17 +287,26 @@ 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.
+# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice,
+# 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, tcl. 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.
 #
@@ -285,7 +317,7 @@ 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 +329,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 +359,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.
@@ -433,6 +465,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.
@@ -511,7 +549,7 @@ INTERNAL_DOCS          = NO
 # 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.
+# (including Cygwin) ands Mac users are advised to set this option to NO.
 # The default value is: system dependent.
 
 CASE_SENSE_NAMES       = YES
@@ -698,7 +736,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,7 +781,8 @@ 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
@@ -781,13 +820,13 @@ WARN_LOGFILE           =
 # Note: If this tag is empty the current directory is searched.
 
 INPUT                  = @DOXY_SOURCE_DIRECTORY@ \
-			 @DOXY_DOCS_DIRECTORY@ \
-			 @PROJECT_SOURCE_DIR@/README.md
+                         @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
+# documentation (see: https://www.gnu.org/software/libiconv/) for the list of
 # possible encodings.
 # The default value is: UTF-8.
 
@@ -805,7 +844,7 @@ INPUT_ENCODING         = UTF-8
 # *.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.
+# *.f, *.for, *.tcl, *.vhd, *.vhdl, *.ucf, *.qsf and *.ice.
 
 FILE_PATTERNS          = *.h \
                          *.hpp \
@@ -825,7 +864,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 +1002,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 +1034,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
 #
@@ -1028,7 +1067,7 @@ VERBATIM_HEADERS       = YES
 # 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
@@ -1041,6 +1080,16 @@ CLANG_ASSISTED_PARSING = NO
 
 CLANG_OPTIONS          =
 
+# If clang assisted parsing is enabled you can provide the clang parser with the
+# path to the compilation database (see:
+# http://clang.llvm.org/docs/HowToSetupToolingForLLVM.html) used when the 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.
+# 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
 #---------------------------------------------------------------------------
@@ -1159,7 +1208,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 +1244,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 +1278,13 @@ 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
+# 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,7 +1323,7 @@ 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
+# (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
@@ -1339,7 +1399,7 @@ 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,7 +1407,7 @@ 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 (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,7 +1416,7 @@ 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 (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.
 
@@ -1364,7 +1424,7 @@ 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 (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.
 
@@ -1372,7 +1432,7 @@ 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  =
@@ -1465,7 +1525,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.
 #
@@ -1477,7 +1537,7 @@ FORMULA_FONTSIZE       = 10
 FORMULA_TRANSPARENT    = YES
 
 # 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
@@ -1504,11 +1564,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://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/.
 # 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
@@ -1566,7 +1626,7 @@ 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,7 +1639,7 @@ 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
+# 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.
 
@@ -1631,21 +1691,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.
@@ -1766,7 +1840,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 +1854,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 +1901,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 +1912,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 +1999,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 +2038,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
@@ -2118,12 +2207,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 +2220,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.

docs/md/core.md

@@ -6,12 +6,22 @@
 # Table of Contents
 
 * [Introduction](#introduction)
-* [Compile-time identifiers](#compile-time-identifiers)
-* [Runtime identifiers](#runtime-identifiers)
+* [Unique sequential identifiers](#unique-sequential-identifiers)
+  * [Compile-time generator](#compile-time-generator)
+  * [Runtime generator](#runtime-generator)
 * [Hashed strings](#hashed-strings)
   * [Wide characters](wide-characters)
   * [Conflicts](#conflicts)
 * [Monostate](#monostate)
+* [Type support](#type-support)
+  * [Type info](#type-info)
+    * [Almost unique identifiers](#almost-unique-identifiers)
+  * [Type index](#type-index)
+  * [Type traits](#type-traits)
+    * [Member class type](#member-class-type)
+    * [Integral constant](#integral-constant)
+    * [Tag](#tag)
+* [Utilities](#utilities)
 <!--
 @endcond TURN_OFF_DOXYGEN
 -->
@@ -23,19 +33,20 @@ of the library itself.<br/>
 Hardly users will include these features in their code, but it's worth
 describing what `EnTT` offers so as not to reinvent the wheel in case of need.
 
-# Compile-time identifiers
+# Unique sequential identifiers
 
-Sometimes it's useful to be able to give unique identifiers to types at
-compile-time.<br/>
-There are plenty of different solutions out there and I could have used one of
-them. However, I decided to spend my time to define a compact and versatile tool
+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.
 
-The _result of my efforts_ is the `identifier` class template:
+## Compile-time generator
+
+To generate sequential numeric identifiers at compile-time, `EnTT` offers the
+`identifier` class template:
 
 ```cpp
-#include <ident.hpp>
-
 // defines the identifiers for the given types
 using id = entt::identifier<a_type, another_type>;
 
@@ -53,14 +64,14 @@ default:
 }
 ```
 
-This is all what the class template has to offer: a `type` inline variable that
-contains a numerical identifier for the given type. It can be used in any
-context where constant expressions are required.
+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 the
-same for every run. In case they have been used in a production environment and
-a type has to be removed, one can just use a placeholder to left the other
-identifiers unchanged:
+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 {};
@@ -72,35 +83,30 @@ using id = entt::identifier<
 >;
 ```
 
-A bit ugly to see, but it works at least.
+Perhaps a bit ugly to see in a codebase but it gets the job done at least.
 
-# Runtime identifiers
+## Runtime generator
 
-Sometimes it's useful to be able to give unique identifiers to types at
-runtime.<br/>
-There are plenty of different solutions out there and I could have used one of
-them. In fact, I adapted the most common one to my requirements and used it
-extensively within the entire library.
-
-It's the `family` class. Here is an example of use directly from the
-entity-component system:
+To generate sequential numeric identifiers at runtime, `EnTT` offers the
+`family` class template:
 
 ```cpp
-using component_family = entt::family<struct internal_registry_component_family>;
+// defines a custom generator
+using id = entt::family<struct my_tag>;
 
 // ...
 
-template<typename Component>
-component_type component() const noexcept {
-    return component_family::type<Component>;
-}
+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 numerical identifier for the given type.
+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 the same for every run.
-Indeed it mostly depends on the flow of execution.
+Please, note that identifiers aren't guaranteed to be stable across different
+runs. Indeed it mostly depends on the flow of execution.
 
 # Hashed strings
 
@@ -182,3 +188,245 @@ 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.
+
+## Type info
+
+This class template isn't a drop-in replacement for `std::type_info` but can
+provide similar information which are not implementation defined at least.
+Therefore, they can sometimes be even more reliable than those obtained otherwise.
+
+Currently, the only information available is the numeric identifier associated
+with a given type:
+
+```cpp
+auto id = entt::type_info<my_type>::id();
+```
+
+In general, the `id` function 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).<br/>
+This function **can** use non-standard features of the language for its own
+purposes. This allows it to provide compile-time identifiers that remain stable
+across different runs. However, it's possible to force the use of standard
+features only by defining the macro `ENTT_STANDARD_CPP`. In this case, there is
+no guarantee that the identifiers are stable across executions though. Moreover,
+identifiers are generated at runtime and are no longer a compile-time thing.
+
+An external type system can also be used if needed. In fact, `type_info` 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_info<Type, std::void_d<decltype(Type::custom_id())>> {
+    static constexpr entt::id_type id() ENTT_NOEXCEPT {
+        return Type::custom_id();
+    }
+};
+```
+
+Note that this class template and its specializations are widely used within
+`EnTT`. It also plays a very important role in making `EnTT` work transparently
+across boundaries in many cases.<br/>
+Please refer to the dedicated section for more details.
+
+### Almost unique identifiers
+
+Since the default non-standard, compile-time implementation makes use of hashed
+strings, it may happen that two types are assigned the same numeric
+identifier.<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.<br/>
+If the types have the same name and belong to the same namespace then their
+identifiers _could_ be identical (they won't necessarily be the same though).
+
+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_info` 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 index
+
+Types in `EnTT` are assigned also unique, sequential _indexes_ generated at
+runtime:
+
+```cpp
+auto index = entt::type_index<my_type>::value();
+```
+
+This value may differ from the numeric identifier of a type and 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`. It also plays a very important role in
+making `EnTT` work nicely across boundaries in many cases. Generating indices
+not sequentially would break an assumption and would likely lead to undesired
+behaviors.
+
+## Type traits
+
+A handful of utilities and traits not present in the standard template library
+but which can be useful in everyday life.
+
+### 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.assign<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.
+
+# 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

@@ -12,6 +12,7 @@
   * [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)
 <!--
 @endcond TURN_OFF_DOXYGEN
 -->
@@ -49,10 +50,15 @@ First of all, there are two things to do in a Windows project:
 * 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_DISABLE_ASSERT` should be defined to disable internal
-checks made by `EnTT` in debug. These are asserts introduced to help the users,
-but require to access to the underlying containers and therefore risk ruining
-the performance in some cases.
+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`
@@ -126,13 +132,9 @@ here is a workaround in the form of a macro:
 
 ```cpp
 #if defined(_MSC_VER)
-    #define HS(str)\
-        __pragma(warning(push))\
-        __pragma(warning(disable:4307))\
-        entt::hashed_string{str}\
-        __pragma(warning(pop))
+#define HS(str) __pragma(warning(suppress:4307)) entt::hashed_string{str}\
 #else
-    #define HS(str) entt::hashed_string{str}
+#define HS(str) entt::hashed_string{str}
 #endif
 ```
 
@@ -161,3 +163,38 @@ so as to get rid of the extra definitions:
 
 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. This trait doesn't check if an object can
+actually be copied but only verifies if there is a copy constructor
+available.<br/>
+This can lead to surprising results due to some idiosyncrasies of the standard
+mainly related to the need to guarantee backward compatibility.
+
+For example, `std::vector` defines a copy constructor no matter if its value
+type is copyable or not. As a result, `std::is_copy_constructible_v` is true
+for the following specialization:
+
+```cpp
+struct type {
+    std::vector<std::unique_ptr<action>> vec;
+};
+```
+
+When trying to assign an instance of this type to an entity in the ECS part,
+this may trigger a compilation error because we cannot really make a copy of
+it.<br/>
+As a workaround, users can mark the type explicitly as non-copyable:
+
+```cpp
+struct type {
+    type(const type &) = delete;
+    type & operator=(const type &) = delete;
+
+    std::vector<std::unique_ptr<action>> vec;
+};
+```
+
+Unfortunately, this will also disable aggregate initialization.

docs/md/lib.md

@@ -5,151 +5,132 @@
 -->
 # Table of Contents
 
-* [Introduction](#introduction)
-* [Named types and traits class](#named-types-and-traits-class)
-  * [Do not mix types](#do-not-mix-types)
-* [Macros, macros everywhere](#macros-macros-everywhere)
-  * [Conflicts](#conflicts)
-* [Allocations: the dark side of the force](#allocations-the-dark-side-of-the-force)
+* [Working across boundaries](#working-across-boundaries)
+  * [The EnTT way](#the-entt-way)
+  * [Meta context](#meta-context)
+  * [Memory management](#memory-management)
 <!--
 @endcond TURN_OFF_DOXYGEN
 -->
 
-# Introduction
+# 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 is due mainly to a custom utility used to assign unique, sequential
-identifiers to different types. Unfortunately, this tool is used by several core
-classes (the `registry` among the others) that are thus almost unusable across
-boundaries.<br/>
-The reasons for that are beyond the purposes of this document. However, the good
-news is that `EnTT` also offers now a way to overcome this limit and to push
-things across boundaries without problems when needed.
+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 straightforward. In
+fact, everything just works transparently in almost all cases. There are only a
+few exceptions, easy to deal with anyway.
 
-# Named types and traits class
+## The EnTT way
 
-To allow a type to work properly across boundaries when used by a class that
-requires to assign unique identifiers to types, users must specialize a class
-template to literally give a compile-time name to the type itself.<br/>
-The name of the class template is `name_type_traits` and the specialization must
-be such that it exposes a static constexpr data member named `value` having type
-either `ENTT_ID_TYPE` or `entt::hashed_string::hash_type`. Its value is the user
-defined unique identifier assigned to the specific type.<br/>
-Identifiers are not to be sequentially generated in this case.
+Many classes in `EnTT` make extensive use of type erasure for their purposes.
+This isn't a problem in 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_info` class template is how identifiers are generated and thus made
+available to the rest of the library. The `type_index` class template makes all
+types _indexable_ instead, so as to speed up the lookup.
 
-As an example:
+In general, these classes don't arouse much interest. The only exceptions are:
+
+* 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 problem in a concise and elegant way. Please refer to the specific
+  documentation.
+
+* When working with linked libraries that also export all required symbols.<br/>
+  Compile definitions `ENTT_API_EXPORT` and `ENTT_API_IMPORT` should be passed
+  respectively where there is a need to import or export the symbols defined by
+  `EnTT`, so as to make everything work nicely across boundaries.
+
+* When working with plugins or shared libraries that don't export any symbol. In
+  this case, `type_index` confuses the other classes by giving potentially wrong
+  information to them.<br/>
+  To avoid problems, it's required to provide a custom generator or to suppress
+  the index generation as a whole:
+
+  ```cpp
+  template<typename Type>
+  struct entt::type_index<Type> {};
+  ```
+
+  All classes that use `type_index` perform also a check on the possibility of
+  creating indexes for types. If it's not a viable solution, they fallback on
+  the type id provided by `type_info`. The latter makes everything stable across
+  boundaries.<br/>
+  This is why suppressing the generation of the indexes solves the problem. In
+  case it's still necessary to associate sequential indexes with types, users
+  can refer to the `family` class, although knowing that these will not be
+  stable across boundaries.
+
+For anyone who needs more details, the test suite contains multiple examples
+covering the most common cases.<br/>
+It goes without saying that it's impossible to cover all the 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 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
-struct my_type { /* ... */ };
-
-template<>
-struct entt::named_type_traits<my_type> {
-    static constexpr auto value = "my_type"_hs;
-};
+entt::meta_ctx ctx{};
 ```
 
-Because of the rules of the language, the specialization must reside in the
-global namespace or in the `entt` namespace. There is no way to change this rule
-unfortunately, because it doesn't depend on the library itself.
-
-The good aspect of this approach is that it's not intrusive at all. The other
-way around was in fact forcing users to inherit all their classes from a common
-base. Something to avoid, at least from my point of view.<br/>
-However, despite the fact that it's not intrusive, it would be great if it was
-also easier to use and a bit less error-prone. This is why a bunch of macros
-exist to ease defining named types.
-
-## Do not mix types
-
-Someone might think that this trick is valid only for the types to push across
-boundaries. This isn't how things work. In fact, the problem is more complex
-than that.<br/>
-As a rule of thumb, users should never mix named and non-named types. Whenever
-a type is given a name, all the types must be given a name. As an example,
-consider the `registry` class template: in case it is pushed across boundaries,
-all the types of components should be assigned a name to avoid subtle bugs.
-
-Indeed, this constraint can be relaxed in many cases. However, it is difficult
-to define a general rule to follow that is not the most stringent, unless users
-know exactly what they are doing. Therefore, I won't elaborate on giving further
-details on the topic.
-
-# Macros, macros everywhere
-
-The library comes with a set of predefined macros to use to declare named types
-or export already existing ones. In particular:
-
-* `ENTT_NAMED_TYPE` can be used to assign a name to already existing types. This
-  macro must be used in the global namespace even when the types to be named are
-  not.
-
-  ```cpp
-  ENTT_NAMED_TYPE(my_type)
-  ENTT_NAMED_TYPE(ns::another_type)
-  ```
-
-* `ENTT_NAMED_STRUCT` can be used to define and export a struct at the same
-  time. It accepts also an optional namespace in which to define the given type.
-  This macro must be used in the global namespace.
-
-  ```cpp
-  ENTT_NAMED_STRUCT(my_type, { /* struct definition */})
-  ENTT_NAMED_STRUCT(ns, another_type, { /* struct definition */})
-  ```
-
-* `ENTT_NAMED_CLASS` can be used to define and export a class at the same
-  time. It accepts also an optional namespace in which to define the given type.
-  This macro must be used in the global namespace.
-
-  ```cpp
-  ENTT_NAMED_CLASS(my_type, { /* class definition */})
-  ENTT_NAMED_CLASS(ns, another_type, { /* class definition */})
-  ```
-
-Nested namespaces are supported out of the box as well in all cases. As an
-example:
+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_NAMED_STRUCT(nested::ns, my_type, { /* struct definition */})
+entt::meta_ctx::bind(ctx);
 ```
 
-These macros can be used to avoid specializing the `named_type_traits` class
-template. In all cases, the name of the class is used also as a seed to generate
-the compile-time unique identifier.
+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:
 
-## Conflicts
+```cpp
+entt::meta_ctx::bind{entt::meta_ctx{});
+```
 
-When using macros, unique identifiers are 32/64 bit integers generated by
-hashing strings during compilation. Therefore, conflicts are rare but still
-possible. In case of conflicts, everything simply will get broken at runtime and
-the strangest things will probably take place.<br/>
-Unfortunately, there is no safe way to prevent it. If this happens, it will be
-enough to give a different value to one of the conflicting types to solve the
-problem. To do this, users can either assign a different name to the class or
-directly define a specialization for the `named_type_traits` class template.
+This is allowed because local and global contexts are separated. Therefore, it's
+always possible to make the local context the current one again.
 
-# Allocations: the dark side of the force
+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.
 
-As long as `EnTT` won't support custom allocators, another problem with
-allocations will remain alive instead. This is in fact easily solved, or at
-least it is if one knows it.
+## Memory Management
 
-To allow users to add types dynamically, the library makes extensive use of type
-erasure techniques and dynamic allocations for pools (whether they are for
-components, events or anything else). The problem occurs when, for example, a
-registry is created on one side of a boundary and a pool is dynamically created
-on the other side. In the best case, everything will crash at the exit, while at
-worst it will do so at runtime.<br/>
-To avoid problems, the pools must be generated from the same side of the
-boundary where the object that owns them is also created. As an example, when
-the registry is created in the main executable and used across boundaries for a
-given type of component, the pool for that type must be created before passing
-around the registry itself. To do this is fortunately quite easy, since it is
-sufficient to invoke any of the methods that involve the given type (continuing
-the example with the registry, a call to `reserve` or `size` is more than
-enough).
+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.
 
-Maybe one day some dedicated methods will be added that do nothing but create a
-pool for a given type. Until now it has been preferred to keep the API cleaner
-as they are not strictly necessary.
+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

@@ -17,6 +17,10 @@ I hope this list can grow much more in the future:
   * [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.
+  * [Land of the Rair](https://github.com/LandOfTheRair/core2): the new backend
+    of [a retro-style MUD](https://rair.land/) for the new age.
+  * [Openblack](https://github.com/openblack/openblack): open source
+    reimplementation of the game _Black & White_ (2001).
   * [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
@@ -40,8 +44,18 @@ I hope this list can grow much more in the future:
     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++.
 
 * Engines and the like:
+  * [Fling Engine](https://github.com/flingengine/FlingEngine): a Vulkan game
+    engine with a focus on data oriented design.
   * [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
@@ -52,14 +66,22 @@ I hope this list can grow much more in the future:
     [Qub3d](https://qub3d.org/): because blocks should be open source.
   * [shiva](https://github.com/Milerius/shiva): modern C++ engine with
     modularity.
-  * [NovusCore](https://github.com/novuscore/NovusCore): A modern take on World
+  * [NovusCore](https://github.com/novuscore/NovusCore): a modern take on World
     of Warcraft emulation.
   * [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
+    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.
+  * [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.
 
-* Articles and blog posts
+* Articles 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.
@@ -73,23 +95,42 @@ I hope this list can grow much more in the future:
     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 about the process followed and the results of the integration
+    of `EnTT` into `Chrysalis`.
+  * [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)).
 
 * Any Other Business:
-  * The [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
+  * [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.
   * [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`).
+  * [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

docs/md/meta.md

@@ -32,7 +32,7 @@ which it belongs and not vice versa.
 
 # Names and identifiers
 
-The meta system doesn't force the user to use the tools provided by the library
+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/>
@@ -46,13 +46,13 @@ identifier is required, it's likely that a user defined literal is used as
 follows:
 
 ```cpp
-auto factory = entt::reflect<my_type>("reflected_type"_hs);
+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::reflect<my_type>(42);
+auto factory = entt::meta<my_type>().type(42);
 ```
 
 Obviously, human-readable identifiers are more convenient to use and highly
@@ -63,23 +63,36 @@ recommended.
 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 _reflect_ a type, the library provides the `reflect` function:
+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::reflect<my_type>("reflected_type"_hs);
+auto factory = entt::meta<my_type>();
 ```
 
-It accepts the type to reflect as a template parameter and an optional
-identifier as an argument. Identifiers are important because users can retrieve
-meta types at runtime by searching for them by _name_. However, 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 allow searching the type by _name_.<br/>
-In both cases, the returned value is a factory object to use to continue
-building the meta 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:
 
-A factory is such that all its member functions returns the factory itself.
-It can be used to extend the reflected type and add the following:
+```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 returns 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
@@ -89,7 +102,7 @@ It can be used to extend the reflected type and add the following:
   Use the `ctor` member function for this purpose:
 
   ```cpp
-  entt::reflect<my_type>("reflected"_hs).ctor<int, char>().ctor<&factory>();
+  entt::meta<my_type>().ctor<int, char>().ctor<&factory>();
   ```
 
 * _Destructors_. Free functions can be set as destructors of reflected types.
@@ -98,7 +111,7 @@ It can be used to extend the reflected type and add the following:
   Use the `dtor` member function for this purpose:
 
   ```cpp
-  entt::reflect<my_type>("reflected"_hs).dtor<&destroy>();
+  entt::meta<my_type>().dtor<&destroy>();
   ```
 
   A function should neither delete nor explicitly invoke the destructor of a
@@ -111,7 +124,7 @@ It can be used to extend the reflected type and add the following:
   Use the `data` member function for this purpose:
 
   ```cpp
-  entt::reflect<my_type>("reflected"_hs)
+  entt::meta<my_type>()
       .data<&my_type::static_variable>("static"_hs)
       .data<&my_type::data_member>("member"_hs)
       .data<&global_variable>("global"_hs);
@@ -132,7 +145,7 @@ It can be used to extend the reflected type and add the following:
   Use the `func` member function for this purpose:
 
   ```cpp
-  entt::reflect<my_type>("reflected"_hs)
+  entt::meta<my_type>()
       .func<&my_type::static_function>("static"_hs)
       .func<&my_type::member_function>("member"_hs)
       .func<&free_function>("free"_hs);
@@ -148,7 +161,7 @@ It can be used to extend the reflected type and add the following:
   Use the `base` member function for this purpose:
 
   ```cpp
-  entt::reflect<derived_type>("derived"_hs).base<base_type>();
+  entt::meta<derived_type>().base<base_type>();
   ```
 
   From now on, wherever a `base_type` is required, an instance of `derived_type`
@@ -161,7 +174,7 @@ It can be used to extend the reflected type and add the following:
   Use the `conv` member function for this purpose:
 
   ```cpp
-  entt::reflect<double>().conv<int>();
+  entt::meta<double>().conv<int>();
   ```
 
 That's all, everything users need to create meta types and enjoy the reflection
@@ -173,7 +186,7 @@ definitely worth the price, at least for me.
 
 ## Any as in any type
 
-The reflection system comes with its own meta any type. It may seem redundant
+The reflection system comes with its own `meta_any` type. It may seem redundant
 since C++17 introduced `std::any`, but it is not.<br/>
 In fact, 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
@@ -181,39 +194,73 @@ wants to see in a software. Furthermore, the class `std::type_info` suffers from
 some design flaws and there is even no way to _convert_ an `std::type_info` into
 a meta type, thus linking the two worlds.
 
-A meta any object provides an API similar to that of its most famous counterpart
-and serves the same purpose of being an opaque container for any type of
-value.<br/>
+The class `meta_any` offers an API similar to that of its most famous
+counterpart and serves the same purpose of being an opaque container for any
+type of value.<br/>
 It minimizes the allocations required, which are almost absent thanks to _SBO_
 techniques. In fact, unless users deal with _fat types_ and create instances of
-them though the reflection system, allocations are at zero.
+them through the reflection system, allocations are at zero.
 
-A meta any object can be created by any other object or as an empty container
-to initialize later:
+Creating instances of `meta_any`, whether empty or from existing objects, is
+trivial:
 
 ```cpp
-// a meta any object that contains an int
+// a container for an int
 entt::meta_any any{0};
 
-// an empty meta any object
+// an empty container
 entt::meta_any empty{};
 ```
 
-It takes the burden of destroying the contained instance when required.<br/>
-Moreover, it can be used as an opaque container for unmanaged objects if needed:
+The `meta_any` class takes also the burden of destroying the contained object
+when required.<br/>
+Furthermore, an instance of `meta_any` is not tied to a specific type.
+Therefore, the wrapper will be reconfigured by assigning it an object of a
+different type than the one contained, so as to be able to handle the new
+instance.
+
+A particularly interesting feature of this class is that it can also be used as
+an opaque container for unmanaged objects:
 
 ```cpp
 int value;
-entt::meta_any any{entt::as_alias, value};
+entt::meta_any any{std::ref(value)};
 ```
 
-In this case, the contained instance is never destroyed and users must ensure
-that the lifetime of the object exceeds that of the container.
+In other words, whenever `meta_any` intercepts a `reference_wrapper`, it acts as
+a reference to the original instance rather than making a copy of it. The
+contained object is never destroyed and users must ensure that its lifetime
+exceeds that of the container.<br/>
+Similarly, to create a copy that works as a _light_ reference for the managed
+object, it's possible to _dereference_ a given `meta_any` so as to invoke its
+aliasing constructor:
 
-A meta any object has a `type` member function that returns the meta type of the
-contained value, if any. The member functions `try_cast`, `cast` and `convert`
-are used to know if the underlying object has a given type as a base or if it
-can be converted implicitly to it.
+```cpp
+// aliasing constructor
+entt::meta_any ref = any.ref();
+```
+
+This is also equivalent to:
+
+```cpp
+// indirection operator
+entt::meta_any ref = *any;
+```
+
+In both cases, it doesn't matter if the starting container actually holds an
+object or acts 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/>
+It means that, starting from the example above, both `ref` and` any` will point
+to the same object, whether it's initially contained in `any` or already an
+unmanaged one. This is particularly useful for passing instances of `meta_any`
+belonging to the external context by reference to a function or a constructor
+rather than making copies of them.
+
+The `meta_any` class has also a `type` member function that returns the meta
+type of the contained value, if any. The member functions `try_cast`, `cast` and
+`convert` are then used to know if the underlying object has a given type as a
+base or if it can be converted implicitly to it.
 
 ## Enjoy the runtime
 
@@ -223,30 +270,35 @@ All this has the great merit that, unlike the vast majority of the things
 present in this library and closely linked to the compile-time, the reflection
 system stands in fact as a non-intrusive tool for the runtime.
 
-To search for a reflected type there are two options: by type or by _name_. In
-both cases, the search can be done by means of the `resolve` function:
+To search for a reflected type there are a few options:
 
 ```cpp
-// search for a reflected type by type
+// direct access to a reflected type
 auto by_type = entt::resolve<my_type>();
 
-// search for a reflected type by name
-auto by_name = entt::resolve("reflected_type"_hs);
+// lookup of a reflected type by identifier
+auto by_id = entt::resolve_id("reflected_type"_hs);
+
+// lookup of a reflected type by type id
+auto by_type_id = entt::resolve_type(entt::type_info<my_type>::id());
 ```
 
-There exits also a third overload of the `resolve` function to use to iterate
-all the reflected types at once:
+There exits also an overload of the `resolve` function to use to iterate all the
+reflected types at once as well as a `resolve_if` function to use to perform
+more refined searches when needed:
 
 ```cpp
 resolve([](auto type) {
     // ...
 });
+
+auto by_lookup = resolve_if([](auto type) { return type.is_floating_point(); });
 ```
 
-In all cases, the returned value is an instance of `meta_type`. This type of
-objects offer an API to know the _runtime identifier_ of the type, to iterate
-all the meta objects associated with them and even to build or destroy instances
-of the underlying type.<br/>
+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:
@@ -260,20 +312,9 @@ The meta objects that compose a meta type are accessed in the following ways:
   The returned type is `meta_ctor` and may be invalid if there is no constructor
   that accepts the supplied arguments or at least some types from which they are
   derived or to which they can be converted.<br/>
-  A meta constructor offers an API to know the number of arguments, the expected
-  meta types and to invoke it, therefore to construct a new instance of the
-  underlying type.
-
-* _Meta destructor_. It's returned by a dedicated function:
-
-  ```cpp
-  auto dtor = entt::resolve<my_type>().dtor();
-  ```
-
-  The returned type is `meta_dtor` and may be invalid if there is no custom
-  destructor set for the given meta type.<br/>
-  All what a meta destructor has to offer is a way to invoke it on a given
-  instance. Be aware that the result may not be what is expected.
+  A meta constructor offers an API to know the number of its arguments and their
+  expected meta types. Furthermor, it's possible to invoke it and therefore to
+  construct new instances of the underlying type.
 
 * _Meta data_. They are accessed by _name_:
 
@@ -283,9 +324,9 @@ The meta objects that compose a meta type are accessed in the following ways:
 
   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 (ie 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.
+  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_:
 
@@ -295,11 +336,11 @@ The meta objects that compose a meta type are accessed in the following ways:
 
   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 (ie 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 meta any object.
+  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:
 
@@ -323,23 +364,20 @@ The meta objects that compose a meta type are accessed in the following ways:
   conversion function associated with the given type.<br/>
   The meta conversion functions are as thin as the meta bases and with a very
   similar interface. The sole difference is that they return a newly created
-  instance wrapped in a meta any object when they convert between different
+  instance wrapped in a `meta_any` object when they convert between different
   types.
 
 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
-auto func = entt::resolve<my_type>().func("member"_hs);
-
-if(func) {
+if(auto func = entt::resolve<my_type>().func("member"_hs); func) {
     // ...
 }
 ```
 
-Furthermore, all meta objects with the exception of meta destructors can be
-iterated through an overload that accepts a callback through which to return
-them. As an example:
+Furthermore, all meta objects can be iterated through an overload that accepts a
+callback through which to return them. As an example:
 
 ```cpp
 entt::resolve<my_type>().data([](auto data) {
@@ -347,23 +385,26 @@ entt::resolve<my_type>().data([](auto data) {
 });
 ```
 
-A meta type can also be used to `construct` or `destroy` actual instances of the
-underlying type.<br/>
+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 returns a `meta_any` object that may or
-may not be initialized, depending on whether a suitable constructor has been
-found or not. On the other side, the `destroy` member function accepts instances
-of `meta_any` as well as actual objects by reference and invokes the registered
-destructor if any.<br/>
-Be aware that the result of a call to `destroy` may not be what is expected. The
-purpose is to give users the ability to free up resources that require special
-treatment and **not** to actually destroy instances.
+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. The reason is quickly explained: 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/>
+Therefore, exposing destructors would be pointless and would add nothing to the
+library itself.
 
 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 official documentation to get the best out of this powerful tool.
+read the inline documentation to get the best out of this powerful tool.
 
 ## Policies: the more, the less
 
@@ -391,21 +432,19 @@ There are a few alternatives available at the moment:
   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.
+  In the second case, instead, the property will not be accessible for reading.
 
   As an example of use:
 
   ```cpp
-  entt::reflect<my_type>("reflected"_hs)
-      .func<&my_type::member_function, entt::as_void_t>("member"_hs);
+  entt::meta<my_type>().func<&my_type::member_function, entt::as_void_t>("member"_hs);
   ```
 
-* The _as-alias_ policy, associated with the type `entt::as_alias_t`.<br/>
-  It allows to build wrappers that act as aliases for the objects used to
-  initialize them. Modifying the object contained in the wrapper for which the
-  _aliasing_ was requested will make it possible to directly modify the instance
-  used to initialize the wrapper itself.<br/>
+* The _as-ref_ policy, associated with the type `entt::as_ref_t`.<br/>
+  It allows to build wrappers that act as references to unmanaged objects.
+  Modifying the object contained in the wrapper for which the _reference_ was
+  requested will make it possible to directly modify the instance used to
+  initialize the wrapper itself.<br/>
   This policy works with constructors (for example, when objects are taken from
   an external container rather than created on demand), data members and
   functions in general (as long as their return types are lvalue references).
@@ -413,8 +452,7 @@ There are a few alternatives available at the moment:
   As an example of use:
 
   ```cpp
-  entt::reflect<my_type>("reflected"_hs)
-      .data<&my_type::data_member, entt::as_alias_t>("member"_hs);
+  entt::meta<my_type>().data<&my_type::data_member, entt::as_ref_t>("member"_hs);
   ```
 
 Some uses are rather trivial, but it's useful to note that there are some less
@@ -439,11 +477,11 @@ members of the reflected types.
 Exporting constant values or elements from an enum is as simple as ever:
 
 ```cpp
-entt::reflect<my_enum>()
+entt::meta<my_enum>()
         .data<my_enum::a_value>("a_value"_hs)
         .data<my_enum::another_value>("another_value"_hs);
 
-entt::reflect<int>().data<2048>("max_int"_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
@@ -455,29 +493,90 @@ 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
+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 be able to attach properties to the meta objects created. Fortunately, this
-is possible for most of them.<br/>
-To attach a property to a meta object, no matter what as long as it supports
-properties, it is sufficient to provide an object at the time of construction
-such that `std::get<0>` and `std::get<1>` are valid for it. In other terms, the
-properties are nothing more than key/value pairs users can put in an
-`std::pair`. As an example:
+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::reflect<my_type>("reflected"_hs, std::make_pair("tooltip"_hs, "message"));
+entt::meta<my_type>().type("reflected_type"_hs).prop("tooltip"_hs, "message");
 ```
 
-The meta objects that support properties offer then a couple of member functions
-named `prop` to iterate them at once and to search a specific property by key:
+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.
+
+* Annotations:
+
+  ```cpp
+  entt::meta<my_type>().type("reflected_type"_hs).prop(&property_generator);
+  ```
+
+  An annotation is an invocable object that returns one or more properties. All
+  of them are treated individually.
+
+It's possible to invoke the `prop` function several times if needed, one for
+each property to associate with the last meta object created:
 
 ```cpp
-// iterate all the properties of a meta type
+entt::meta<my_type>()
+    .type("reflected_type"_hs)
+        .prop(entt::hashed_string{"Name"}, "Reflected Type")
+    .data<&my_type::data_member>("member"_hs)
+        .prop(std::make_pair("tooltip"_hs, "Member"))
+        .prop(my_enum::a_value, 42);
+```
+
+Alternatively, the `props` function is available to associate several properties
+at a time. However, 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 the meta
+types, meta constructors, meta data and meta functions. It's not possible to
+attach properties to other types of meta objects and the factory returned as a
+result of their construction won't allow such an operation.
+
+These types 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
 entt::resolve<my_type>().prop([](auto prop) {
     // ...
 });
@@ -488,7 +587,7 @@ 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.
+the key and the value contained in the form of `meta_any` objects, respectively.
 
 ## Unregister types
 
@@ -497,15 +596,13 @@ means unregistering all its data members, member functions, conversion functions
 and so on. However, the base classes won't be unregistered, 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) won't
-be unregistered.
-
-To unregister a type, users can use the `unregister` function from the global
-namespace:
+be 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::unregister<my_type>();
+entt::meta<my_type>().reset();
 ```
 
-This function returns a boolean value that is true if the type is actually
-registered with the reflection system, false otherwise.<br/>
 The type can be re-registered later with a completely different name and form.

docs/md/process.md

@@ -74,6 +74,10 @@ Here is a minimal example for the sake of curiosity:
 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);
 
@@ -85,7 +89,7 @@ struct my_process: entt::process<my_process, std::uint32_t> {
     }
 
 private:
-    delta_type remaining{1000u};
+    delta_type remaining;
 };
 ```
 
@@ -158,7 +162,7 @@ To attach a process to a scheduler there are mainly two ways:
   the `attach` member function:
 
   ```cpp
-  scheduler.attach<my_process>("foobar");
+  scheduler.attach<my_process>(1000u);
   ```
 
 * Otherwise, in case of a lambda or a functor, it's enough to provide an
@@ -182,7 +186,7 @@ scheduler.attach([](auto delta, void *, auto succeed, auto fail) {
     // ...
 })
 // appends a child in the form of a process class
-.then<my_process>();
+.then<my_process>(1000u);
 ```
 
 To update a scheduler and therefore all its processes, the `update` member

docs/md/references.md

@@ -0,0 +1,42 @@
+# 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:
+  * [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.
+
+* Javascript:
+  * [ecsy](https://github.com/MozillaReality/ecsy): I haven't had the time to
+    investigate the underlying design of `ecsy` but it looks cool anyway.
+
+* 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.
+  * [Specs](https://github.com/amethyst/specs): a parallel ECS based mainly on
+    hierarchical bitsets that allows different types of storage as needed.
+
+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

@@ -45,7 +45,7 @@ A _loader_ is a class the aim of which is to load a specific resource. It has to
 inherit directly from the dedicated base class as in the following example:
 
 ```cpp
-struct my_loader final: entt::resource_loader<my_loader, my_resource> {
+struct my_loader final: entt::loader<my_loader, my_resource> {
     // ...
 };
 ```
@@ -57,7 +57,7 @@ resource.<br/>
 As an example:
 
 ```cpp
-struct my_loader: entt::resource_loader<my_loader, my_resource> {
+struct my_loader: entt::loader<my_loader, my_resource> {
     std::shared_ptr<my_resource> load(int value) const {
         // ...
         return std::shared_ptr<my_resource>(new my_resource{ value });
@@ -76,11 +76,11 @@ Finally, a cache is a specialization of a class template tailored to a specific
 resource:
 
 ```cpp
-using my_resource_cache = entt::resource_cache<my_resource>;
+using my_cache = entt::cache<my_resource>;
 
 // ...
 
-my_resource_cache cache{};
+my_cache cache{};
 ```
 
 The idea is to create different caches for different types of resources and to
@@ -105,19 +105,12 @@ cache.clear();
 
 Besides these member functions, a cache contains what is needed to load, use and
 discard resources of the given type.<br/>
-Before to explore this part of the interface, it makes sense to mention how
-resources are identified. The type of the identifiers to use is defined as:
+Before exploring this part of the interface, it makes sense to mention how
+resources are identified. They have type `id_type` and therefore they can be
+created explicitly as in the following example:
 
 ```cpp
-entt::resource_cache<resource>::resource_type
-```
-
-Where `resource_type` is an alias for `entt::hashed_string::hash_type`.
-Therefore, resource identifiers are created explicitly as in the following
-example:
-
-```cpp
-constexpr auto identifier = entt::resource_cache<resource>::resource_type{"my/resource/identifier"_hs};
+constexpr auto identifier = "my/resource/identifier"_hs;
 // this is equivalent to the following
 constexpr auto hs = entt::hashed_string{"my/resource/identifier"};
 ```

docs/md/signal.md

@@ -37,7 +37,7 @@ lightweight classes to solve the same and many other problems.
 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 does not claim to be a drop-in replacement for an `std::function`, so do not
+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.
@@ -79,9 +79,9 @@ 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. In this case, `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:
+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) { /* ... */ }
@@ -107,7 +107,7 @@ 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/>v
+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.
 
@@ -142,6 +142,24 @@ 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, note that members of a class 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:
+
+```
+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.
+
 # Signals
 
 Signal handlers work with references to classes, function pointers and pointers
@@ -158,11 +176,10 @@ _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. The most important thing is that
-it comes in two forms: with and without a collector. In case a signal is
-provided with a collector, all the values returned by the listeners can be
-literally _collected_ and used later by the caller. Otherwise it works just like
-a plain signal that emits events from time to time.<br/>
+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:
 
@@ -200,10 +217,10 @@ sink.disconnect<&foo>();
 // disconnect a member function of an instance
 sink.disconnect<&listener::bar>(instance);
 
-// disconnect all the member functions of an instance, if any
+// disconnect all member functions of an instance, if any
 sink.disconnect(instance);
 
-// discards all the listeners at once
+// discards all listeners at once
 sink.disconnect();
 ```
 
@@ -211,10 +228,20 @@ 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/>
-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.
+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`

scripts/update_homebrew.sh

@@ -41,14 +41,14 @@ echo "Sedding..."
 
 # change the url in the formula file
 # the slashes in the URL must be escaped
-ESCAPED_URL="$(sed -e 's/[\/&]/\\&/g' <<< "$URL")"
+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 "$FORMULA-e"
+rm -rf "$FORMULA-e"
 
 # update remote repo
 echo "Gitting..."

scripts/update_packages.sh

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

src/entt/config/config.h

@@ -3,45 +3,67 @@
 
 
 #ifndef ENTT_NOEXCEPT
-#define ENTT_NOEXCEPT noexcept
-#endif // ENTT_NOEXCEPT
+#   define ENTT_NOEXCEPT noexcept
+#endif
 
 
 #ifndef ENTT_HS_SUFFIX
-#define ENTT_HS_SUFFIX _hs
-#endif // ENTT_HS_SUFFIX
+#   define ENTT_HS_SUFFIX _hs
+#endif
 
 
 #ifndef ENTT_HWS_SUFFIX
-#define ENTT_HWS_SUFFIX _hws
-#endif // ENTT_HWS_SUFFIX
+#   define ENTT_HWS_SUFFIX _hws
+#endif
 
 
-#ifndef ENTT_NO_ATOMIC
-#include <atomic>
-#define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
-#else // ENTT_NO_ATOMIC
-#define ENTT_MAYBE_ATOMIC(Type) Type
-#endif // ENTT_NO_ATOMIC
+#ifndef ENTT_USE_ATOMIC
+#   define ENTT_MAYBE_ATOMIC(Type) Type
+#else
+#   include <atomic>
+#   define ENTT_MAYBE_ATOMIC(Type) std::atomic<Type>
+#endif
 
 
 #ifndef ENTT_ID_TYPE
-#include <cstdint>
-#define ENTT_ID_TYPE std::uint32_t
-#endif // ENTT_ID_TYPE
+#   include <cstdint>
+#   define ENTT_ID_TYPE std::uint32_t
+#endif
 
 
 #ifndef ENTT_PAGE_SIZE
-#define ENTT_PAGE_SIZE 32768
-#endif // ENTT_PAGE_SIZE
+#   define ENTT_PAGE_SIZE 32768
+#endif
 
 
-#ifndef ENTT_DISABLE_ASSERT
-#include <cassert>
-#define ENTT_ASSERT(condition) assert(condition)
-#else // ENTT_DISABLE_ASSERT
-#define ENTT_ASSERT(...) ((void)0)
-#endif // ENTT_DISABLE_ASSERT
+#ifndef ENTT_ASSERT
+#   include <cassert>
+#   define ENTT_ASSERT(condition) assert(condition)
+#endif
 
 
-#endif // ENTT_CONFIG_CONFIG_H
+#ifndef ENTT_NO_ETO
+#   include <type_traits>
+#   define ENTT_IS_EMPTY(Type) std::is_empty_v<Type>
+#else
+#   include <type_traits>
+#   // sfinae-friendly definition
+#   define ENTT_IS_EMPTY(Type) (false && std::is_empty_v<Type>)
+#endif
+
+
+#ifndef ENTT_STANDARD_CPP
+#   if defined _MSC_VER
+#      define ENTT_PRETTY_FUNCTION __FUNCSIG__
+#      define ENTT_PRETTY_FUNCTION_CONSTEXPR(...) constexpr
+#   elif defined __clang__ || (defined __GNUC__ && __GNUC__ > 8)
+#      define ENTT_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#      define ENTT_PRETTY_FUNCTION_CONSTEXPR(...) constexpr
+#   elif defined __GNUC__
+#      define ENTT_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#      define ENTT_PRETTY_FUNCTION_CONSTEXPR(...) __VA_ARGS__
+#   endif
+#endif
+
+
+#endif

src/entt/config/version.h

@@ -2,10 +2,9 @@
 #define ENTT_CONFIG_VERSION_H
 
 
-#define ENTT_VERSION "3.1.1"
 #define ENTT_VERSION_MAJOR 3
-#define ENTT_VERSION_MINOR 1
-#define ENTT_VERSION_PATCH 1
+#define ENTT_VERSION_MINOR 4
+#define ENTT_VERSION_PATCH 0
 
 
-#endif // ENTT_CONFIG_VERSION_H
+#endif

src/entt/core/algorithm.hpp

@@ -2,6 +2,7 @@
 #define ENTT_CORE_ALGORITHM_HPP
 
 
+#include <vector>
 #include <utility>
 #include <iterator>
 #include <algorithm>
@@ -140,4 +141,4 @@ struct radix_sort {
 }
 
 
-#endif // ENTT_CORE_ALGORITHM_HPP
+#endif

src/entt/core/attribute.h

@@ -0,0 +1,33 @@
+#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/family.hpp

@@ -2,8 +2,8 @@
 #define ENTT_CORE_FAMILY_HPP
 
 
-#include <type_traits>
 #include "../config/config.h"
+#include "fwd.hpp"
 
 
 namespace entt {
@@ -18,24 +18,20 @@ namespace entt {
  */
 template<typename...>
 class family {
-    inline static ENTT_MAYBE_ATOMIC(ENTT_ID_TYPE) identifier;
-
-    template<typename...>
-    // clang (since version 9) started to complain if auto is used instead of ENTT_ID_TYPE
-    inline static const ENTT_ID_TYPE inner = identifier++;
+    inline static ENTT_MAYBE_ATOMIC(id_type) identifier{};
 
 public:
     /*! @brief Unsigned integer type. */
-    using family_type = ENTT_ID_TYPE;
+    using family_type = id_type;
 
     /*! @brief Statically generated unique identifier for the given type. */
     template<typename... 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 = inner<std::decay_t<Type>...>;
+    inline static const family_type type = identifier++;
 };
 
 
 }
 
 
-#endif // ENTT_CORE_FAMILY_HPP
+#endif

src/entt/core/fwd.hpp

@@ -0,0 +1,18 @@
+#ifndef ENTT_CORE_FWD_HPP
+#define ENTT_CORE_FWD_HPP
+
+
+#include "../config/config.h"
+
+
+namespace entt {
+
+
+/*! @brief Alias declaration for type identifiers. */
+using id_type = ENTT_ID_TYPE;
+
+
+}
+
+
+#endif

src/entt/core/hashed_string.hpp

@@ -3,7 +3,9 @@
 
 
 #include <cstddef>
+#include <cstdint>
 #include "../config/config.h"
+#include "fwd.hpp"
 
 
 namespace entt {
@@ -24,6 +26,7 @@ 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;
 };
@@ -31,6 +34,7 @@ struct fnv1a_traits<std::uint32_t> {
 
 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;
 };
@@ -58,7 +62,7 @@ struct fnv1a_traits<std::uint64_t> {
  */
 template<typename Char>
 class basic_hashed_string {
-    using traits_type = internal::fnv1a_traits<ENTT_ID_TYPE>;
+    using traits_type = internal::fnv1a_traits<id_type>;
 
     struct const_wrapper {
         // non-explicit constructor on purpose
@@ -67,15 +71,21 @@ class basic_hashed_string {
     };
 
     // Fowler–Noll–Vo hash function v. 1a - the good
-    static constexpr ENTT_ID_TYPE helper(ENTT_ID_TYPE partial, const Char *curr) ENTT_NOEXCEPT {
-        return curr[0] == 0 ? partial : helper((partial^curr[0])*traits_type::prime, curr+1);
+    static constexpr id_type helper(const Char *curr) ENTT_NOEXCEPT {
+        auto value = traits_type::offset;
+
+        while(*curr != 0) {
+            value = (value ^ static_cast<traits_type::type>(*(curr++))) * traits_type::prime;
+        }
+
+        return value;
     }
 
 public:
     /*! @brief Character type. */
     using value_type = Char;
     /*! @brief Unsigned integer type. */
-    using hash_type = ENTT_ID_TYPE;
+    using hash_type = id_type;
 
     /**
      * @brief Returns directly the numeric representation of a string.
@@ -93,8 +103,8 @@ public:
      * @return The numeric representation of the string.
      */
     template<std::size_t N>
-    static constexpr hash_type to_value(const value_type (&str)[N]) ENTT_NOEXCEPT {
-        return helper(traits_type::offset, str);
+    static constexpr hash_type value(const value_type (&str)[N]) ENTT_NOEXCEPT {
+        return helper(str);
     }
 
     /**
@@ -102,8 +112,8 @@ public:
      * @param wrapper Helps achieving the purpose by relying on overloading.
      * @return The numeric representation of the string.
      */
-    static hash_type to_value(const_wrapper wrapper) ENTT_NOEXCEPT {
-        return helper(traits_type::offset, wrapper.str);
+    static hash_type value(const_wrapper wrapper) ENTT_NOEXCEPT {
+        return helper(wrapper.str);
     }
 
     /**
@@ -112,8 +122,8 @@ public:
      * @param size Length of the string to hash.
      * @return The numeric representation of the string.
      */
-    static hash_type to_value(const value_type *str, std::size_t size) ENTT_NOEXCEPT {
-        ENTT_ID_TYPE partial{traits_type::offset};
+    static hash_type value(const value_type *str, std::size_t size) ENTT_NOEXCEPT {
+        id_type partial{traits_type::offset};
         while(size--) { partial = (partial^(str++)[0])*traits_type::prime; }
         return partial;
     }
@@ -139,7 +149,7 @@ public:
      */
     template<std::size_t N>
     constexpr basic_hashed_string(const value_type (&curr)[N]) ENTT_NOEXCEPT
-        : str{curr}, hash{helper(traits_type::offset, curr)}
+        : str{curr}, hash{helper(curr)}
     {}
 
     /**
@@ -148,7 +158,7 @@ public:
      * @param wrapper Helps achieving the purpose by relying on overloading.
      */
     explicit constexpr basic_hashed_string(const_wrapper wrapper) ENTT_NOEXCEPT
-        : str{wrapper.str}, hash{helper(traits_type::offset, wrapper.str)}
+        : str{wrapper.str}, hash{helper(wrapper.str)}
     {}
 
     /**
@@ -167,14 +177,14 @@ public:
         return hash;
     }
 
-    /**
-     * @brief Returns the human-readable representation of a hashed string.
-     * @return The string used to initialize the instance.
-     */
-    constexpr operator const value_type *() const ENTT_NOEXCEPT { return str; }
+    /*! @copydoc data */
+    constexpr operator const value_type *() const ENTT_NOEXCEPT { return data(); }
 
-    /*! @copydoc value */
-    constexpr operator hash_type() const ENTT_NOEXCEPT { return hash; }
+    /**
+     * @brief Returns the numeric representation of a hashed string.
+     * @return The numeric representation of the instance.
+     */
+    constexpr operator hash_type() const ENTT_NOEXCEPT { return value(); }
 
     /**
      * @brief Compares two hashed strings.
@@ -250,4 +260,4 @@ constexpr entt::hashed_wstring operator"" ENTT_HWS_SUFFIX(const wchar_t *str, st
 }
 
 
-#endif // ENTT_CORE_HASHED_STRING_HPP
+#endif

src/entt/core/ident.hpp

@@ -3,9 +3,11 @@
 
 
 #include <tuple>
+#include <cstddef>
 #include <utility>
 #include <type_traits>
 #include "../config/config.h"
+#include "fwd.hpp"
 
 
 namespace entt {
@@ -43,22 +45,22 @@ class identifier {
     using tuple_type = std::tuple<std::decay_t<Types>...>;
 
     template<typename Type, std::size_t... Indexes>
-    static constexpr ENTT_ID_TYPE get(std::index_sequence<Indexes...>) ENTT_NOEXCEPT {
+    static constexpr id_type get(std::index_sequence<Indexes...>) {
         static_assert(std::disjunction_v<std::is_same<Type, Types>...>);
-        return (0 + ... + (std::is_same_v<Type, std::tuple_element_t<Indexes, tuple_type>> ? ENTT_ID_TYPE(Indexes) : ENTT_ID_TYPE{}));
+        return (0 + ... + (std::is_same_v<Type, std::tuple_element_t<Indexes, tuple_type>> ? id_type(Indexes) : id_type{}));
     }
 
 public:
     /*! @brief Unsigned integer type. */
-    using identifier_type = ENTT_ID_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::make_index_sequence<sizeof...(Types)>{});
+    static constexpr identifier_type type = get<std::decay_t<Type>>(std::index_sequence_for<Types...>{});
 };
 
 
 }
 
 
-#endif // ENTT_CORE_IDENT_HPP
+#endif

src/entt/core/monostate.hpp

@@ -2,8 +2,8 @@
 #define ENTT_CORE_MONOSTATE_HPP
 
 
-#include <cassert>
 #include "../config/config.h"
+#include "fwd.hpp"
 
 
 namespace entt {
@@ -20,7 +20,7 @@ namespace entt {
  * both during an assignment and when they try to read back their data.
  * Otherwise, they can incur in unexpected results.
  */
-template<ENTT_ID_TYPE>
+template<id_type>
 struct monostate {
     /**
      * @brief Assigns a value of a specific type to a given key.
@@ -52,11 +52,11 @@ private:
  * @brief Helper variable template.
  * @tparam Value Value used to differentiate between different variables.
  */
-template<ENTT_ID_TYPE Value>
+template<id_type Value>
 inline monostate<Value> monostate_v = {};
 
 
 }
 
 
-#endif // ENTT_CORE_MONOSTATE_HPP
+#endif

src/entt/core/type_info.hpp

@@ -0,0 +1,105 @@
+#ifndef ENTT_CORE_TYPE_INFO_HPP
+#define ENTT_CORE_TYPE_INFO_HPP
+
+
+#include "../config/config.h"
+#include "../core/attribute.h"
+#include "hashed_string.hpp"
+#include "fwd.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @cond TURN_OFF_DOXYGEN
+ * Internal details not to be documented.
+ */
+
+
+namespace internal {
+
+
+struct ENTT_API type_index {
+    static id_type next() ENTT_NOEXCEPT {
+        static ENTT_MAYBE_ATOMIC(id_type) value{};
+        return value++;
+    }
+};
+
+
+}
+
+
+/**
+ * Internal details not to be documented.
+ * @endcond TURN_OFF_DOXYGEN
+ */
+
+
+/**
+ * @brief Type index.
+ * @tparam Type Type for which to generate a sequential identifier.
+ */
+template<typename Type, typename = void>
+struct ENTT_API type_index {
+    /**
+     * @brief Returns the sequential identifier of a given type.
+     * @return The sequential identifier of a given type.
+     */
+    static id_type value() ENTT_NOEXCEPT {
+        static const id_type value = internal::type_index::next();
+        return value;
+    }
+};
+
+
+/**
+ * @brief Provides the member constant `value` to true if a given type is
+ * indexable, false otherwise.
+ * @tparam Type Potentially indexable type.
+ */
+template<typename, typename = void>
+struct has_type_index: std::false_type {};
+
+
+/*! @brief has_type_index */
+template<typename Type>
+struct has_type_index<Type, std::void_t<decltype(type_index<Type>::value())>>: std::true_type {};
+
+
+/**
+ * @brief Helper variable template.
+ * @tparam Type Potentially indexable type.
+ */
+template<typename Type>
+inline constexpr bool has_type_index_v = has_type_index<Type>::value;
+
+
+/**
+ * @brief Type info.
+ * @tparam Type Type for which to generate information.
+ */
+template<typename Type, typename = void>
+struct ENTT_API type_info {
+    /**
+     * @brief Returns the numeric representation of a given type.
+     * @return The numeric representation of the given type.
+     */
+#if defined ENTT_PRETTY_FUNCTION
+    static ENTT_PRETTY_FUNCTION_CONSTEXPR() id_type id() ENTT_NOEXCEPT {
+        ENTT_PRETTY_FUNCTION_CONSTEXPR(static const) auto value = entt::hashed_string::value(ENTT_PRETTY_FUNCTION);
+        return value;
+    }
+#else
+    static id_type id() ENTT_NOEXCEPT {
+        return type_index<Type>::value();
+    }
+#endif
+};
+
+
+}
+
+
+#endif

src/entt/core/type_traits.hpp

@@ -2,14 +2,59 @@
 #define ENTT_CORE_TYPE_TRAITS_HPP
 
 
+#include <cstddef>
+#include <utility>
 #include <type_traits>
 #include "../config/config.h"
-#include "../core/hashed_string.hpp"
+#include "hashed_string.hpp"
+#include "fwd.hpp"
 
 
 namespace entt {
 
 
+/**
+ * @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 ease 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 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 TURN_OFF_DOXYGEN */
+{};
+
+
+/*! @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 A class to use to push around lists of types, nothing more. */
 template<typename...>
 struct type_list {};
@@ -35,7 +80,7 @@ struct type_list_size<type_list<Type...>>
  * @tparam List Type list.
  */
 template<class List>
-constexpr auto type_list_size_v = type_list_size<List>::value;
+inline constexpr auto type_list_size_v = type_list_size<List>::value;
 
 
 /*! @brief Primary template isn't defined on purpose. */
@@ -120,52 +165,60 @@ template<typename Type>
 using type_list_unique_t = typename type_list_unique<Type>::type;
 
 
-/*! @brief Traits class used mainly to push things across boundaries. */
-template<typename>
-struct named_type_traits;
-
-
 /**
- * @brief Specialization used to get rid of constness.
- * @tparam Type Named type.
+ * @brief Provides the member constant `value` to true if a given type is
+ * equality comparable, false otherwise.
+ * @tparam Type Potentially equality comparable type.
  */
+template<typename Type, typename = std::void_t<>>
+struct is_equality_comparable: std::false_type {};
+
+
+/*! @copydoc is_equality_comparable */
 template<typename Type>
-struct named_type_traits<const Type>
-        : named_type_traits<Type>
-{};
-
-
-/**
- * @brief Helper type.
- * @tparam Type Potentially named type.
- */
-template<typename Type>
-using named_type_traits_t = typename named_type_traits<Type>::type;
-
-
-/**
- * @brief Provides the member constant `value` to true if a given type has a
- * name. In all other cases, `value` is false.
- */
-template<typename, typename = std::void_t<>>
-struct is_named_type: std::false_type {};
-
-
-/**
- * @brief Provides the member constant `value` to true if a given type has a
- * name. In all other cases, `value` is false.
- * @tparam Type Potentially named type.
- */
-template<typename Type>
-struct is_named_type<Type, std::void_t<named_type_traits_t<std::decay_t<Type>>>>: std::true_type {};
+struct is_equality_comparable<Type, std::void_t<decltype(std::declval<Type>() == std::declval<Type>())>>: std::true_type {};
 
 
 /**
  * @brief Helper variable template.
- * @tparam Type Potentially named type.
+ * @tparam Type Potentially equality comparable type.
  */
 template<class Type>
-constexpr auto is_named_type_v = is_named_type<Type>::value;
+inline constexpr auto is_equality_comparable_v = is_equality_comparable<Type>::value;
+
+
+/**
+ * @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>);
+
+    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;
+
+
+}
 
 
 /**
@@ -176,102 +229,10 @@ constexpr auto is_named_type_v = is_named_type<Type>::value;
  */
 #define ENTT_OPAQUE_TYPE(clazz, type)\
     enum class clazz: type {};\
-    constexpr auto to_integer(const clazz id) ENTT_NOEXCEPT {\
-        return std::underlying_type_t<clazz>(id);\
-    }
+    constexpr auto to_integral(const clazz id) ENTT_NOEXCEPT {\
+        return static_cast<std::underlying_type_t<clazz>>(id);\
+    }\
+    static_assert(true)
 
 
-}
-
-
-/**
- * @brief Utility macro to deal with an issue of MSVC.
- *
- * See _msvc-doesnt-expand-va-args-correctly_ on SO for all the details.
- *
- * @param args Argument to expand.
- */
-#define ENTT_EXPAND(args) args
-
-
-/**
- * @brief Makes an already existing type a named type.
- *
- * The current definition contains a workaround for Clang 6 because it fails to
- * deduce correctly the type to use to specialize the class template.<br/>
- * With a compiler that fully supports C++17 and works fine with deduction
- * guides, the following should be fine instead:
- *
- * @code{.cpp}
- * std::integral_constant<ENTT_ID_TYPE, entt::basic_hashed_string{#type}>
- * @endcode
- *
- * In order to support even sligthly older compilers, I prefer to stick to the
- * implementation below.
- *
- * @param type Type to assign a name to.
- */
-#define ENTT_NAMED_TYPE(type)\
-    template<>\
-    struct entt::named_type_traits<type>\
-        : std::integral_constant<ENTT_ID_TYPE, entt::basic_hashed_string<std::remove_cv_t<std::remove_pointer_t<std::decay_t<decltype(#type)>>>>{#type}>\
-    {\
-        static_assert(std::is_same_v<std::decay_t<type>, type>);\
-    };
-
-
-/**
- * @brief Defines a named type (to use for structs).
- * @param clazz Name of the type to define.
- * @param body Body of the type to define.
- */
-#define ENTT_NAMED_STRUCT_ONLY(clazz, body)\
-    struct clazz body;\
-    ENTT_NAMED_TYPE(clazz)
-
-
-/**
- * @brief Defines a named type (to use for structs).
- * @param ns Namespace where to define the named type.
- * @param clazz Name of the type to define.
- * @param body Body of the type to define.
- */
-#define ENTT_NAMED_STRUCT_WITH_NAMESPACE(ns, clazz, body)\
-    namespace ns { struct clazz body; }\
-    ENTT_NAMED_TYPE(ns::clazz)
-
-
-/*! @brief Utility function to simulate macro overloading. */
-#define ENTT_NAMED_STRUCT_OVERLOAD(_1, _2, _3, FUNC, ...) FUNC
-/*! @brief Defines a named type (to use for structs). */
-#define ENTT_NAMED_STRUCT(...) ENTT_EXPAND(ENTT_NAMED_STRUCT_OVERLOAD(__VA_ARGS__, ENTT_NAMED_STRUCT_WITH_NAMESPACE, ENTT_NAMED_STRUCT_ONLY,)(__VA_ARGS__))
-
-
-/**
- * @brief Defines a named type (to use for classes).
- * @param clazz Name of the type to define.
- * @param body Body of the type to define.
- */
-#define ENTT_NAMED_CLASS_ONLY(clazz, body)\
-    class clazz body;\
-    ENTT_NAMED_TYPE(clazz)
-
-
-/**
- * @brief Defines a named type (to use for classes).
- * @param ns Namespace where to define the named type.
- * @param clazz Name of the type to define.
- * @param body Body of the type to define.
- */
-#define ENTT_NAMED_CLASS_WITH_NAMESPACE(ns, clazz, body)\
-    namespace ns { class clazz body; }\
-    ENTT_NAMED_TYPE(ns::clazz)
-
-
-/*! @brief Utility function to simulate macro overloading. */
-#define ENTT_NAMED_CLASS_MACRO(_1, _2, _3, FUNC, ...) FUNC
-/*! @brief Defines a named type (to use for classes). */
-#define ENTT_NAMED_CLASS(...) ENTT_EXPAND(ENTT_NAMED_CLASS_MACRO(__VA_ARGS__, ENTT_NAMED_CLASS_WITH_NAMESPACE, ENTT_NAMED_CLASS_ONLY,)(__VA_ARGS__))
-
-
-#endif // ENTT_CORE_TYPE_TRAITS_HPP
+#endif

src/entt/core/utility.hpp

@@ -2,6 +2,7 @@
 #define ENTT_CORE_UTILITY_HPP
 
 
+#include <utility>
 #include "../config/config.h"
 
 
@@ -24,11 +25,11 @@ struct identity {
 
 
 /**
- * @brief Constant utility to disambiguate overloaded member functions.
- * @tparam Type Function type of the desired overload.
- * @tparam Class Type of class to which the member functions belong.
- * @param member A valid pointer to a member function.
- * @return Pointer to the member function.
+ * @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>
 constexpr auto overload(Type Class:: *member) ENTT_NOEXCEPT { return member; }
@@ -36,15 +37,69 @@ constexpr auto overload(Type Class:: *member) ENTT_NOEXCEPT { return member; }
 
 /**
  * @brief Constant utility to disambiguate overloaded functions.
- * @tparam Type Function type of the desired overload.
+ * @tparam Func Function type of the desired overload.
  * @param func A valid pointer to a function.
  * @return Pointer to the function.
  */
-template<typename Type>
-constexpr auto overload(Type *func) ENTT_NOEXCEPT { return func; }
+template<typename Func>
+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;
+};
 
 
 }
 
 
-#endif // ENTT_CORE_UTILITY_HPP
+#endif

src/entt/entity/actor.hpp

@@ -2,7 +2,6 @@
 #define ENTT_ENTITY_ACTOR_HPP
 
 
-#include <cassert>
 #include <utility>
 #include <type_traits>
 #include "../config/config.h"
@@ -35,6 +34,21 @@ struct basic_actor {
         : entt{entt::null}, reg{nullptr}
     {}
 
+    /**
+     * @brief Move constructor.
+     *
+     * After actor move construction, instances that have been moved from are
+     * placed in a valid but unspecified state. It's highly discouraged to
+     * continue using them.
+     *
+     * @param other The instance to move from.
+     */
+    basic_actor(basic_actor &&other) ENTT_NOEXCEPT
+        : entt{other.entt}, reg{other.reg}
+    {
+        other.entt = null;
+    }
+
     /**
      * @brief Constructs an actor from a given registry.
      * @param ref An instance of the registry class.
@@ -48,7 +62,7 @@ struct basic_actor {
      * @param entity A valid entity identifier.
      * @param ref An instance of the registry class.
      */
-    explicit basic_actor(entity_type entity, registry_type &ref)
+    explicit basic_actor(entity_type entity, registry_type &ref) ENTT_NOEXCEPT
         : entt{entity}, reg{&ref}
     {
         ENTT_ASSERT(ref.valid(entity));
@@ -61,21 +75,6 @@ struct basic_actor {
         }
     }
 
-    /**
-     * @brief Move constructor.
-     *
-     * After actor move construction, instances that have been moved from are
-     * placed in a valid but unspecified state. It's highly discouraged to
-     * continue using them.
-     *
-     * @param other The instance to move from.
-     */
-    basic_actor(basic_actor &&other)
-        : entt{other.entt}, reg{other.reg}
-    {
-        other.entt = null;
-    }
-
     /**
      * @brief Move assignment operator.
      *
@@ -86,7 +85,7 @@ struct basic_actor {
      * @param other The instance to move from.
      * @return This actor.
      */
-    basic_actor & operator=(basic_actor &&other) {
+    basic_actor & operator=(basic_actor &&other) ENTT_NOEXCEPT {
         if(this != &other) {
             auto tmp{std::move(other)};
             std::swap(reg, tmp.reg);
@@ -112,7 +111,7 @@ struct basic_actor {
      */
     template<typename Component, typename... Args>
     decltype(auto) assign(Args &&... args) {
-        return reg->template assign_or_replace<Component>(entt, std::forward<Args>(args)...);
+        return reg->template emplace_or_replace<Component>(entt, std::forward<Args>(args)...);
     }
 
     /**
@@ -130,8 +129,8 @@ struct basic_actor {
      * @return True if the actor has all the components, false otherwise.
      */
     template<typename... Component>
-    bool has() const ENTT_NOEXCEPT {
-        return (reg->template has<Component>(entt) && ...);
+    bool has() const {
+        return reg->template has<Component...>(entt);
     }
 
     /**
@@ -140,13 +139,13 @@ struct basic_actor {
      * @return References to the components owned by the actor.
      */
     template<typename... Component>
-    decltype(auto) get() const ENTT_NOEXCEPT {
+    decltype(auto) get() const {
         return std::as_const(*reg).template get<Component...>(entt);
     }
 
     /*! @copydoc get */
     template<typename... Component>
-    decltype(auto) get() ENTT_NOEXCEPT {
+    decltype(auto) get() {
         return reg->template get<Component...>(entt);
     }
 
@@ -156,13 +155,13 @@ struct basic_actor {
      * @return Pointers to the components owned by the actor.
      */
     template<typename... Component>
-    auto try_get() const ENTT_NOEXCEPT {
+    auto try_get() const {
         return std::as_const(*reg).template try_get<Component...>(entt);
     }
 
     /*! @copydoc try_get */
     template<typename... Component>
-    auto try_get() ENTT_NOEXCEPT {
+    auto try_get() {
         return reg->template try_get<Component...>(entt);
     }
 
@@ -191,7 +190,7 @@ struct basic_actor {
      * @brief Checks if an actor refers to a valid entity or not.
      * @return True if the actor refers to a valid entity, false otherwise.
      */
-    explicit operator bool() const ENTT_NOEXCEPT {
+    explicit operator bool() const {
         return reg && reg->valid(entt);
     }
 
@@ -204,4 +203,4 @@ private:
 }
 
 
-#endif // ENTT_ENTITY_ACTOR_HPP
+#endif

src/entt/entity/entity.hpp

@@ -5,6 +5,8 @@
 #include <cstdint>
 #include <type_traits>
 #include "../config/config.h"
+#include "../core/type_traits.hpp"
+#include "../core/fwd.hpp"
 
 
 namespace entt {
@@ -127,7 +129,7 @@ public:
 
     template<typename Entity>
     constexpr bool operator==(const Entity entity) const ENTT_NOEXCEPT {
-        return (to_integer(entity) & traits_type<Entity>::entity_mask) == to_integer(static_cast<Entity>(*this));
+        return (to_integral(entity) & traits_type<Entity>::entity_mask) == to_integral(static_cast<Entity>(*this));
     }
 
     template<typename Entity>
@@ -139,13 +141,13 @@ public:
 
 template<typename Entity>
 constexpr bool operator==(const Entity entity, null other) ENTT_NOEXCEPT {
-    return other == entity;
+    return other.operator==(entity);
 }
 
 
 template<typename Entity>
 constexpr bool operator!=(const Entity entity, null other) ENTT_NOEXCEPT {
-    return other != entity;
+    return !(other == entity);
 }
 
 
@@ -158,6 +160,10 @@ constexpr bool operator!=(const Entity entity, null other) ENTT_NOEXCEPT {
  */
 
 
+/*! @brief Default entity identifier. */
+ENTT_OPAQUE_TYPE(entity, id_type);
+
+
 /**
  * @brief Compile-time constant for null entities.
  *
@@ -165,10 +171,10 @@ constexpr bool operator!=(const Entity entity, null other) ENTT_NOEXCEPT {
  * any allowed type. Similarly, there exist comparision operators between the
  * null entity and any other entity identifier.
  */
-constexpr auto null = internal::null{};
+inline constexpr auto null = internal::null{};
 
 
 }
 
 
-#endif // ENTT_ENTITY_ENTITY_HPP
+#endif

src/entt/entity/fwd.hpp

@@ -2,19 +2,18 @@
 #define ENTT_ENTITY_FWD_HPP
 
 
-#include <cstdint>
-#include "../config/config.h"
-#include "../core/type_traits.hpp"
+#include "../core/fwd.hpp"
 
 
 namespace entt {
 
+
 /*! @class basic_registry */
 template <typename>
 class basic_registry;
 
 /*! @class basic_view */
-template<typename, typename...>
+template<typename...>
 class basic_view;
 
 /*! @class basic_runtime_view */
@@ -29,14 +28,10 @@ class basic_group;
 template<typename>
 class basic_observer;
 
-/*! @class basic_actor */
+/*! @struct basic_actor */
 template <typename>
 struct basic_actor;
 
-/*! @class basic_prototype */
-template<typename>
-class basic_prototype;
-
 /*! @class basic_snapshot */
 template<typename>
 class basic_snapshot;
@@ -49,11 +44,8 @@ class basic_snapshot_loader;
 template<typename>
 class basic_continuous_loader;
 
-/*! @brief Alias declaration for the most common use case. */
-ENTT_OPAQUE_TYPE(entity, ENTT_ID_TYPE)
-
-/*! @brief Alias declaration for the most common use case. */
-ENTT_OPAQUE_TYPE(component, ENTT_ID_TYPE)
+/*! @class entity */
+enum class entity: id_type;
 
 /*! @brief Alias declaration for the most common use case. */
 using registry = basic_registry<entity>;
@@ -64,9 +56,6 @@ using observer = basic_observer<entity>;
 /*! @brief Alias declaration for the most common use case. */
 using actor = basic_actor<entity>;
 
-/*! @brief Alias declaration for the most common use case. */
-using prototype = basic_prototype<entity>;
-
 /*! @brief Alias declaration for the most common use case. */
 using snapshot = basic_snapshot<entity>;
 
@@ -78,7 +67,7 @@ using continuous_loader = basic_continuous_loader<entity>;
 
 /**
  * @brief Alias declaration for the most common use case.
- * @tparam Component Types of components iterated by the view.
+ * @tparam Types Types of components iterated by the view.
  */
 template<typename... Types>
 using view = basic_view<entity, Types...>;
@@ -97,4 +86,4 @@ using group = basic_group<entity, Types...>;
 }
 
 
-#endif // ENTT_ENTITY_FWD_HPP
+#endif

src/entt/entity/group.hpp

@@ -10,6 +10,7 @@
 #include "sparse_set.hpp"
 #include "storage.hpp"
 #include "utility.hpp"
+#include "entity.hpp"
 #include "fwd.hpp"
 
 
@@ -29,11 +30,9 @@ class basic_group;
 /**
  * @brief Non-owning group.
  *
- * A non-owning group returns all the 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.<br/>
- * In general, non-owning groups don't stay true to the order of any set of
- * components unless users explicitly sort them.
+ * 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
  *
@@ -44,40 +43,38 @@ class basic_group;
  *   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.
+ * 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 instance of the same
+ * 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 the set of entities).
+ * all of them because they _share_ entities and components).
  *
  * @warning
- * Lifetime of a group must overcome the one of the registry that generated it.
+ * 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 Exclude Types of components used to filter the group.
- * @tparam Get Type of component observed by the group.
- * @tparam Other Other types of components observed by the group.
+ * @tparam Get Type of components observed by the group.
  */
-template<typename Entity, typename... Exclude, typename Get, typename... Other>
-class basic_group<Entity, exclude_t<Exclude...>, get_t<Get, Other...>> {
+template<typename Entity, typename... Exclude, typename... Get>
+class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>> {
     /*! @brief A registry is allowed to create groups. */
     friend class basic_registry<Entity>;
 
     template<typename Component>
     using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
 
-    // we could use pool_type<Type> *..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug)
-    basic_group(sparse_set<Entity> *ref, storage<Entity, std::remove_const_t<Get>> *get, storage<Entity, std::remove_const_t<Other>> *... other) ENTT_NOEXCEPT
-        : handler{ref},
-          pools{get, other...}
+    // we could use pool_type<Type> &..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug)
+    basic_group(sparse_set<Entity> &ref, storage<Entity, std::remove_const_t<Get>> &... gpool) ENTT_NOEXCEPT
+        : handler{&ref},
+          pools{&gpool...}
     {}
 
     template<typename Func, typename... Weak>
@@ -88,16 +85,16 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get, Other...>> {
             } else {
                 func(entt, std::get<pool_type<Weak> *>(pools)->get(entt)...);
             }
-        };
+        }
     }
 
 public:
     /*! @brief Underlying entity identifier. */
-    using entity_type = typename sparse_set<Entity>::entity_type;
+    using entity_type = Entity;
     /*! @brief Unsigned integer type. */
-    using size_type = typename sparse_set<Entity>::size_type;
+    using size_type = std::size_t;
     /*! @brief Input iterator type. */
-    using iterator_type = typename sparse_set<Entity>::iterator_type;
+    using iterator = typename sparse_set<Entity>::iterator;
 
     /**
      * @brief Returns the number of existing components of the given type.
@@ -132,22 +129,17 @@ public:
     }
 
     /**
-     * @brief Checks whether the pool of a given component is empty.
-     * @tparam Component Type of component in which one is interested.
-     * @return True if the pool of the given component is empty, false
-     * otherwise.
+     * @brief Checks whether a group or some pools are empty.
+     * @tparam Component Types of components in which one is interested.
+     * @return True if the group or the pools are empty, false otherwise.
      */
-    template<typename Component>
+    template<typename... Component>
     bool empty() const ENTT_NOEXCEPT {
-        return std::get<pool_type<Component> *>(pools)->empty();
-    }
-
-    /**
-     * @brief Checks whether the group is empty.
-     * @return True if the group is empty, false otherwise.
-     */
-    bool empty() const ENTT_NOEXCEPT {
-        return handler->empty();
+        if constexpr(sizeof...(Component) == 0) {
+            return handler->empty();
+        } else {
+            return (std::get<pool_type<Component> *>(pools)->empty() && ...);
+        }
     }
 
     /**
@@ -218,7 +210,7 @@ public:
      *
      * @return An iterator to the first entity that has the given components.
      */
-    iterator_type begin() const ENTT_NOEXCEPT {
+    iterator begin() const ENTT_NOEXCEPT {
         return handler->begin();
     }
 
@@ -237,17 +229,37 @@ public:
      * @return An iterator to the entity following the last entity that has the
      * given components.
      */
-    iterator_type end() const ENTT_NOEXCEPT {
+    iterator end() const ENTT_NOEXCEPT {
         return handler->end();
     }
 
+    /**
+     * @brief Returns the first entity that has the given components, if any.
+     * @return The first entity that has the given components if one exists, the
+     * null entity otherwise.
+     */
+    entity_type front() const {
+        const auto it = begin();
+        return it != end() ? *it : null;
+    }
+
+    /**
+     * @brief Returns the last entity that has the given components, if any.
+     * @return The last entity that has the given components if one exists, the
+     * null entity otherwise.
+     */
+    entity_type back() const {
+        const auto it = std::make_reverse_iterator(end());
+        return it != std::make_reverse_iterator(begin()) ? *it : null;
+    }
+
     /**
      * @brief Finds an entity.
      * @param entt A valid entity identifier.
      * @return An iterator to the given entity if it's found, past the end
      * iterator otherwise.
      */
-    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
+    iterator find(const entity_type entt) const {
         const auto it = handler->find(entt);
         return it != end() && *it == entt ? it : end();
     }
@@ -257,7 +269,7 @@ public:
      * @param pos Position of the element to return.
      * @return The identifier that occupies the given position.
      */
-    entity_type operator[](const size_type pos) const ENTT_NOEXCEPT {
+    entity_type operator[](const size_type pos) const {
         return begin()[pos];
     }
 
@@ -266,15 +278,15 @@ public:
      * @param entt A valid entity identifier.
      * @return True if the group contains the given entity, false otherwise.
      */
-    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
-        return find(entt) != end();
+    bool contains(const entity_type entt) const {
+        return 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 companion function.
+     * far better performance than its counterpart.
      *
      * @warning
      * Attempting to use an invalid component type results in a compilation
@@ -288,44 +300,16 @@ public:
      * @return The components assigned to the entity.
      */
     template<typename... Component>
-    decltype(auto) get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
+    decltype(auto) get([[maybe_unused]] const entity_type entt) const {
         ENTT_ASSERT(contains(entt));
 
         if constexpr(sizeof...(Component) == 1) {
             return (std::get<pool_type<Component> *>(pools)->get(entt), ...);
         } else {
-            return std::tuple<decltype(get<Component>(entt))...>{get<Component>(entt)...};
+            return std::tuple<decltype(get<Component>({}))...>{get<Component>(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 all its 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, Get &, Other &...);
-     * void(Get &, Other &...);
-     * @endcode
-     *
-     * @note
-     * Empty types aren't explicitly instantiated. Therefore, temporary objects
-     * are returned during iterations. They can be caught only by copy or with
-     * const references.
-     *
-     * @tparam Func Type of the function object to invoke.
-     * @param func A valid function object.
-     */
-    template<typename Func>
-    void each(Func func) const {
-        traverse(std::move(func), type_list<Get, Other...>{});
-    }
-
     /**
      * @brief Iterates entities and components and applies the given function
      * object to them.
@@ -341,16 +325,45 @@ public:
      * void(Type &...);
      * @endcode
      *
-     * @sa each
+     * @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 {
+        using get_type_list = type_list_cat_t<std::conditional_t<ENTT_IS_EMPTY(Get), type_list<>, type_list<Get>>...>;
+        traverse(std::move(func), get_type_list{});
+    }
+
+    /**
+     * @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>
+    [[deprecated("use ::each instead")]]
     void less(Func func) const {
-        using get_type_list = std::conditional_t<std::is_empty_v<Get>, type_list<>, type_list<Get>>;
-        using other_type_list = type_list_cat_t<std::conditional_t<std::is_empty_v<Other>, type_list<>, type_list<Other>>...>;
-        traverse(std::move(func), type_list_cat_t<get_type_list, other_type_list>{});
+        each(std::move(func));
     }
 
     /**
@@ -381,10 +394,6 @@ public:
      * * An iterator past the last element of the range to sort.
      * * A comparison function to use to compare the elements.
      *
-     * The comparison function object received by the sort function object
-     * hasn't necessarily the type of the one passed along with the other
-     * parameters to this member function.
-     *
      * @note
      * Attempting to iterate elements using a raw pointer returned by a call to
      * either `data` or `raw` gives no guarantees on the order, even though
@@ -403,10 +412,13 @@ public:
         if constexpr(sizeof...(Component) == 0) {
             static_assert(std::is_invocable_v<Compare, const entity_type, const entity_type>);
             handler->sort(handler->begin(), handler->end(), std::move(compare), std::move(algo), std::forward<Args>(args)...);
+        }  else if constexpr(sizeof...(Component) == 1) {
+            handler->sort(handler->begin(), handler->end(), [this, compare = std::move(compare)](const entity_type lhs, const entity_type rhs) {
+                return compare((std::get<pool_type<Component> *>(pools)->get(lhs), ...), (std::get<pool_type<Component> *>(pools)->get(rhs), ...));
+            }, std::move(algo), std::forward<Args>(args)...);
         } else {
             handler->sort(handler->begin(), handler->end(), [this, compare = std::move(compare)](const entity_type lhs, const entity_type rhs) {
-                // useless this-> used to suppress a warning with clang
-                return compare(this->get<Component...>(lhs), this->get<Component...>(rhs));
+                return compare(std::tuple<decltype(get<Component>({}))...>{std::get<pool_type<Component> *>(pools)->get(lhs)...}, std::tuple<decltype(get<Component>({}))...>{std::get<pool_type<Component> *>(pools)->get(rhs)...});
             }, std::move(algo), std::forward<Args>(args)...);
         }
     }
@@ -415,7 +427,7 @@ public:
      * @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
+     * 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.
      *
@@ -434,22 +446,22 @@ public:
 
 private:
     sparse_set<entity_type> *handler;
-    const std::tuple<pool_type<Get> *, pool_type<Other> *...> pools;
+    const std::tuple<pool_type<Get> *...> pools;
 };
 
 
 /**
  * @brief Owning group.
  *
- * Owning groups return all the entities and only the entities that have at
- * least the given components. Moreover:
+ * 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 the owned
- *   components have the same order in memory.
+ * * 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.
@@ -463,9 +475,8 @@ private:
  *   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.
+ * 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
@@ -477,17 +488,16 @@ private:
  * of them because they share the underlying data structure).
  *
  * @warning
- * Lifetime of a group must overcome the one of the registry that generated it.
+ * 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 Exclude Types of components used to filter the group.
  * @tparam Get Types of components observed by the group.
- * @tparam Owned Type of component owned by the group.
- * @tparam Other Other types of components owned by the group.
+ * @tparam Owned Types of components owned by the group.
  */
-template<typename Entity, typename... Exclude, typename... Get, typename Owned, typename... Other>
-class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned, Other...> {
+template<typename Entity, typename... Exclude, typename... Get, typename... Owned>
+class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned...> {
     /*! @brief A registry is allowed to create groups. */
     friend class basic_registry<Entity>;
 
@@ -495,41 +505,42 @@ class basic_group<Entity, exclude_t<Exclude...>, get_t<Get...>, Owned, Other...>
     using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
 
     template<typename Component>
-    using component_iterator_type = decltype(std::declval<pool_type<Component>>().begin());
+    using component_iterator = decltype(std::declval<pool_type<Component>>().begin());
 
-    // we could use pool_type<Type> *..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug)
-    basic_group(const typename basic_registry<Entity>::size_type *sz, storage<Entity, std::remove_const_t<Owned>> *owned, storage<Entity, std::remove_const_t<Other>> *... other, storage<Entity, std::remove_const_t<Get>> *... get) ENTT_NOEXCEPT
-        : length{sz},
-          pools{owned, other..., get...}
+    // we could use pool_type<Type> &..., but vs complains about it and refuses to compile for unknown reasons (most likely a bug)
+    basic_group(const std::size_t &ref, const std::size_t &extent, storage<Entity, std::remove_const_t<Owned>> &... opool, storage<Entity, std::remove_const_t<Get>> &... gpool) ENTT_NOEXCEPT
+        : pools{&opool..., &gpool...},
+          length{&extent},
+          super{&ref}
     {}
 
     template<typename Func, typename... Strong, typename... Weak>
     void traverse(Func func, type_list<Strong...>, type_list<Weak...>) const {
-        [[maybe_unused]] auto raw = std::make_tuple((std::get<pool_type<Strong> *>(pools)->end() - *length)...);
-        [[maybe_unused]] auto data = std::get<pool_type<Owned> *>(pools)->sparse_set<entity_type>::end() - *length;
+        [[maybe_unused]] auto it = std::make_tuple((std::get<pool_type<Strong> *>(pools)->end() - *length)...);
+        [[maybe_unused]] auto data = std::get<0>(pools)->sparse_set<entity_type>::end() - *length;
 
         for(auto next = *length; next; --next) {
             if constexpr(std::is_invocable_v<Func, decltype(get<Strong>({}))..., decltype(get<Weak>({}))...>) {
                 if constexpr(sizeof...(Weak) == 0) {
-                    func(*(std::get<component_iterator_type<Strong>>(raw)++)...);
+                    func(*(std::get<component_iterator<Strong>>(it)++)...);
                 } else {
                     const auto entt = *(data++);
-                    func(*(std::get<component_iterator_type<Strong>>(raw)++)..., std::get<pool_type<Weak> *>(pools)->get(entt)...);
+                    func(*(std::get<component_iterator<Strong>>(it)++)..., std::get<pool_type<Weak> *>(pools)->get(entt)...);
                 }
             } else {
                 const auto entt = *(data++);
-                func(entt, *(std::get<component_iterator_type<Strong>>(raw)++)..., std::get<pool_type<Weak> *>(pools)->get(entt)...);
+                func(entt, *(std::get<component_iterator<Strong>>(it)++)..., std::get<pool_type<Weak> *>(pools)->get(entt)...);
             }
         }
     }
 
 public:
     /*! @brief Underlying entity identifier. */
-    using entity_type = typename sparse_set<Entity>::entity_type;
+    using entity_type = Entity;
     /*! @brief Unsigned integer type. */
-    using size_type = typename sparse_set<Entity>::size_type;
+    using size_type = std::size_t;
     /*! @brief Input iterator type. */
-    using iterator_type = typename sparse_set<Entity>::iterator_type;
+    using iterator = typename sparse_set<Entity>::iterator;
 
     /**
      * @brief Returns the number of existing components of the given type.
@@ -550,22 +561,17 @@ public:
     }
 
     /**
-     * @brief Checks whether the pool of a given component is empty.
-     * @tparam Component Type of component in which one is interested.
-     * @return True if the pool of the given component is empty, false
-     * otherwise.
+     * @brief Checks whether a group or some pools are empty.
+     * @tparam Component Types of components in which one is interested.
+     * @return True if the group or the pools are empty, false otherwise.
      */
-    template<typename Component>
+    template<typename... Component>
     bool empty() const ENTT_NOEXCEPT {
-        return std::get<pool_type<Component> *>(pools)->empty();
-    }
-
-    /**
-     * @brief Checks whether the group is empty.
-     * @return True if the group is empty, false otherwise.
-     */
-    bool empty() const ENTT_NOEXCEPT {
-        return !*length;
+        if constexpr(sizeof...(Component) == 0) {
+            return !*length;
+        } else {
+            return (std::get<pool_type<Component> *>(pools)->empty() && ...);
+        }
     }
 
     /**
@@ -625,7 +631,7 @@ public:
      * @return A pointer to the array of entities.
      */
     const entity_type * data() const ENTT_NOEXCEPT {
-        return std::get<pool_type<Owned> *>(pools)->data();
+        return std::get<0>(pools)->data();
     }
 
     /**
@@ -642,8 +648,8 @@ public:
      *
      * @return An iterator to the first entity that has the given components.
      */
-    iterator_type begin() const ENTT_NOEXCEPT {
-        return std::get<pool_type<Owned> *>(pools)->sparse_set<entity_type>::end() - *length;
+    iterator begin() const ENTT_NOEXCEPT {
+        return std::get<0>(pools)->sparse_set<entity_type>::end() - *length;
     }
 
     /**
@@ -661,8 +667,28 @@ public:
      * @return An iterator to the entity following the last entity that has the
      * given components.
      */
-    iterator_type end() const ENTT_NOEXCEPT {
-        return std::get<pool_type<Owned> *>(pools)->sparse_set<entity_type>::end();
+    iterator end() const ENTT_NOEXCEPT {
+        return std::get<0>(pools)->sparse_set<entity_type>::end();
+    }
+
+    /**
+     * @brief Returns the first entity that has the given components, if any.
+     * @return The first entity that has the given components if one exists, the
+     * null entity otherwise.
+     */
+    entity_type front() const {
+        const auto it = begin();
+        return it != end() ? *it : null;
+    }
+
+    /**
+     * @brief Returns the last entity that has the given components, if any.
+     * @return The last entity that has the given components if one exists, the
+     * null entity otherwise.
+     */
+    entity_type back() const {
+        const auto it = std::make_reverse_iterator(end());
+        return it != std::make_reverse_iterator(begin()) ? *it : null;
     }
 
     /**
@@ -671,8 +697,8 @@ public:
      * @return An iterator to the given entity if it's found, past the end
      * iterator otherwise.
      */
-    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
-        const auto it = std::get<pool_type<Owned> *>(pools)->find(entt);
+    iterator find(const entity_type entt) const {
+        const auto it = std::get<0>(pools)->find(entt);
         return it != end() && it >= begin() && *it == entt ? it : end();
     }
 
@@ -681,7 +707,7 @@ public:
      * @param pos Position of the element to return.
      * @return The identifier that occupies the given position.
      */
-    entity_type operator[](const size_type pos) const ENTT_NOEXCEPT {
+    entity_type operator[](const size_type pos) const {
         return begin()[pos];
     }
 
@@ -690,15 +716,15 @@ public:
      * @param entt A valid entity identifier.
      * @return True if the group contains the given entity, false otherwise.
      */
-    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
-        return find(entt) != end();
+    bool contains(const entity_type entt) const {
+        return 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 companion function.
+     * far better performance than its counterpart.
      *
      * @warning
      * Attempting to use an invalid component type results in a compilation
@@ -712,44 +738,16 @@ public:
      * @return The components assigned to the entity.
      */
     template<typename... Component>
-    decltype(auto) get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
+    decltype(auto) get([[maybe_unused]] const entity_type entt) const {
         ENTT_ASSERT(contains(entt));
 
         if constexpr(sizeof...(Component) == 1) {
             return (std::get<pool_type<Component> *>(pools)->get(entt), ...);
         } else {
-            return std::tuple<decltype(get<Component>(entt))...>{get<Component>(entt)...};
+            return std::tuple<decltype(get<Component>({}))...>{get<Component>(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 all its 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, Owned &, Other &..., Get &...);
-     * void(Owned &, Other &..., Get &...);
-     * @endcode
-     *
-     * @note
-     * Empty types aren't explicitly instantiated. Therefore, temporary objects
-     * are returned during iterations. They can be caught only by copy or with
-     * const references.
-     *
-     * @tparam Func Type of the function object to invoke.
-     * @param func A valid function object.
-     */
-    template<typename Func>
-    void each(Func func) const {
-        traverse(std::move(func), type_list<Owned, Other...>{}, type_list<Get...>{});
-    }
-
     /**
      * @brief Iterates entities and components and applies the given function
      * object to them.
@@ -765,17 +763,55 @@ public:
      * void(Type &...);
      * @endcode
      *
-     * @sa each
+     * @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 {
+        using owned_type_list = type_list_cat_t<std::conditional_t<ENTT_IS_EMPTY(Owned), type_list<>, type_list<Owned>>...>;
+        using get_type_list = type_list_cat_t<std::conditional_t<ENTT_IS_EMPTY(Get), type_list<>, type_list<Get>>...>;
+        traverse(std::move(func), owned_type_list{}, get_type_list{});
+    }
+
+    /**
+     * @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>
+    [[deprecated("use ::each instead")]]
     void less(Func func) const {
-        using owned_type_list = std::conditional_t<std::is_empty_v<Owned>, type_list<>, type_list<Owned>>;
-        using other_type_list = type_list_cat_t<std::conditional_t<std::is_empty_v<Other>, type_list<>, type_list<Other>>...>;
-        using get_type_list = type_list_cat_t<std::conditional_t<std::is_empty_v<Get>, type_list<>, type_list<Get>>...>;
-        traverse(std::move(func), type_list_cat_t<owned_type_list, other_type_list>{}, get_type_list{});
+        each(std::move(func));
+    }
+
+    /**
+     * @brief Checks whether the group can be sorted.
+     * @return True if the group can be sorted, false otherwise.
+     */
+    bool sortable() const ENTT_NOEXCEPT {
+        constexpr auto size = sizeof...(Owned) + sizeof...(Get) + sizeof...(Exclude);
+        return *super == size;
     }
 
     /**
@@ -807,10 +843,6 @@ public:
      * * An iterator past the last element of the range to sort.
      * * A comparison function to use to compare the elements.
      *
-     * The comparison function object received by the sort function object
-     * hasn't necessarily the type of the one passed along with the other
-     * parameters to this member function.
-     *
      * @note
      * Attempting to iterate elements using a raw pointer returned by a call to
      * either `data` or `raw` gives no guarantees on the order, even though
@@ -826,32 +858,39 @@ public:
      */
     template<typename... Component, typename Compare, typename Sort = std_sort, typename... Args>
     void sort(Compare compare, Sort algo = Sort{}, Args &&... args) {
-        auto *cpool = std::get<pool_type<Owned> *>(pools);
+        ENTT_ASSERT(sortable());
+        auto *cpool = std::get<0>(pools);
 
         if constexpr(sizeof...(Component) == 0) {
             static_assert(std::is_invocable_v<Compare, const entity_type, const entity_type>);
             cpool->sort(cpool->end()-*length, cpool->end(), std::move(compare), std::move(algo), std::forward<Args>(args)...);
+        } else if constexpr(sizeof...(Component) == 1) {
+            cpool->sort(cpool->end()-*length, cpool->end(), [this, compare = std::move(compare)](const entity_type lhs, const entity_type rhs) {
+                return compare((std::get<pool_type<Component> *>(pools)->get(lhs), ...), (std::get<pool_type<Component> *>(pools)->get(rhs), ...));
+            }, std::move(algo), std::forward<Args>(args)...);
         } else {
             cpool->sort(cpool->end()-*length, cpool->end(), [this, compare = std::move(compare)](const entity_type lhs, const entity_type rhs) {
-                // useless this-> used to suppress a warning with clang
-                return compare(this->get<Component...>(lhs), this->get<Component...>(rhs));
+                return compare(std::tuple<decltype(get<Component>({}))...>{std::get<pool_type<Component> *>(pools)->get(lhs)...}, std::tuple<decltype(get<Component>({}))...>{std::get<pool_type<Component> *>(pools)->get(rhs)...});
             }, std::move(algo), std::forward<Args>(args)...);
         }
 
-        for(auto next = *length; next; --next) {
-            const auto pos = next - 1;
-            const auto entt = cpool->data()[pos];
-            (std::get<pool_type<Other> *>(pools)->swap(pos, std::get<pool_type<Other> *>(pools)->index(entt)), ...);
-        }
+        [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(other->data()[pos], entt), ...);
+            }
+        }(std::get<pool_type<Owned> *>(pools)...);
     }
 
 private:
-    const typename basic_registry<Entity>::size_type *length;
-    const std::tuple<pool_type<Owned> *, pool_type<Other> *..., pool_type<Get> *...> pools;
+    const std::tuple<pool_type<Owned> *..., pool_type<Get> *...> pools;
+    const size_type *length;
+    const size_type *super;
 };
 
 
 }
 
 
-#endif // ENTT_ENTITY_GROUP_HPP
+#endif

src/entt/entity/helper.hpp

@@ -4,8 +4,10 @@
 
 #include <type_traits>
 #include "../config/config.h"
-#include "../signal/sigh.hpp"
+#include "../core/type_traits.hpp"
+#include "../signal/delegate.hpp"
 #include "registry.hpp"
+#include "fwd.hpp"
 
 
 namespace entt {
@@ -29,12 +31,13 @@ struct as_view {
 
     /**
      * @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... Component>
-    operator entt::basic_view<Entity, Component...>() const {
-        return reg.template view<Component...>();
+    template<typename Exclude, typename... Component>
+    operator entt::basic_view<Entity, Exclude, Component...>() const {
+        return reg.template view<Component...>(Exclude{});
     }
 
 private:
@@ -109,30 +112,24 @@ template<typename Entity>
 as_group(const basic_registry<Entity> &) ENTT_NOEXCEPT -> as_group<true, Entity>;
 
 
+
 /**
- * @brief Alias template to ease the assignment of tags to entities.
- *
- * If used in combination with hashed strings, it simplifies the assignment of
- * tags to entities and the use of tags in general where a type would be
- * required otherwise.<br/>
- * As an example and where the user defined literal for hashed strings hasn't
- * been changed:
- * @code{.cpp}
- * entt::registry registry;
- * registry.assign<entt::tag<"enemy"_hs>>(entity);
- * @endcode
- *
- * @note
- * Tags are empty components and therefore candidates for the empty component
- * optimization.
- *
- * @tparam Value The numeric representation of an instance of hashed string.
+ * @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<ENTT_ID_TYPE Value>
-using tag = std::integral_constant<ENTT_ID_TYPE, Value>;
+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)>);
+    delegate<void(basic_registry<Entity> &, const Entity)> func;
+    func.template connect<Member>(reg.template get<member_class_t<decltype(Member)>>(entt));
+    func(reg, entt);
+}
 
 
 }
 
 
-#endif // ENTT_ENTITY_HELPER_HPP
+#endif

src/entt/entity/observer.hpp

@@ -6,12 +6,12 @@
 #include <cstddef>
 #include <cstdint>
 #include <utility>
-#include <algorithm>
 #include <type_traits>
 #include "../config/config.h"
 #include "../core/type_traits.hpp"
 #include "registry.hpp"
 #include "storage.hpp"
+#include "utility.hpp"
 #include "entity.hpp"
 #include "fwd.hpp"
 
@@ -52,7 +52,7 @@ struct basic_collector<> {
      */
     template<typename... AllOf, typename... NoneOf>
     static constexpr auto group(exclude_t<NoneOf...> = {}) ENTT_NOEXCEPT {
-        return basic_collector<matcher<matcher<type_list<>, type_list<>>, type_list<NoneOf...>, type_list<AllOf...>>>{};
+        return basic_collector<matcher<type_list<>, type_list<>, type_list<NoneOf...>, AllOf...>>{};
     }
 
     /**
@@ -61,19 +61,31 @@ struct basic_collector<> {
      * @return The updated collector.
      */
     template<typename AnyOf>
+    static constexpr auto update() ENTT_NOEXCEPT {
+        return basic_collector<matcher<type_list<>, type_list<>, AnyOf>>{};
+    }
+
+    /*! @copydoc update */
+    template<typename AnyOf>
+    [[deprecated("use ::update instead")]]
     static constexpr auto replace() ENTT_NOEXCEPT {
-        return basic_collector<matcher<matcher<type_list<>, type_list<>>, AnyOf>>{};
+        return update<AnyOf>();
     }
 };
 
 /**
  * @brief Collector.
  * @copydetails basic_collector<>
- * @tparam AnyOf Types of components for which changes should be detected.
- * @tparam Matcher Types of grouping matchers.
+ * @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<matcher<type_list<Reject...>, type_list<Require...>>, Rule...>, 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.
@@ -82,8 +94,7 @@ struct basic_collector<matcher<matcher<type_list<Reject...>, type_list<Require..
      */
     template<typename... AllOf, typename... NoneOf>
     static constexpr auto group(exclude_t<NoneOf...> = {}) ENTT_NOEXCEPT {
-        using first = matcher<matcher<type_list<Reject...>, type_list<Require...>>, Rule...>;
-        return basic_collector<first, Other..., matcher<matcher<type_list<>, type_list<>>, type_list<NoneOf...>, type_list<AllOf...>>>{};
+        return basic_collector<matcher<type_list<>, type_list<>, type_list<NoneOf...>, AllOf...>, current_type, Other...>{};
     }
 
     /**
@@ -92,11 +103,18 @@ struct basic_collector<matcher<matcher<type_list<Reject...>, type_list<Require..
      * @return The updated collector.
      */
     template<typename AnyOf>
-    static constexpr auto replace() ENTT_NOEXCEPT {
-        using first = matcher<matcher<type_list<Reject...>, type_list<Require...>>, Rule...>;
-        return basic_collector<first, Other..., matcher<matcher<type_list<>, type_list<>>, AnyOf>>{};
+    static constexpr auto update() ENTT_NOEXCEPT {
+        return basic_collector<matcher<type_list<>, type_list<>, AnyOf>, current_type, Other...>{};
     }
 
+    /*! @copydoc update */
+    template<typename AnyOf>
+    [[deprecated("use ::update instead")]]
+    static constexpr auto replace() ENTT_NOEXCEPT {
+        return update<AnyOf>();
+    }
+
+
     /**
      * @brief Updates the filter of the last added matcher.
      * @tparam AllOf Types of components required by the matcher.
@@ -105,13 +123,14 @@ struct basic_collector<matcher<matcher<type_list<Reject...>, type_list<Require..
      */
     template<typename... AllOf, typename... NoneOf>
     static constexpr auto where(exclude_t<NoneOf...> = {}) ENTT_NOEXCEPT {
-        return basic_collector<matcher<matcher<type_list<Reject..., NoneOf...>, type_list<Require..., AllOf...>>, Rule...>, Other...>{};
+        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. */
-constexpr basic_collector<> collector{};
+inline constexpr basic_collector<> collector{};
 
 
 /**
@@ -126,8 +145,8 @@ constexpr basic_collector<> collector{};
  * collector:
  *
  * * Observing matcher: an observer will return at least all the living entities
- *   for which one or more of the given components have been explicitly
- *   replaced and not yet destroyed.
+ *   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.
@@ -156,7 +175,7 @@ constexpr basic_collector<> collector{};
  * behavior.
  *
  * @warning
- * Lifetime of an observer doesn't necessarily have to overcome the one of the
+ * 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.
@@ -171,19 +190,22 @@ class basic_observer {
     struct matcher_handler;
 
     template<typename... Reject, typename... Require, typename AnyOf>
-    struct matcher_handler<matcher<matcher<type_list<Reject...>, type_list<Require...>>, 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, const Entity entt, const basic_registry<Entity> &reg) {
-            if(reg.template has<Require...>(entt) && !(reg.template has<Reject>(entt) || ...)) {
-                auto *comp = obs.view.try_get(entt);
-                (comp ? *comp : obs.view.construct(entt)) |= (1 << Index);
+        static void maybe_valid_if(basic_observer &obs, const basic_registry<Entity> &reg, const Entity entt) {
+            if(reg.template has<Require...>(entt) && !reg.template any<Reject...>(entt)) {
+                if(auto *comp = obs.view.try_get(entt); !comp) {
+                    obs.view.emplace(entt);
+                }
+
+                obs.view.get(entt) |= (1 << Index);
             }
         }
 
         template<std::size_t Index>
-        static void discard_if(basic_observer &obs, const Entity entt) {
+        static void discard_if(basic_observer &obs, const basic_registry<Entity> &, const Entity entt) {
             if(auto *value = obs.view.try_get(entt); value && !(*value &= (~(1 << Index)))) {
-                obs.view.destroy(entt);
+                obs.view.erase(entt);
             }
         }
 
@@ -191,34 +213,35 @@ class basic_observer {
         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_replace<AnyOf>().template connect<&maybe_valid_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_replace<AnyOf>().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<matcher<type_list<Reject...>, type_list<Require...>>, type_list<NoneOf...>, type_list<AllOf...>>> {
+    struct matcher_handler<matcher<type_list<Reject...>, type_list<Require...>, type_list<NoneOf...>, AllOf...>> {
         template<std::size_t Index>
-        static void maybe_valid_if(basic_observer &obs, const Entity entt, const basic_registry<Entity> &reg) {
-            if(reg.template has<AllOf...>(entt) && !(reg.template has<NoneOf>(entt) || ...)
-                    && reg.template has<Require...>(entt) && !(reg.template has<Reject>(entt) || ...))
-            {
-                auto *comp = obs.view.try_get(entt);
-                (comp ? *comp : obs.view.construct(entt)) |= (1 << Index);
+        static void maybe_valid_if(basic_observer &obs, const basic_registry<Entity> &reg, const Entity entt) {
+            if(reg.template has<AllOf..., Require...>(entt) && !reg.template any<NoneOf..., Reject...>(entt)) {
+                if(auto *comp = obs.view.try_get(entt); !comp) {
+                    obs.view.emplace(entt);
+                }
+
+                obs.view.get(entt) |= (1 << Index);
             }
         }
 
         template<std::size_t Index>
-        static void discard_if(basic_observer &obs, const Entity entt) {
+        static void discard_if(basic_observer &obs, const basic_registry<Entity> &, const Entity entt) {
             if(auto *value = obs.view.try_get(entt); value && !(*value &= (~(1 << Index)))) {
-                obs.view.destroy(entt);
+                obs.view.erase(entt);
             }
         }
 
@@ -260,10 +283,10 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Input iterator type. */
-    using iterator_type = typename sparse_set<Entity>::iterator_type;
+    using iterator = typename sparse_set<Entity>::iterator;
 
     /*! @brief Default constructor. */
-    basic_observer() ENTT_NOEXCEPT
+    basic_observer()
         : target{}, release{}, view{}
     {}
 
@@ -278,12 +301,12 @@ public:
      * @param reg A valid reference to a registry.
      */
     template<typename... Matcher>
-    basic_observer(basic_registry<entity_type> &reg, basic_collector<Matcher...>) ENTT_NOEXCEPT
+    basic_observer(basic_registry<entity_type> &reg, basic_collector<Matcher...>)
         : target{&reg},
           release{},
           view{}
     {
-        connect<Matcher...>(reg, std::make_index_sequence<sizeof...(Matcher)>{});
+        connect<Matcher...>(reg, std::index_sequence_for<Matcher...>{});
     }
 
     /*! @brief Default destructor. */
@@ -309,9 +332,9 @@ public:
     template<typename... Matcher>
     void connect(basic_registry<entity_type> &reg, basic_collector<Matcher...>) {
         disconnect();
-        connect<Matcher...>(reg, std::make_index_sequence<sizeof...(Matcher)>{});
+        connect<Matcher...>(reg, std::index_sequence_for<Matcher...>{});
         target = &reg;
-        view.reset();
+        view.clear();
     }
 
     /*! @brief Disconnects an observer from the registry it keeps track of. */
@@ -362,7 +385,7 @@ public:
      *
      * @return An iterator to the first entity of the observer.
      */
-    iterator_type begin() const ENTT_NOEXCEPT {
+    iterator begin() const ENTT_NOEXCEPT {
         return view.sparse_set<entity_type>::begin();
     }
 
@@ -376,18 +399,17 @@ public:
      * @return An iterator to the entity following the last entity of the
      * observer.
      */
-    iterator_type end() const ENTT_NOEXCEPT {
+    iterator end() const ENTT_NOEXCEPT {
         return view.sparse_set<entity_type>::end();
     }
 
-    /*! @brief Resets the underlying container. */
-    void clear() {
-        view.reset();
+    /*! @brief Clears the underlying container. */
+    void clear() ENTT_NOEXCEPT {
+        view.clear();
     }
 
     /**
-     * @brief Iterates entities and applies the given function object to them,
-     * then clears the observer.
+     * @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:
@@ -402,19 +424,17 @@ public:
     template<typename Func>
     void each(Func func) const {
         static_assert(std::is_invocable_v<Func, entity_type>);
-        std::for_each(begin(), end(), std::move(func));
+
+        for(const auto entity: *this) {
+            func(entity);
+        }
     }
 
     /**
      * @brief Iterates entities and applies the given function object to them,
      * then clears the observer.
      *
-     * 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
+     * @sa each
      *
      * @tparam Func Type of the function object to invoke.
      * @param func A valid function object.
@@ -435,4 +455,4 @@ private:
 }
 
 
-#endif // ENTT_ENTITY_OBSERVER_HPP
+#endif

src/entt/entity/runtime_view.hpp

@@ -3,14 +3,12 @@
 
 
 #include <iterator>
-#include <cassert>
 #include <vector>
 #include <utility>
 #include <algorithm>
 #include <type_traits>
 #include "../config/config.h"
 #include "sparse_set.hpp"
-#include "entity.hpp"
 #include "fwd.hpp"
 
 
@@ -50,7 +48,7 @@ namespace entt {
  * have a valid reference and won't be updated accordingly).
  *
  * @warning
- * Lifetime of a view must overcome the one of the registry that generated it.
+ * 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).
@@ -60,68 +58,76 @@ class basic_runtime_view {
     /*! @brief A registry is allowed to create views. */
     friend class basic_registry<Entity>;
 
-    using underlying_iterator_type = typename sparse_set<Entity>::iterator_type;
-    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
+    using underlying_iterator = typename sparse_set<Entity>::iterator;
 
-    class iterator {
+    class view_iterator final {
         friend class basic_runtime_view<Entity>;
 
-        iterator(underlying_iterator_type first, underlying_iterator_type last, const sparse_set<Entity> * const *others, const sparse_set<Entity> * const *length) ENTT_NOEXCEPT
-            : begin{first},
-              end{last},
-              from{others},
-              to{length}
+        using direct_type = std::vector<const sparse_set<Entity> *>;
+
+        view_iterator(const direct_type &all, underlying_iterator curr) ENTT_NOEXCEPT
+            : pools{&all},
+              it{curr}
         {
-            if(begin != end && !valid()) {
+            if(it != (*pools)[0]->end() && !valid()) {
                 ++(*this);
             }
         }
 
-        bool valid() const ENTT_NOEXCEPT {
-            return std::all_of(from, to, [entt = *begin](const auto *view) {
-                return view->has(entt);
+        bool valid() const {
+            return std::all_of(pools->begin()++, pools->end(), [entt = *it](const auto *curr) {
+                return curr->contains(entt);
             });
         }
 
     public:
-        using difference_type = typename underlying_iterator_type::difference_type;
-        using value_type = typename underlying_iterator_type::value_type;
-        using pointer = typename underlying_iterator_type::pointer;
-        using reference = typename underlying_iterator_type::reference;
-        using iterator_category = std::forward_iterator_tag;
+        using difference_type = typename underlying_iterator::difference_type;
+        using value_type = typename underlying_iterator::value_type;
+        using pointer = typename underlying_iterator::pointer;
+        using reference = typename underlying_iterator::reference;
+        using iterator_category = std::bidirectional_iterator_tag;
 
-        iterator() ENTT_NOEXCEPT = default;
+        view_iterator() ENTT_NOEXCEPT = default;
 
-        iterator & operator++() ENTT_NOEXCEPT {
-            return (++begin != end && !valid()) ? ++(*this) : *this;
+        view_iterator & operator++() {
+            while(++it != (*pools)[0]->end() && !valid());
+            return *this;
         }
 
-        iterator operator++(int) ENTT_NOEXCEPT {
-            iterator orig = *this;
-            return ++(*this), orig;
+        view_iterator operator++(int) {
+            view_iterator orig = *this;
+            return operator++(), orig;
         }
 
-        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
-            return other.begin == begin;
+        view_iterator & operator--() ENTT_NOEXCEPT {
+            while(--it != (*pools)[0]->begin() && !valid());
+            return *this;
         }
 
-        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
+        view_iterator operator--(int) ENTT_NOEXCEPT {
+            view_iterator orig = *this;
+            return operator--(), orig;
+        }
+
+        bool operator==(const view_iterator &other) const ENTT_NOEXCEPT {
+            return other.it == it;
+        }
+
+        bool operator!=(const view_iterator &other) const ENTT_NOEXCEPT {
             return !(*this == other);
         }
 
-        pointer operator->() const ENTT_NOEXCEPT {
-            return begin.operator->();
+        pointer operator->() const {
+            return it.operator->();
         }
 
-        reference operator*() const ENTT_NOEXCEPT {
+        reference operator*() const {
             return *operator->();
         }
 
     private:
-        underlying_iterator_type begin;
-        underlying_iterator_type end;
-        const sparse_set<Entity> * const *from;
-        const sparse_set<Entity> * const *to;
+        const direct_type *pools;
+        underlying_iterator it;
     };
 
     basic_runtime_view(std::vector<const sparse_set<Entity> *> others) ENTT_NOEXCEPT
@@ -135,7 +141,7 @@ class basic_runtime_view {
         std::rotate(pools.begin(), it, pools.end());
     }
 
-    bool valid() const ENTT_NOEXCEPT {
+    bool valid() const {
         return !pools.empty() && pools.front();
     }
 
@@ -145,13 +151,13 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Input iterator type. */
-    using iterator_type = iterator;
+    using iterator = view_iterator;
 
     /**
      * @brief Estimates the number of entities that have the given components.
      * @return Estimated number of entities that have the given components.
      */
-    size_type size() const ENTT_NOEXCEPT {
+    size_type size() const {
         return valid() ? pools.front()->size() : size_type{};
     }
 
@@ -159,7 +165,7 @@ public:
      * @brief Checks if the view is definitely empty.
      * @return True if the view is definitely empty, false otherwise.
      */
-    bool empty() const ENTT_NOEXCEPT {
+    bool empty() const {
         return !valid() || pools.front()->empty();
     }
 
@@ -177,13 +183,11 @@ public:
      *
      * @return An iterator to the first entity that has the given components.
      */
-    iterator_type begin() const ENTT_NOEXCEPT {
-        iterator_type it{};
+    iterator begin() const {
+        iterator it{};
 
         if(valid()) {
-            const auto &pool = *pools.front();
-            const auto * const *data = pools.data();
-            it = { pool.begin(), pool.end(), data + 1, data + pools.size() };
+            it = { pools, pools[0]->begin() };
         }
 
         return it;
@@ -204,12 +208,11 @@ public:
      * @return An iterator to the entity following the last entity that has the
      * given components.
      */
-    iterator_type end() const ENTT_NOEXCEPT {
-        iterator_type it{};
+    iterator end() const {
+        iterator it{};
 
         if(valid()) {
-            const auto &pool = *pools.front();
-            it = { pool.end(), pool.end(), nullptr, nullptr };
+            it = { pools, pools[0]->end() };
         }
 
         return it;
@@ -220,7 +223,7 @@ public:
      * @param entt A valid entity identifier.
      * @return True if the view contains the given entity, false otherwise.
      */
-    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
+    bool contains(const entity_type entt) const {
         return valid() && std::all_of(pools.cbegin(), pools.cend(), [entt](const auto *view) {
             return view->find(entt) != view->end();
         });
@@ -243,7 +246,9 @@ public:
      */
     template<typename Func>
     void each(Func func) const {
-        std::for_each(begin(), end(), func);
+        for(const auto entity: *this) {
+            func(entity);
+        }
     }
 
 private:
@@ -254,4 +259,4 @@ private:
 }
 
 
-#endif // ENTT_ENTITY_RUNTIME_VIEW_HPP
+#endif

src/entt/entity/snapshot.hpp

@@ -3,6 +3,7 @@
 
 
 #include <array>
+#include <vector>
 #include <cstddef>
 #include <utility>
 #include <iterator>
@@ -31,15 +32,8 @@ class basic_snapshot {
     /*! @brief A registry is allowed to create snapshots. */
     friend class basic_registry<Entity>;
 
-    using follow_fn_type = Entity(const basic_registry<Entity> &, const Entity);
     using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
-    basic_snapshot(const basic_registry<Entity> *source, Entity init, follow_fn_type *fn) ENTT_NOEXCEPT
-        : reg{source},
-          seed{init},
-          follow{fn}
-    {}
-
     template<typename Component, typename Archive, typename It>
     void get(Archive &archive, std::size_t sz, It first, It last) const {
         archive(typename traits_type::entity_type(sz));
@@ -71,6 +65,17 @@ class basic_snapshot {
     }
 
 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 &&) = default;
 
@@ -78,10 +83,10 @@ public:
     basic_snapshot & operator=(basic_snapshot &&) = default;
 
     /**
-     * @brief Puts aside all the entities that are still in use.
+     * @brief Puts aside all the entities from the underlying registry.
      *
      * Entities are serialized along with their versions. Destroyed entities are
-     * not taken in consideration by this function.
+     * taken in consideration as well by this function.
      *
      * @tparam Archive Type of output archive.
      * @param archive A valid reference to an output archive.
@@ -89,39 +94,28 @@ public:
      */
     template<typename Archive>
     const basic_snapshot & entities(Archive &archive) const {
-        archive(typename traits_type::entity_type(reg->alive()));
-        reg->each([&archive](const auto entt) { archive(entt); });
-        return *this;
-    }
+        const auto sz = reg->size();
+        auto first = reg->data();
+        const auto last = first + sz;
 
-    /**
-     * @brief Puts aside destroyed entities.
-     *
-     * Entities are serialized along with their versions. Entities that are
-     * still in use are not taken in consideration by this function.
-     *
-     * @tparam Archive Type of output archive.
-     * @param archive A valid reference to an output archive.
-     * @return An object of this type to continue creating the snapshot.
-     */
-    template<typename Archive>
-    const basic_snapshot & destroyed(Archive &archive) const {
-        auto size = reg->size() - reg->alive();
-        archive(typename traits_type::entity_type(size));
+        archive(typename traits_type::entity_type(sz));
 
-        if(size) {
-            auto curr = seed;
-            archive(curr);
-
-            for(--size; size; --size) {
-                curr = follow(*reg, curr);
-                archive(curr);
-            }
+        while(first != last) {
+            archive(*(first++));
         }
 
         return *this;
     }
 
+    /**
+     * @brief Deprecated function. Currently, it does nothing.
+     * @tparam Archive Type of output archive.
+     * @return An object of this type to continue creating the snapshot.
+     */
+    template<typename Archive>
+    [[deprecated("use ::entities instead, it exports now also destroyed entities")]]
+    const basic_snapshot & destroyed(Archive &) const { return *this; }
+
     /**
      * @brief Puts aside the given components.
      *
@@ -135,25 +129,7 @@ public:
      */
     template<typename... Component, typename Archive>
     const basic_snapshot & component(Archive &archive) const {
-        if constexpr(sizeof...(Component) == 1) {
-            const auto sz = reg->template size<Component...>();
-            const auto *entities = reg->template data<Component...>();
-
-            archive(typename traits_type::entity_type(sz));
-
-            for(std::remove_const_t<decltype(sz)> pos{}; pos < sz; ++pos) {
-                const auto entt = entities[pos];
-
-                if constexpr(std::is_empty_v<Component...>) {
-                    archive(entt);
-                } else {
-                    archive(entt, reg->template get<Component...>(entt));
-                }
-            };
-        } else {
-            (component<Component>(archive), ...);
-        }
-
+        (component<Component>(archive, reg->template data<Component>(), reg->template data<Component>() + reg->template size<Component>()), ...);
         return *this;
     }
 
@@ -173,14 +149,12 @@ public:
      */
     template<typename... Component, typename Archive, typename It>
     const basic_snapshot & component(Archive &archive, It first, It last) const {
-        component<Component...>(archive, first, last, std::make_index_sequence<sizeof...(Component)>{});
+        component<Component...>(archive, first, last, std::index_sequence_for<Component...>{});
         return *this;
     }
 
 private:
-    const basic_registry<Entity> *reg;
-    const Entity seed;
-    follow_fn_type *follow;
+    const basic_registry<entity_type> *reg;
 };
 
 
@@ -199,52 +173,46 @@ class basic_snapshot_loader {
     /*! @brief A registry is allowed to create snapshot loaders. */
     friend class basic_registry<Entity>;
 
-    using force_fn_type = void(basic_registry<Entity> &, const Entity, const bool);
     using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
-    basic_snapshot_loader(basic_registry<Entity> *source, force_fn_type *fn) ENTT_NOEXCEPT
-        : reg{source},
-          force{fn}
-    {
-        // to restore a snapshot as a whole requires a clean registry
-        ENTT_ASSERT(reg->empty());
-    }
-
-    template<typename Archive>
-    void assure(Archive &archive, bool discard) const {
-        typename traits_type::entity_type length{};
-        archive(length);
-
-        while(length--) {
-            Entity entt{};
-            archive(entt);
-            force(*reg, entt, discard);
-        }
-    }
-
     template<typename Type, typename Archive, typename... Args>
     void assign(Archive &archive, Args... args) const {
         typename traits_type::entity_type length{};
         archive(length);
 
         while(length--) {
-            static constexpr auto discard = false;
-            Entity entt{};
+            entity_type entt{};
 
             if constexpr(std::is_empty_v<Type>) {
                 archive(entt);
-                force(*reg, entt, discard);
-                reg->template assign<Type>(args..., entt);
+                const auto entity = reg->valid(entt) ? entt : reg->create(entt);
+                ENTT_ASSERT(entity == entt);
+                reg->template emplace<Type>(args..., entt);
             } else {
                 Type instance{};
                 archive(entt, instance);
-                force(*reg, entt, discard);
-                reg->template assign<Type>(args..., entt, std::as_const(instance));
+                const auto entity = reg->valid(entt) ? entt : reg->create(entt);
+                ENTT_ASSERT(entity == entt);
+                reg->template emplace<Type>(args..., entt, std::as_const(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());
+    }
+
     /*! @brief Default move constructor. */
     basic_snapshot_loader(basic_snapshot_loader &&) = default;
 
@@ -263,27 +231,28 @@ public:
      */
     template<typename Archive>
     const basic_snapshot_loader & entities(Archive &archive) const {
-        static constexpr auto discard = false;
-        assure(archive, discard);
+        typename traits_type::entity_type length{};
+
+        archive(length);
+        std::vector<entity_type> all(length);
+
+        for(decltype(length) pos{}; pos < length; ++pos) {
+            archive(all[pos]);
+        }
+
+        reg->assign(all.cbegin(), all.cend());
+
         return *this;
     }
 
     /**
-     * @brief Restores entities that were destroyed during serialization.
-     *
-     * This function restores the entities that were destroyed during
-     * serialization and gives them the versions they originally had.
-     *
+     * @brief Deprecated function. Currently, it does nothing.
      * @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 & destroyed(Archive &archive) const {
-        static constexpr auto discard = true;
-        assure(archive, discard);
-        return *this;
-    }
+    [[deprecated("use ::entities instead, it imports now also destroyed entities")]]
+    const basic_snapshot_loader & destroyed(Archive &) const { return *this; }
 
     /**
      * @brief Restores components and assigns them to the right entities.
@@ -323,8 +292,7 @@ public:
     }
 
 private:
-    basic_registry<Entity> *reg;
-    force_fn_type *force;
+    basic_registry<entity_type> *reg;
 };
 
 
@@ -332,7 +300,7 @@ private:
  * @brief Utility class for _continuous loading_.
  *
  * A _continuous loader_ is designed to load data from a source registry to a
- * (possibly) non-empty destination. The loader can accomodate in a registry
+ * (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.
@@ -371,39 +339,59 @@ class basic_continuous_loader {
         }
     }
 
-    template<typename Other, typename Type, typename Member>
-    void update(Other &instance, Member Type:: *member) {
-        if constexpr(!std::is_same_v<Other, Type>) {
-            return;
-        } else if constexpr(std::is_same_v<Member, Entity>) {
-            instance.*member = map(instance.*member);
-        } else {
-            // maybe a container? let's try...
-            for(auto &entt: instance.*member) {
-                entt = map(entt);
+    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>);
+                other.emplace(std::move(pair.first), map(pair.second));
             }
         }
+
+        std::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>);
+
+        for(auto &&entt: container) {
+            entt = map(entt);
+        }
     }
 
-    template<typename Archive>
-    void assure(Archive &archive, void(basic_continuous_loader:: *member)(Entity)) {
-        typename traits_type::entity_type length{};
-        archive(length);
-
-        while(length--) {
-            Entity entt{};
-            archive(entt);
-            (this->*member)(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 reset() {
+    void remove_if_exists() {
         for(auto &&ref: remloc) {
             const auto local = ref.second.first;
 
             if(reg->valid(local)) {
-                reg->template reset<Component>(local);
+                reg->template remove_if_exists<Component>(local);
             }
         }
     }
@@ -414,18 +402,18 @@ class basic_continuous_loader {
         archive(length);
 
         while(length--) {
-            Entity entt{};
+            entity_type entt{};
 
             if constexpr(std::is_empty_v<Other>) {
                 archive(entt);
                 restore(entt);
-                reg->template assign_or_replace<Other>(map(entt));
+                reg->template emplace_or_replace<Other>(map(entt));
             } else {
                 Other instance{};
                 archive(entt, instance);
                 (update(instance, member), ...);
                 restore(entt);
-                reg->template assign_or_replace<Other>(map(entt), std::as_const(instance));
+                reg->template emplace_or_replace<Other>(map(entt), std::as_const(instance));
             }
         }
     }
@@ -435,7 +423,7 @@ public:
     using entity_type = Entity;
 
     /**
-     * @brief Constructs a loader that is bound to a given registry.
+     * @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
@@ -460,25 +448,32 @@ public:
      */
     template<typename Archive>
     basic_continuous_loader & entities(Archive &archive) {
-        assure(archive, &basic_continuous_loader::restore);
+        typename traits_type::entity_type length{};
+        entity_type entt{};
+
+        archive(length);
+
+        for(decltype(length) pos{}; pos < length; ++pos) {
+            archive(entt);
+
+            if(const auto entity = (to_integral(entt) & traits_type::entity_mask); entity == pos) {
+                restore(entt);
+            } else {
+                destroy(entt);
+            }
+        }
+
         return *this;
     }
 
     /**
-     * @brief Restores entities that were destroyed during serialization.
-     *
-     * This function restores the entities that were destroyed during
-     * serialization and creates local counterparts for them if required.
-     *
+     * @brief Deprecated function. Currently, it does nothing.
      * @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 & destroyed(Archive &archive) {
-        assure(archive, &basic_continuous_loader::destroy);
-        return *this;
-    }
+    [[deprecated("use ::entities instead, it imports now also destroyed entities")]]
+    basic_continuous_loader & destroyed(Archive &) { return *this; }
 
     /**
      * @brief Restores components and assigns them to the right entities.
@@ -501,7 +496,7 @@ public:
      */
     template<typename... Component, typename Archive, typename... Type, typename... Member>
     basic_continuous_loader & component(Archive &archive, Member Type:: *... member) {
-        (reset<Component>(), ...);
+        (remove_if_exists<Component>(), ...);
         (assign<Component>(archive, member...), ...);
         return *this;
     }
@@ -559,10 +554,16 @@ public:
      * @param entt An entity identifier.
      * @return True if `entity` is managed by the loader, false otherwise.
      */
-    bool has(entity_type entt) const ENTT_NOEXCEPT {
+    bool contains(entity_type entt) const ENTT_NOEXCEPT {
         return (remloc.find(entt) != remloc.cend());
     }
 
+    /*! @copydoc contains */
+    [[deprecated("use ::contains instead")]]
+    bool has(entity_type entt) const ENTT_NOEXCEPT {
+        return contains(entt);
+    }
+
     /**
      * @brief Returns the identifier to which an entity refers.
      * @param entt An entity identifier.
@@ -588,4 +589,4 @@ private:
 }
 
 
-#endif // ENTT_ENTITY_SNAPSHOT_HPP
+#endif

src/entt/entity/sparse_set.hpp

@@ -2,13 +2,11 @@
 #define ENTT_ENTITY_SPARSE_SET_HPP
 
 
-#include <algorithm>
 #include <iterator>
 #include <utility>
 #include <vector>
 #include <memory>
 #include <cstddef>
-#include <numeric>
 #include <type_traits>
 #include "../config/config.h"
 #include "../core/algorithm.hpp"
@@ -48,19 +46,20 @@ namespace entt {
  */
 template<typename Entity>
 class sparse_set {
-    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
-
     static_assert(ENTT_PAGE_SIZE && ((ENTT_PAGE_SIZE & (ENTT_PAGE_SIZE - 1)) == 0));
-    static constexpr auto entt_per_page = ENTT_PAGE_SIZE / sizeof(typename traits_type::entity_type);
+    static constexpr auto entt_per_page = ENTT_PAGE_SIZE / sizeof(Entity);
 
-    class iterator {
+    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
+    using page_type = std::unique_ptr<Entity[]>;
+
+    class sparse_set_iterator final {
         friend class sparse_set<Entity>;
 
-        using direct_type = const std::vector<Entity>;
+        using packed_type = std::vector<Entity>;
         using index_type = typename traits_type::difference_type;
 
-        iterator(direct_type *ref, const index_type idx) ENTT_NOEXCEPT
-            : direct{ref}, index{idx}
+        sparse_set_iterator(const packed_type &ref, const index_type idx) ENTT_NOEXCEPT
+            : packed{&ref}, index{idx}
         {}
 
     public:
@@ -70,107 +69,113 @@ class sparse_set {
         using reference = const value_type &;
         using iterator_category = std::random_access_iterator_tag;
 
-        iterator() ENTT_NOEXCEPT = default;
+        sparse_set_iterator() ENTT_NOEXCEPT = default;
 
-        iterator & operator++() ENTT_NOEXCEPT {
+        sparse_set_iterator & operator++() ENTT_NOEXCEPT {
             return --index, *this;
         }
 
-        iterator operator++(int) ENTT_NOEXCEPT {
+        sparse_set_iterator operator++(int) ENTT_NOEXCEPT {
             iterator orig = *this;
-            return ++(*this), orig;
+            return operator++(), orig;
         }
 
-        iterator & operator--() ENTT_NOEXCEPT {
+        sparse_set_iterator & operator--() ENTT_NOEXCEPT {
             return ++index, *this;
         }
 
-        iterator operator--(int) ENTT_NOEXCEPT {
-            iterator orig = *this;
-            return --(*this), orig;
+        sparse_set_iterator operator--(int) ENTT_NOEXCEPT {
+            sparse_set_iterator orig = *this;
+            return operator--(), orig;
         }
 
-        iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
+        sparse_set_iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
             index -= value;
             return *this;
         }
 
-        iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
-            return iterator{direct, index-value};
+        sparse_set_iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
+            sparse_set_iterator copy = *this;
+            return (copy += value);
         }
 
-        iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
+        sparse_set_iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
             return (*this += -value);
         }
 
-        iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
+        sparse_set_iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
             return (*this + -value);
         }
 
-        difference_type operator-(const iterator &other) const ENTT_NOEXCEPT {
+        difference_type operator-(const sparse_set_iterator &other) const ENTT_NOEXCEPT {
             return other.index - index;
         }
 
-        reference operator[](const difference_type value) const ENTT_NOEXCEPT {
+        reference operator[](const difference_type value) const {
             const auto pos = size_type(index-value-1);
-            return (*direct)[pos];
+            return (*packed)[pos];
         }
 
-        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator==(const sparse_set_iterator &other) const ENTT_NOEXCEPT {
             return other.index == index;
         }
 
-        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator!=(const sparse_set_iterator &other) const ENTT_NOEXCEPT {
             return !(*this == other);
         }
 
-        bool operator<(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator<(const sparse_set_iterator &other) const ENTT_NOEXCEPT {
             return index > other.index;
         }
 
-        bool operator>(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator>(const sparse_set_iterator &other) const ENTT_NOEXCEPT {
             return index < other.index;
         }
 
-        bool operator<=(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator<=(const sparse_set_iterator &other) const ENTT_NOEXCEPT {
             return !(*this > other);
         }
 
-        bool operator>=(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator>=(const sparse_set_iterator &other) const ENTT_NOEXCEPT {
             return !(*this < other);
         }
 
-        pointer operator->() const ENTT_NOEXCEPT {
+        pointer operator->() const {
             const auto pos = size_type(index-1);
-            return &(*direct)[pos];
+            return &(*packed)[pos];
         }
 
-        reference operator*() const ENTT_NOEXCEPT {
+        reference operator*() const {
             return *operator->();
         }
 
     private:
-        direct_type *direct;
+        const packed_type *packed;
         index_type index;
     };
 
-    void assure(const std::size_t page) {
-        if(!(page < reverse.size())) {
-            reverse.resize(page+1);
-        }
-
-        if(!reverse[page]) {
-            reverse[page] = std::make_unique<entity_type[]>(entt_per_page);
-            // null is safe in all cases for our purposes
-            std::fill_n(reverse[page].get(), entt_per_page, null);
-        }
+    auto page(const Entity entt) const ENTT_NOEXCEPT {
+        return std::size_t{(to_integral(entt) & traits_type::entity_mask) / entt_per_page};
     }
 
-    auto map(const Entity entt) const ENTT_NOEXCEPT {
-        const auto identifier = to_integer(entt) & traits_type::entity_mask;
-        const auto page = size_type(identifier / entt_per_page);
-        const auto offset = size_type(identifier & (entt_per_page - 1));
-        return std::make_pair(page, offset);
+    auto offset(const Entity entt) const ENTT_NOEXCEPT {
+        return std::size_t{to_integral(entt) & (entt_per_page - 1)};
+    }
+
+    page_type & assure(const std::size_t pos) {
+        if(!(pos < sparse.size())) {
+            sparse.resize(pos+1);
+        }
+
+        if(!sparse[pos]) {
+            sparse[pos] = std::make_unique<entity_type[]>(entt_per_page);
+            // null is safe in all cases for our purposes
+            for(auto *first = sparse[pos].get(), *last = first + entt_per_page; first != last; ++first) {
+                *first = null;
+            }
+        }
+
+        return sparse[pos];
     }
 
 public:
@@ -179,46 +184,16 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Random access iterator type. */
-    using iterator_type = iterator;
+    using iterator = sparse_set_iterator;
 
     /*! @brief Default constructor. */
     sparse_set() = default;
 
-    /**
-     * @brief Copy constructor.
-     * @param other The instance to copy from.
-     */
-    sparse_set(const sparse_set &other)
-        : reverse{},
-          direct{other.direct}
-    {
-        for(size_type pos{}, last = other.reverse.size(); pos < last; ++pos) {
-            if(other.reverse[pos]) {
-                assure(pos);
-                std::copy_n(other.reverse[pos].get(), entt_per_page, reverse[pos].get());
-            }
-        }
-    }
-
     /*! @brief Default move constructor. */
     sparse_set(sparse_set &&) = default;
 
     /*! @brief Default destructor. */
-    virtual ~sparse_set() ENTT_NOEXCEPT = default;
-
-    /**
-     * @brief Copy assignment operator.
-     * @param other The instance to copy from.
-     * @return This sparse set.
-     */
-    sparse_set & operator=(const sparse_set &other) {
-        if(&other != this) {
-            auto tmp{other};
-            *this = std::move(tmp);
-        }
-
-        return *this;
-    }
+    virtual ~sparse_set() = default;
 
     /*! @brief Default move assignment operator. @return This sparse set. */
     sparse_set & operator=(sparse_set &&) = default;
@@ -232,7 +207,7 @@ public:
      * @param cap Desired capacity.
      */
     void reserve(const size_type cap) {
-        direct.reserve(cap);
+        packed.reserve(cap);
     }
 
     /**
@@ -241,18 +216,18 @@ public:
      * @return Capacity of the sparse set.
      */
     size_type capacity() const ENTT_NOEXCEPT {
-        return direct.capacity();
+        return packed.capacity();
     }
 
     /*! @brief Requests the removal of unused capacity. */
     void shrink_to_fit() {
         // conservative approach
-        if(direct.empty()) {
-            reverse.clear();
+        if(packed.empty()) {
+            sparse.clear();
         }
 
-        reverse.shrink_to_fit();
-        direct.shrink_to_fit();
+        sparse.shrink_to_fit();
+        packed.shrink_to_fit();
     }
 
     /**
@@ -266,7 +241,7 @@ public:
      * @return Extent of the sparse set.
      */
     size_type extent() const ENTT_NOEXCEPT {
-        return reverse.size() * entt_per_page;
+        return sparse.size() * entt_per_page;
     }
 
     /**
@@ -280,7 +255,7 @@ public:
      * @return Number of elements.
      */
     size_type size() const ENTT_NOEXCEPT {
-        return direct.size();
+        return packed.size();
     }
 
     /**
@@ -288,7 +263,7 @@ public:
      * @return True if the sparse set is empty, false otherwise.
      */
     bool empty() const ENTT_NOEXCEPT {
-        return direct.empty();
+        return packed.empty();
     }
 
     /**
@@ -307,7 +282,7 @@ public:
      * @return A pointer to the internal packed array.
      */
     const entity_type * data() const ENTT_NOEXCEPT {
-        return direct.data();
+        return packed.data();
     }
 
     /**
@@ -323,9 +298,9 @@ public:
      *
      * @return An iterator to the first entity of the internal packed array.
      */
-    iterator_type begin() const ENTT_NOEXCEPT {
-        const typename traits_type::difference_type pos = direct.size();
-        return iterator_type{&direct, pos};
+    iterator begin() const ENTT_NOEXCEPT {
+        const typename traits_type::difference_type pos = packed.size();
+        return iterator{packed, pos};
     }
 
     /**
@@ -342,8 +317,8 @@ public:
      * @return An iterator to the element following the last entity of the
      * internal packed array.
      */
-    iterator_type end() const ENTT_NOEXCEPT {
-        return iterator_type{&direct, {}};
+    iterator end() const ENTT_NOEXCEPT {
+        return iterator{packed, {}};
     }
 
     /**
@@ -352,8 +327,8 @@ public:
      * @return An iterator to the given entity if it's found, past the end
      * iterator otherwise.
      */
-    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
-        return has(entt) ? --(end() - index(entt)) : end();
+    iterator find(const entity_type entt) const {
+        return contains(entt) ? --(end() - index(entt)) : end();
     }
 
     /**
@@ -361,10 +336,16 @@ public:
      * @param entt A valid entity identifier.
      * @return True if the sparse set contains the entity, false otherwise.
      */
-    bool has(const entity_type entt) const ENTT_NOEXCEPT {
-        auto [page, offset] = map(entt);
-        // testing against null permits to avoid accessing the direct vector
-        return (page < reverse.size() && reverse[page] && reverse[page][offset] != null);
+    bool contains(const entity_type entt) const {
+        const auto curr = page(entt);
+        // testing against null permits to avoid accessing the packed array
+        return (curr < sparse.size() && sparse[curr] && sparse[curr][offset(entt)] != null);
+    }
+
+    /*! @copydoc contains */
+    [[deprecated("use ::contains instead")]]
+    bool has(const entity_type entt) const {
+        return contains(entt);
     }
 
     /**
@@ -379,10 +360,9 @@ public:
      * @param entt A valid entity identifier.
      * @return The position of the entity in the sparse set.
      */
-    size_type index(const entity_type entt) const ENTT_NOEXCEPT {
-        ENTT_ASSERT(has(entt));
-        auto [page, offset] = map(entt);
-        return size_type(reverse[page][offset]);
+    size_type index(const entity_type entt) const {
+        ENTT_ASSERT(contains(entt));
+        return size_type(sparse[page(entt)][offset(entt)]);
     }
 
     /**
@@ -396,12 +376,16 @@ public:
      *
      * @param entt A valid entity identifier.
      */
+    void emplace(const entity_type entt) {
+        ENTT_ASSERT(!contains(entt));
+        assure(page(entt))[offset(entt)] = entity_type(packed.size());
+        packed.push_back(entt);
+    }
+
+    /*! @copydoc emplace */
+    [[deprecated("use ::emplace instead")]]
     void construct(const entity_type entt) {
-        ENTT_ASSERT(!has(entt));
-        auto [page, offset] = map(entt);
-        assure(page);
-        reverse[page][offset] = entity_type(direct.size());
-        direct.push_back(entt);
+        emplace(entt);
     }
 
     /**
@@ -413,20 +397,27 @@ public:
      * An assertion will abort the execution at runtime in debug mode if the
      * sparse set already contains the given entity.
      *
-     * @tparam It Type of forward iterator.
+     * @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.
      */
     template<typename It>
-    void batch(It first, It last) {
-        std::for_each(first, last, [this, next = direct.size()](const auto entt) mutable {
-            ENTT_ASSERT(!has(entt));
-            auto [page, offset] = map(entt);
-            assure(page);
-            reverse[page][offset] = entity_type(next++);
-        });
+    void insert(It first, It last) {
+        auto next = packed.size();
+        packed.insert(packed.end(), first, last);
 
-        direct.insert(direct.end(), first, last);
+        while(first != last) {
+            const auto entt = *(first++);
+            ENTT_ASSERT(!contains(entt));
+            assure(page(entt))[offset(entt)] = entity_type(next++);
+        }
+    }
+
+    /*! @copydoc insert */
+    template<typename It>
+    [[deprecated("use ::insert instead")]]
+    void construct(It first, It last) {
+        insert(std::move(first), std::move(last));
     }
 
     /**
@@ -440,14 +431,20 @@ public:
      *
      * @param entt A valid entity identifier.
      */
+    void erase(const entity_type entt) {
+        ENTT_ASSERT(contains(entt));
+        const auto curr = page(entt);
+        const auto pos = offset(entt);
+        packed[size_type(sparse[curr][pos])] = entity_type(packed.back());
+        sparse[page(packed.back())][offset(packed.back())] = sparse[curr][pos];
+        sparse[curr][pos] = null;
+        packed.pop_back();
+    }
+
+    /*! @copydoc erase */
+    [[deprecated("use ::erase instead")]]
     void destroy(const entity_type entt) {
-        ENTT_ASSERT(has(entt));
-        auto [from_page, from_offset] = map(entt);
-        auto [to_page, to_offset] = map(direct.back());
-        direct[size_type(reverse[from_page][from_offset])] = entity_type(direct.back());
-        reverse[to_page][to_offset] = reverse[from_page][from_offset];
-        reverse[from_page][from_offset] = null;
-        direct.pop_back();
+        erase(entt);
     }
 
     /**
@@ -462,16 +459,14 @@ public:
      * An assertion will abort the execution at runtime in debug mode if the
      * sparse set doesn't contain the given entities.
      *
-     * @param lhs A valid position within the sparse set.
-     * @param rhs A valid position within the sparse set.
+     * @param lhs A valid entity identifier.
+     * @param rhs A valid entity identifier.
      */
-    virtual void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT {
-        ENTT_ASSERT(lhs < direct.size());
-        ENTT_ASSERT(rhs < direct.size());
-        auto [src_page, src_offset] = map(direct[lhs]);
-        auto [dst_page, dst_offset] = map(direct[rhs]);
-        std::swap(reverse[src_page][src_offset], reverse[dst_page][dst_offset]);
-        std::swap(direct[lhs], direct[rhs]);
+    virtual void swap(const entity_type lhs, const entity_type rhs) {
+        auto &from = sparse[page(lhs)][offset(lhs)];
+        auto &to = sparse[page(rhs)][offset(rhs)];
+        std::swap(packed[size_type(from)], packed[size_type(to)]);
+        std::swap(from, to);
     }
 
     /**
@@ -499,14 +494,10 @@ public:
      * * An iterator past the last element of the range to sort.
      * * A comparison function to use to compare the elements.
      *
-     * The comparison function object received by the sort function object
-     * hasn't necessarily the type of the one passed along with the other
-     * parameters to this member function.
-     *
      * @note
      * Attempting to iterate elements using a raw pointer returned by a call to
-     * either `data` or `raw` gives no guarantees on the order, even though
-     * `sort` has been invoked.
+     * `data` gives no guarantees on the order, even though `sort` has been
+     * invoked.
      *
      * @tparam Compare Type of comparison function object.
      * @tparam Sort Type of sort function object.
@@ -518,26 +509,71 @@ public:
      * @param args Arguments to forward to the sort function object, if any.
      */
     template<typename Compare, typename Sort = std_sort, typename... Args>
-    void sort(iterator_type first, iterator_type last, Compare compare, Sort algo = Sort{}, Args &&... args) {
-        ENTT_ASSERT(!(first > last));
+    void sort(iterator first, iterator last, Compare compare, Sort algo = Sort{}, Args &&... args) {
+        ENTT_ASSERT(!(last < first));
+        ENTT_ASSERT(!(last > end()));
 
-        std::vector<size_type> copy(last - first);
-        const auto offset = std::distance(last, end());
-        std::iota(copy.begin(), copy.end(), size_type{});
+        const auto length = std::distance(first, last);
+        const auto skip = std::distance(last, end());
+        const auto to = packed.rend() - skip;
+        const auto from = to - length;
 
-        algo(copy.rbegin(), copy.rend(), [this, offset, compare = std::move(compare)](const auto lhs, const auto rhs) {
-            return compare(std::as_const(direct[lhs+offset]), std::as_const(direct[rhs+offset]));
-        }, std::forward<Args>(args)...);
+        algo(from, to, std::move(compare), std::forward<Args>(args)...);
 
-        for(size_type pos{}, length = copy.size(); pos < length; ++pos) {
+        for(size_type pos = skip, end = skip+length; pos < end; ++pos) {
+            sparse[page(packed[pos])][offset(packed[pos])] = entity_type(pos);
+        }
+    }
+
+    /**
+     * @brief Sort elements according to the given comparison function.
+     *
+     * @sa sort
+     *
+     * This function is a slightly slower version of `sort` that invokes the
+     * caller to indicate which entities are swapped.<br/>
+     * It's recommended when the caller wants to sort its own data structures to
+     * align them with the order induced in the sparse set.
+     *
+     * The signature of the callback should be equivalent to the following:
+     *
+     * @code{.cpp}
+     * bool(const Entity, const Entity);
+     * @endcode
+     *
+     * @tparam Apply Type of function object to invoke to notify the caller.
+     * @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 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 apply A valid function object to use as a callback.
+     * @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 Apply, typename Compare, typename Sort = std_sort, typename... Args>
+    void arrange(iterator first, iterator last, Apply apply, Compare compare, Sort algo = Sort{}, Args &&... args) {
+        ENTT_ASSERT(!(last < first));
+        ENTT_ASSERT(!(last > end()));
+
+        const auto length = std::distance(first, last);
+        const auto skip = std::distance(last, end());
+        const auto to = packed.rend() - skip;
+        const auto from = to - length;
+
+        algo(from, to, std::move(compare), std::forward<Args>(args)...);
+
+        for(size_type pos = skip, end = skip+length; pos < end; ++pos) {
             auto curr = pos;
-            auto next = copy[curr];
+            auto next = index(packed[curr]);
 
             while(curr != next) {
-                swap(copy[curr] + offset, copy[next] + offset);
-                copy[curr] = curr;
+                apply(packed[curr], packed[next]);
+                sparse[page(packed[curr])][offset(packed[curr])] = entity_type(curr);
+
                 curr = next;
-                next = copy[curr];
+                next = index(packed[curr]);
             }
         }
     }
@@ -556,21 +592,22 @@ public:
      * more details.
      *
      * @note
-     * Attempting to iterate elements using the raw pointer returned by `data`
-     * gives no guarantees on the order, even though `respect` has been invoked.
+     * Attempting to iterate elements using a raw pointer returned by a call to
+     * `data` gives no guarantees on the order, even though `respect` has been
+     * invoked.
      *
      * @param other The sparse sets that imposes the order of the entities.
      */
-    void respect(const sparse_set &other) ENTT_NOEXCEPT {
+    void respect(const sparse_set &other) {
         const auto to = other.end();
         auto from = other.begin();
 
-        size_type pos = direct.size() - 1;
+        size_type pos = packed.size() - 1;
 
         while(pos && from != to) {
-            if(has(*from)) {
-                if(*from != direct[pos]) {
-                    swap(pos, index(*from));
+            if(contains(*from)) {
+                if(*from != packed[pos]) {
+                    swap(packed[pos], *from);
                 }
 
                 --pos;
@@ -581,20 +618,20 @@ public:
     }
 
     /**
-     * @brief Resets a sparse set.
+     * @brief Clears a sparse set.
      */
-    void reset() {
-        reverse.clear();
-        direct.clear();
+    void clear() ENTT_NOEXCEPT {
+        sparse.clear();
+        packed.clear();
     }
 
 private:
-    std::vector<std::unique_ptr<entity_type[]>> reverse;
-    std::vector<entity_type> direct;
+    std::vector<page_type> sparse;
+    std::vector<entity_type> packed;
 };
 
 
 }
 
 
-#endif // ENTT_ENTITY_SPARSE_SET_HPP
+#endif

src/entt/entity/storage.hpp

@@ -4,7 +4,6 @@
 
 #include <algorithm>
 #include <iterator>
-#include <numeric>
 #include <utility>
 #include <vector>
 #include <cstddef>
@@ -38,9 +37,8 @@ namespace entt {
  * functions for that). Use `begin` and `end` instead.
  *
  * @warning
- * Empty types aren't explicitly instantiated. Temporary objects are returned in
- * place of the instances of the components and raw access isn't available for
- * them.
+ * Empty types aren't explicitly instantiated. Therefore, many of the functions
+ * normally available for non-empty types will not be available for empty ones.
  *
  * @sa sparse_set<Entity>
  *
@@ -48,19 +46,22 @@ namespace entt {
  * @tparam Type Type of objects assigned to the entities.
  */
 template<typename Entity, typename Type, typename = std::void_t<>>
-class basic_storage: public sparse_set<Entity> {
+class storage: public sparse_set<Entity> {
+    static_assert(std::is_move_constructible_v<Type>);
+    static_assert(std::is_move_assignable_v<Type>);
+
     using underlying_type = sparse_set<Entity>;
     using traits_type = entt_traits<std::underlying_type_t<Entity>>;
 
     template<bool Const>
-    class iterator {
-        friend class basic_storage<Entity, Type>;
+    class storage_iterator final {
+        friend class storage<Entity, Type>;
 
         using instance_type = std::conditional_t<Const, const std::vector<Type>, std::vector<Type>>;
         using index_type = typename traits_type::difference_type;
 
-        iterator(instance_type *ref, const index_type idx) ENTT_NOEXCEPT
-            : instances{ref}, index{idx}
+        storage_iterator(instance_type &ref, const index_type idx) ENTT_NOEXCEPT
+            : instances{&ref}, index{idx}
         {}
 
     public:
@@ -70,44 +71,45 @@ class basic_storage: public sparse_set<Entity> {
         using reference = std::conditional_t<Const, const value_type &, value_type &>;
         using iterator_category = std::random_access_iterator_tag;
 
-        iterator() ENTT_NOEXCEPT = default;
+        storage_iterator() ENTT_NOEXCEPT = default;
 
-        iterator & operator++() ENTT_NOEXCEPT {
+        storage_iterator & operator++() ENTT_NOEXCEPT {
             return --index, *this;
         }
 
-        iterator operator++(int) ENTT_NOEXCEPT {
-            iterator orig = *this;
-            return ++(*this), orig;
+        storage_iterator operator++(int) ENTT_NOEXCEPT {
+            storage_iterator orig = *this;
+            return operator++(), orig;
         }
 
-        iterator & operator--() ENTT_NOEXCEPT {
+        storage_iterator & operator--() ENTT_NOEXCEPT {
             return ++index, *this;
         }
 
-        iterator operator--(int) ENTT_NOEXCEPT {
-            iterator orig = *this;
-            return --(*this), orig;
+        storage_iterator operator--(int) ENTT_NOEXCEPT {
+            storage_iterator orig = *this;
+            return operator--(), orig;
         }
 
-        iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
+        storage_iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
             index -= value;
             return *this;
         }
 
-        iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
-            return iterator{instances, index-value};
+        storage_iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
+            storage_iterator copy = *this;
+            return (copy += value);
         }
 
-        iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
+        storage_iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
             return (*this += -value);
         }
 
-        iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
+        storage_iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
             return (*this + -value);
         }
 
-        difference_type operator-(const iterator &other) const ENTT_NOEXCEPT {
+        difference_type operator-(const storage_iterator &other) const ENTT_NOEXCEPT {
             return other.index - index;
         }
 
@@ -116,27 +118,27 @@ class basic_storage: public sparse_set<Entity> {
             return (*instances)[pos];
         }
 
-        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator==(const storage_iterator &other) const ENTT_NOEXCEPT {
             return other.index == index;
         }
 
-        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator!=(const storage_iterator &other) const ENTT_NOEXCEPT {
             return !(*this == other);
         }
 
-        bool operator<(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator<(const storage_iterator &other) const ENTT_NOEXCEPT {
             return index > other.index;
         }
 
-        bool operator>(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator>(const storage_iterator &other) const ENTT_NOEXCEPT {
             return index < other.index;
         }
 
-        bool operator<=(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator<=(const storage_iterator &other) const ENTT_NOEXCEPT {
             return !(*this > other);
         }
 
-        bool operator>=(const iterator &other) const ENTT_NOEXCEPT {
+        bool operator>=(const storage_iterator &other) const ENTT_NOEXCEPT {
             return !(*this < other);
         }
 
@@ -162,9 +164,9 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Random access iterator type. */
-    using iterator_type = iterator<false>;
+    using iterator = storage_iterator<false>;
     /*! @brief Constant random access iterator type. */
-    using const_iterator_type = iterator<true>;
+    using const_iterator = storage_iterator<true>;
 
     /**
      * @brief Increases the capacity of a storage.
@@ -221,20 +223,20 @@ public:
      *
      * @return An iterator to the first instance of the given type.
      */
-    const_iterator_type cbegin() const ENTT_NOEXCEPT {
+    const_iterator cbegin() const ENTT_NOEXCEPT {
         const typename traits_type::difference_type pos = underlying_type::size();
-        return const_iterator_type{&instances, pos};
+        return const_iterator{instances, pos};
     }
 
     /*! @copydoc cbegin */
-    const_iterator_type begin() const ENTT_NOEXCEPT {
+    const_iterator begin() const ENTT_NOEXCEPT {
         return cbegin();
     }
 
     /*! @copydoc begin */
-    iterator_type begin() ENTT_NOEXCEPT {
+    iterator begin() ENTT_NOEXCEPT {
         const typename traits_type::difference_type pos = underlying_type::size();
-        return iterator_type{&instances, pos};
+        return iterator{instances, pos};
     }
 
     /**
@@ -251,18 +253,18 @@ public:
      * @return An iterator to the element following the last instance of the
      * given type.
      */
-    const_iterator_type cend() const ENTT_NOEXCEPT {
-        return const_iterator_type{&instances, {}};
+    const_iterator cend() const ENTT_NOEXCEPT {
+        return const_iterator{instances, {}};
     }
 
     /*! @copydoc cend */
-    const_iterator_type end() const ENTT_NOEXCEPT {
+    const_iterator end() const ENTT_NOEXCEPT {
         return cend();
     }
 
     /*! @copydoc end */
-    iterator_type end() ENTT_NOEXCEPT {
-        return iterator_type{&instances, {}};
+    iterator end() ENTT_NOEXCEPT {
+        return iterator{instances, {}};
     }
 
     /**
@@ -277,12 +279,12 @@ public:
      * @param entt A valid entity identifier.
      * @return The object associated with the entity.
      */
-    const object_type & get(const entity_type entt) const ENTT_NOEXCEPT {
+    const object_type & get(const entity_type entt) const {
         return instances[underlying_type::index(entt)];
     }
 
     /*! @copydoc get */
-    object_type & get(const entity_type entt) ENTT_NOEXCEPT {
+    object_type & get(const entity_type entt) {
         return const_cast<object_type &>(std::as_const(*this).get(entt));
     }
 
@@ -291,12 +293,12 @@ public:
      * @param entt A valid entity identifier.
      * @return The object associated with the entity, if any.
      */
-    const object_type * try_get(const entity_type entt) const ENTT_NOEXCEPT {
-        return underlying_type::has(entt) ? (instances.data() + underlying_type::index(entt)) : nullptr;
+    const object_type * try_get(const entity_type entt) const {
+        return underlying_type::contains(entt) ? (instances.data() + underlying_type::index(entt)) : nullptr;
     }
 
     /*! @copydoc try_get */
-    object_type * try_get(const entity_type entt) ENTT_NOEXCEPT {
+    object_type * try_get(const entity_type entt) {
         return const_cast<object_type *>(std::as_const(*this).try_get(entt));
     }
 
@@ -316,26 +318,29 @@ public:
      * @tparam Args Types of arguments to use to construct the object.
      * @param entt A valid entity identifier.
      * @param args Parameters to use to construct an object for the entity.
-     * @return The object associated with the entity.
      */
     template<typename... Args>
-    object_type & construct(const entity_type entt, Args &&... args) {
+    void emplace(const entity_type entt, Args &&... args) {
         if constexpr(std::is_aggregate_v<object_type>) {
-            instances.emplace_back(Type{std::forward<Args>(args)...});
+            instances.push_back(Type{std::forward<Args>(args)...});
         } else {
             instances.emplace_back(std::forward<Args>(args)...);
         }
 
         // entity goes after component in case constructor throws
-        underlying_type::construct(entt);
-        return instances.back();
+        underlying_type::emplace(entt);
+    }
+
+    /*! @copydoc emplace */
+    template<typename... Args>
+    [[deprecated("use ::emplace instead")]]
+    void construct(const entity_type entt, Args &&... args) {
+        emplace(entt, std::forward<Args>(args)...);
     }
 
     /**
-     * @brief Assigns one or more entities to a storage and default constructs
-     * their objects.
-     *
-     * The object type must be at least move and default insertable.
+     * @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
@@ -343,41 +348,52 @@ public:
      * An assertion will abort the execution at runtime in debug mode if the
      * storage already contains the given entity.
      *
-     * @tparam It Type of forward iterator.
+     * @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.
-     * @return An iterator to the list of instances just created and sorted the
-     * same of the entities.
+     * @param value An instance of the object to construct.
      */
     template<typename It>
-    iterator_type batch(It first, It last) {
-        instances.resize(instances.size() + std::distance(first, last));
-        // entity goes after component in case constructor throws
-        underlying_type::batch(first, last);
-        return begin();
+    void insert(It first, It last, const object_type &value = {}) {
+        instances.insert(instances.end(), std::distance(first, last), value);
+        // entities go after components in case constructors throw
+        underlying_type::insert(first, last);
+    }
+
+    /*! @copydoc insert */
+    template<typename It>
+    [[deprecated("use ::insert instead")]]
+    std::enable_if_t<std::is_same_v<typename std::iterator_traits<It>::value_type, entity_type>, void>
+    construct(It first, It last, const object_type &value = {}) {
+        insert(std::move(first), std::move(last), value);
     }
 
     /**
-     * @brief Assigns one or more entities to a storage and copy constructs
-     * their objects.
+     * @brief Assigns one or more entities to a storage and constructs their
+     * objects from a given range.
      *
-     * The object type must be at least move and copy insertable.
+     * @sa construct
      *
-     * @sa batch
-     *
-     * @tparam It Type of forward iterator.
+     * @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 value The value to initialize the new objects with.
-     * @return An iterator to the list of instances just created and sorted the
-     * same of the entities.
+     * @param from An iterator to the first element of the range of objects.
+     * @param to An iterator past the last element of the range of objects.
      */
-    template<typename It>
-    iterator_type batch(It first, It last, const object_type &value) {
-        instances.resize(instances.size() + std::distance(first, last), value);
-        // entity goes after component in case constructor throws
-        underlying_type::batch(first, last);
-        return begin();
+    template<typename EIt, typename CIt>
+    void insert(EIt first, EIt last, CIt from, CIt to) {
+        instances.insert(instances.end(), from, to);
+        // entities go after components in case constructors throw
+        underlying_type::insert(first, last);
+    }
+
+    /*! @copydoc insert */
+    template<typename EIt, typename CIt>
+    [[deprecated("use ::insert instead")]]
+    std::enable_if_t<std::is_same_v<typename std::iterator_traits<EIt>::value_type, entity_type>, void>
+    construct(EIt first, EIt last, CIt value) {
+        insert(std::move(first), std::move(last), std::move(value));
     }
 
     /**
@@ -391,11 +407,17 @@ public:
      *
      * @param entt A valid entity identifier.
      */
-    void destroy(const entity_type entt) {
+    void erase(const entity_type entt) {
         auto other = std::move(instances.back());
         instances[underlying_type::index(entt)] = std::move(other);
         instances.pop_back();
-        underlying_type::destroy(entt);
+        underlying_type::erase(entt);
+    }
+
+    /*! @copydoc erase */
+    [[deprecated("use ::erase instead")]]
+    void destroy(const entity_type entt) {
+        erase(entt);
     }
 
     /**
@@ -407,13 +429,11 @@ public:
      * An assertion will abort the execution at runtime in debug mode if the
      * sparse set doesn't contain the given entities.
      *
-     * @param lhs A valid position within the sparse set.
-     * @param rhs A valid position within the sparse set.
+     * @param lhs A valid entity identifier.
+     * @param rhs A valid entity identifier.
      */
-    void swap(const size_type lhs, const size_type rhs) ENTT_NOEXCEPT override {
-        ENTT_ASSERT(lhs < instances.size());
-        ENTT_ASSERT(rhs < instances.size());
-        std::swap(instances[lhs], instances[rhs]);
+    void swap(const entity_type lhs, const entity_type rhs) override {
+        std::swap(instances[underlying_type::index(lhs)], instances[underlying_type::index(rhs)]);
         underlying_type::swap(lhs, rhs);
     }
 
@@ -443,15 +463,16 @@ public:
      * * An iterator past the last element of the range to sort.
      * * A comparison function to use to compare the elements.
      *
-     * The comparison function object received by the sort function object
-     * hasn't necessarily the type of the one passed along with the other
-     * parameters to this member function.
-     *
      * @note
      * Attempting to iterate elements using a raw pointer returned by a call to
      * either `data` or `raw` gives no guarantees on the order, even though
      * `sort` has been invoked.
      *
+     * @warning
+     * Empty types are never instantiated. Therefore, only comparison function
+     * objects that require to return entities rather than components are
+     * accepted.
+     *
      * @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.
@@ -462,26 +483,29 @@ public:
      * @param args Arguments to forward to the sort function object, if any.
      */
     template<typename Compare, typename Sort = std_sort, typename... Args>
-    void sort(iterator_type first, iterator_type last, Compare compare, Sort algo = Sort{}, Args &&... args) {
-        ENTT_ASSERT(!(first > last));
+    void sort(iterator first, iterator last, Compare compare, Sort algo = Sort{}, Args &&... args) {
+        ENTT_ASSERT(!(last < first));
+        ENTT_ASSERT(!(last > end()));
 
         const auto from = underlying_type::begin() + std::distance(begin(), first);
         const auto to = from + std::distance(first, last);
 
-        if constexpr(std::is_invocable_v<Compare, const object_type &, const object_type &>) {
-            static_assert(!std::is_empty_v<object_type>);
+        const auto apply = [this](const auto lhs, const auto rhs) {
+            std::swap(instances[underlying_type::index(lhs)], instances[underlying_type::index(rhs)]);
+        };
 
-            underlying_type::sort(from, to, [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
+        if constexpr(std::is_invocable_v<Compare, const object_type &, const object_type &>) {
+            underlying_type::arrange(from, to, std::move(apply), [this, compare = std::move(compare)](const auto lhs, const auto rhs) {
                 return compare(std::as_const(instances[underlying_type::index(lhs)]), std::as_const(instances[underlying_type::index(rhs)]));
             }, std::move(algo), std::forward<Args>(args)...);
         } else {
-            underlying_type::sort(from, to, std::move(compare), std::move(algo), std::forward<Args>(args)...);
+            underlying_type::arrange(from, to, std::move(apply), std::move(compare), std::move(algo), std::forward<Args>(args)...);
         }
     }
 
-    /*! @brief Resets a storage. */
-    void reset() {
-        underlying_type::reset();
+    /*! @brief Clears a storage. */
+    void clear() {
+        underlying_type::clear();
         instances.clear();
     }
 
@@ -490,109 +514,12 @@ private:
 };
 
 
-/*! @copydoc basic_storage */
+/*! @copydoc storage */
 template<typename Entity, typename Type>
-class basic_storage<Entity, Type, std::enable_if_t<std::is_empty_v<Type>>>: public sparse_set<Entity> {
+class storage<Entity, Type, std::enable_if_t<ENTT_IS_EMPTY(Type)>>: public sparse_set<Entity> {
     using traits_type = entt_traits<std::underlying_type_t<Entity>>;
     using underlying_type = sparse_set<Entity>;
 
-    class iterator {
-        friend class basic_storage<Entity, Type>;
-
-        using index_type = typename traits_type::difference_type;
-
-        iterator(const index_type idx) ENTT_NOEXCEPT
-            : index{idx}
-        {}
-
-    public:
-        using difference_type = index_type;
-        using value_type = Type;
-        using pointer = const value_type *;
-        using reference = value_type;
-        using iterator_category = std::input_iterator_tag;
-
-        iterator() ENTT_NOEXCEPT = default;
-
-        iterator & operator++() ENTT_NOEXCEPT {
-            return --index, *this;
-        }
-
-        iterator operator++(int) ENTT_NOEXCEPT {
-            iterator orig = *this;
-            return ++(*this), orig;
-        }
-
-        iterator & operator--() ENTT_NOEXCEPT {
-            return ++index, *this;
-        }
-
-        iterator operator--(int) ENTT_NOEXCEPT {
-            iterator orig = *this;
-            return --(*this), orig;
-        }
-
-        iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
-            index -= value;
-            return *this;
-        }
-
-        iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
-            return iterator{index-value};
-        }
-
-        iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
-            return (*this += -value);
-        }
-
-        iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
-            return (*this + -value);
-        }
-
-        difference_type operator-(const iterator &other) const ENTT_NOEXCEPT {
-            return other.index - index;
-        }
-
-        reference operator[](const difference_type) const ENTT_NOEXCEPT {
-            return {};
-        }
-
-        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
-            return other.index == index;
-        }
-
-        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
-            return !(*this == other);
-        }
-
-        bool operator<(const iterator &other) const ENTT_NOEXCEPT {
-            return index > other.index;
-        }
-
-        bool operator>(const iterator &other) const ENTT_NOEXCEPT {
-            return index < other.index;
-        }
-
-        bool operator<=(const iterator &other) const ENTT_NOEXCEPT {
-            return !(*this > other);
-        }
-
-        bool operator>=(const iterator &other) const ENTT_NOEXCEPT {
-            return !(*this < other);
-        }
-
-        pointer operator->() const ENTT_NOEXCEPT {
-            return nullptr;
-        }
-
-        reference operator*() const ENTT_NOEXCEPT {
-            return {};
-        }
-
-    private:
-        index_type index;
-    };
-
 public:
     /*! @brief Type of the objects associated with the entities. */
     using object_type = Type;
@@ -600,105 +527,65 @@ public:
     using entity_type = Entity;
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
-    /*! @brief Random access iterator type. */
-    using iterator_type = iterator;
 
     /**
-     * @brief Returns an iterator to the beginning.
-     *
-     * The returned iterator points to the first instance of the given type. If
-     * the storage is empty, the returned iterator will be equal to `end()`.
-     *
-     * @note
-     * Input iterators stay true to the order imposed by a call to either `sort`
-     * or `respect`.
-     *
-     * @return An iterator to the first instance of the given type.
-     */
-    iterator_type cbegin() const ENTT_NOEXCEPT {
-        const typename traits_type::difference_type pos = underlying_type::size();
-        return iterator_type{pos};
-    }
-
-    /*! @copydoc cbegin */
-    iterator_type begin() const ENTT_NOEXCEPT {
-        return cbegin();
-    }
-
-    /**
-     * @brief Returns an iterator to the end.
-     *
-     * The returned iterator points to the element following the last instance
-     * of the given type. Attempting to dereference the returned iterator
-     * results in undefined behavior.
-     *
-     * @note
-     * Input iterators stay true to the order imposed by a call to either `sort`
-     * or `respect`.
-     *
-     * @return An iterator to the element following the last instance of the
-     * given type.
-     */
-    iterator_type cend() const ENTT_NOEXCEPT {
-        return iterator_type{};
-    }
-
-    /*! @copydoc cend */
-    iterator_type end() const ENTT_NOEXCEPT {
-        return cend();
-    }
-
-    /**
-     * @brief Returns the object associated with an entity.
-     *
-     * @note
-     * Empty types aren't explicitly instantiated. Therefore, this function
-     * always returns a temporary object.
+     * @brief Assigns an entity to a storage and constructs its object.
      *
      * @warning
-     * Attempting to use an entity that doesn't belong to the storage results in
-     * undefined behavior.<br/>
+     * Attempting to use an entity that already belongs to the storage results
+     * in undefined behavior.<br/>
      * An assertion will abort the execution at runtime in debug mode if the
-     * storage doesn't contain the given entity.
+     * storage already contains the given entity.
      *
+     * @tparam Args Types of arguments to use to construct the object.
      * @param entt A valid entity identifier.
-     * @return The object associated with the entity.
+     * @param args Parameters to use to construct an object for the entity.
      */
-    object_type get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
-        ENTT_ASSERT(underlying_type::has(entt));
-        return {};
+    template<typename... Args>
+    void emplace(const entity_type entt, Args &&... args) {
+        [[maybe_unused]] object_type instance{std::forward<Args>(args)...};
+        underlying_type::emplace(entt);
+    }
+
+    /*! @copydoc emplace */
+    template<typename... Args>
+    [[deprecated("use ::emplace instead")]]
+    void construct(const entity_type entt, Args &&... args) {
+        emplace(entt, std::forward<Args>(args)...);
     }
 
     /**
      * @brief Assigns one or more entities to a storage.
      *
-     * The object type must be at least default constructible.
-     *
      * @warning
      * Attempting to assign an entity that already belongs to the storage
      * results in undefined behavior.<br/>
      * An assertion will abort the execution at runtime in debug mode if the
      * storage already contains the given entity.
      *
-     * @tparam It Type of forward iterator.
+     * @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.
-     * @return An iterator to the list of instances just created and sorted the
-     * same of the entities.
      */
     template<typename It>
-    iterator_type batch(It first, It last, const object_type & = {}) {
-        underlying_type::batch(first, last);
-        return begin();
+    void insert(It first, It last, const object_type & = {}) {
+        underlying_type::insert(first, last);
+    }
+
+    /**
+     * @copydoc insert
+     * @param value An instance of the object to construct.
+     */
+    template<typename It>
+    [[deprecated("use ::insert instead")]]
+    std::enable_if_t<std::is_same_v<typename std::iterator_traits<It>::value_type, entity_type>, void>
+    construct(It first, It last, const object_type &value = {}) {
+        insert(std::move(first), std::move(last), value);
     }
 };
 
-/*! @copydoc basic_storage */
-template<typename Entity, typename Type>
-struct storage: basic_storage<Entity, Type> {};
-
 
 }
 
 
-#endif // ENTT_ENTITY_STORAGE_HPP
+#endif

src/entt/entity/utility.hpp

@@ -21,7 +21,7 @@ struct exclude_t: type_list<Type...> {};
  * @tparam Type List of types.
  */
 template<typename... Type>
-constexpr exclude_t<Type...> exclude{};
+inline constexpr exclude_t<Type...> exclude{};
 
 
 /**
@@ -37,10 +37,10 @@ struct get_t: type_list<Type...>{};
  * @tparam Type List of types.
  */
 template<typename... Type>
-constexpr get_t<Type...> get{};
+inline constexpr get_t<Type...> get{};
 
 
 }
 
 
-#endif // ENTT_ENTITY_UTILITY_HPP
+#endif

src/entt/entity/view.hpp

@@ -12,6 +12,7 @@
 #include "../core/type_traits.hpp"
 #include "sparse_set.hpp"
 #include "storage.hpp"
+#include "utility.hpp"
 #include "entity.hpp"
 #include "fwd.hpp"
 
@@ -19,17 +20,23 @@
 namespace entt {
 
 
+/**
+ * @brief View.
+ *
+ * Primary template isn't defined on purpose. All the specializations give a
+ * compile-time error, but for a few reasonable cases.
+ */
+template<typename...>
+class basic_view;
+
+
 /**
  * @brief Multi component view.
  *
  * Multi component views iterate over those entities that have at least all the
  * given components in their bags. During initialization, a multi component 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.
+ * looks at the number of entities available for each component and uses the
+ * smallest set in order to get a performance boost when iterate.
  *
  * @b Important
  *
@@ -40,9 +47,8 @@ namespace entt {
  *   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.
+ * In all other cases, modifying the pools iterated by the view 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
@@ -50,16 +56,15 @@ namespace entt {
  * made by means of the registry are immediately reflected by views.
  *
  * @warning
- * Lifetime of a view must overcome the one of the registry that generated it.
+ * 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 Exclude Types of components used to filter the view.
  * @tparam Component Types of components iterated by the view.
  */
-template<typename Entity, typename... Component>
-class basic_view {
-    static_assert(sizeof...(Component) > 1);
-
+template<typename Entity, typename... Exclude, typename... Component>
+class basic_view<Entity, exclude_t<Exclude...>, Component...> {
     /*! @brief A registry is allowed to create views. */
     friend class basic_registry<Entity>;
 
@@ -67,91 +72,103 @@ class basic_view {
     using pool_type = std::conditional_t<std::is_const_v<Comp>, const storage<Entity, std::remove_const_t<Comp>>, storage<Entity, Comp>>;
 
     template<typename Comp>
-    using component_iterator_type = decltype(std::declval<pool_type<Comp>>().begin());
+    using component_iterator = decltype(std::declval<pool_type<Comp>>().begin());
 
-    using underlying_iterator_type = typename sparse_set<Entity>::iterator_type;
+    using underlying_iterator = typename sparse_set<Entity>::iterator;
     using unchecked_type = std::array<const sparse_set<Entity> *, (sizeof...(Component) - 1)>;
-    using traits_type = entt_traits<std::underlying_type_t<Entity>>;
+    using filter_type = std::array<const sparse_set<Entity> *, sizeof...(Exclude)>;
 
-    class iterator {
-        friend class basic_view<Entity, Component...>;
+    class view_iterator final {
+        friend class basic_view<Entity, exclude_t<Exclude...>, Component...>;
 
-        iterator(unchecked_type other, underlying_iterator_type first, underlying_iterator_type last) ENTT_NOEXCEPT
-            : unchecked{other},
-              begin{first},
-              end{last}
+        view_iterator(const sparse_set<Entity> &candidate, unchecked_type other, filter_type ignore, underlying_iterator curr) ENTT_NOEXCEPT
+            : view{&candidate},
+              unchecked{other},
+              filter{ignore},
+              it{curr}
         {
-            if(begin != end && !valid()) {
+            if(it != view->end() && !valid()) {
                 ++(*this);
             }
         }
 
-        bool valid() const ENTT_NOEXCEPT {
-            return std::all_of(unchecked.cbegin(), unchecked.cend(), [this](const sparse_set<Entity> *view) {
-                return view->has(*begin);
-            });
+        bool valid() const {
+            return std::all_of(unchecked.cbegin(), unchecked.cend(), [entt = *it](const sparse_set<Entity> *curr) { return curr->contains(entt); })
+                    && std::none_of(filter.cbegin(), filter.cend(), [entt = *it](const sparse_set<Entity> *curr) { return curr->contains(entt); });
         }
 
     public:
-        using difference_type = typename underlying_iterator_type::difference_type;
-        using value_type = typename underlying_iterator_type::value_type;
-        using pointer = typename underlying_iterator_type::pointer;
-        using reference = typename underlying_iterator_type::reference;
-        using iterator_category = std::forward_iterator_tag;
+        using difference_type = typename underlying_iterator::difference_type;
+        using value_type = typename underlying_iterator::value_type;
+        using pointer = typename underlying_iterator::pointer;
+        using reference = typename underlying_iterator::reference;
+        using iterator_category = std::bidirectional_iterator_tag;
 
-        iterator() ENTT_NOEXCEPT = default;
+        view_iterator() ENTT_NOEXCEPT = default;
 
-        iterator & operator++() ENTT_NOEXCEPT {
-            return (++begin != end && !valid()) ? ++(*this) : *this;
+        view_iterator & operator++() {
+            while(++it != view->end() && !valid());
+            return *this;
         }
 
-        iterator operator++(int) ENTT_NOEXCEPT {
-            iterator orig = *this;
-            return ++(*this), orig;
+        view_iterator operator++(int) {
+            view_iterator orig = *this;
+            return operator++(), orig;
         }
 
-        bool operator==(const iterator &other) const ENTT_NOEXCEPT {
-            return other.begin == begin;
+        view_iterator & operator--() ENTT_NOEXCEPT {
+            while(--it != view->begin() && !valid());
+            return *this;
         }
 
-        bool operator!=(const iterator &other) const ENTT_NOEXCEPT {
+        view_iterator operator--(int) ENTT_NOEXCEPT {
+            view_iterator orig = *this;
+            return operator--(), orig;
+        }
+
+        bool operator==(const view_iterator &other) const ENTT_NOEXCEPT {
+            return other.it == it;
+        }
+
+        bool operator!=(const view_iterator &other) const ENTT_NOEXCEPT {
             return !(*this == other);
         }
 
-        pointer operator->() const ENTT_NOEXCEPT {
-            return begin.operator->();
+        pointer operator->() const {
+            return it.operator->();
         }
 
-        reference operator*() const ENTT_NOEXCEPT {
+        reference operator*() const {
             return *operator->();
         }
 
     private:
+        const sparse_set<Entity> *view;
         unchecked_type unchecked;
-        underlying_iterator_type begin;
-        underlying_iterator_type end;
+        filter_type filter;
+        underlying_iterator it;
     };
 
-    // we could use pool_type<Component> *..., but vs complains about it and refuses to compile for unknown reasons (likely a bug)
-    basic_view(storage<Entity, std::remove_const_t<Component>> *... ref) ENTT_NOEXCEPT
-        : pools{ref...}
+    // we could use pool_type<Component> &..., but vs complains about it and refuses to compile for unknown reasons (likely a bug)
+    basic_view(storage<Entity, std::remove_const_t<Component>> &... component, storage<Entity, std::remove_const_t<Exclude>> &... epool) ENTT_NOEXCEPT
+        : pools{&component..., &epool...}
     {}
 
-    const sparse_set<Entity> * candidate() const ENTT_NOEXCEPT {
-        return std::min({ static_cast<const sparse_set<Entity> *>(std::get<pool_type<Component> *>(pools))... }, [](const auto *lhs, const auto *rhs) {
+    const sparse_set<Entity> & candidate() const ENTT_NOEXCEPT {
+        return *std::min({ static_cast<const sparse_set<Entity> *>(std::get<pool_type<Component> *>(pools))... }, [](const auto *lhs, const auto *rhs) {
             return lhs->size() < rhs->size();
         });
     }
 
-    unchecked_type unchecked(const sparse_set<Entity> *view) const ENTT_NOEXCEPT {
+    unchecked_type unchecked(const sparse_set<Entity> &view) const {
+        std::size_t pos{};
         unchecked_type other{};
-        typename unchecked_type::size_type pos{};
-        ((std::get<pool_type<Component> *>(pools) == view ? nullptr : (other[pos++] = std::get<pool_type<Component> *>(pools))), ...);
+        ((std::get<pool_type<Component> *>(pools) == &view ? nullptr : (other[pos++] = std::get<pool_type<Component> *>(pools))), ...);
         return other;
     }
 
     template<typename Comp, typename Other>
-    decltype(auto) get([[maybe_unused]] component_iterator_type<Comp> it, [[maybe_unused]] pool_type<Other> *cpool, [[maybe_unused]] const Entity entt) const ENTT_NOEXCEPT {
+    decltype(auto) get([[maybe_unused]] component_iterator<Comp> it, [[maybe_unused]] pool_type<Other> *cpool, [[maybe_unused]] const Entity entt) const {
         if constexpr(std::is_same_v<Comp, Other>) {
             return *it;
         } else {
@@ -159,33 +176,32 @@ class basic_view {
         }
     }
 
-    template<typename Comp, typename Func, typename... Other, typename... Type>
-    void traverse(Func func, type_list<Other...>, type_list<Type...>) const {
-        const auto end = std::get<pool_type<Comp> *>(pools)->sparse_set<Entity>::end();
-        auto begin = std::get<pool_type<Comp> *>(pools)->sparse_set<Entity>::begin();
-
+    template<typename Comp, typename Func, typename... Type>
+    void traverse(Func func, type_list<Type...>) const {
         if constexpr(std::disjunction_v<std::is_same<Comp, Type>...>) {
-            std::for_each(begin, end, [this, raw = std::get<pool_type<Comp> *>(pools)->begin(), &func](const auto entity) mutable {
-                auto curr = raw++;
+            auto it = std::get<pool_type<Comp> *>(pools)->begin();
 
-                if((std::get<pool_type<Other> *>(pools)->has(entity) && ...)) {
+            for(const auto entt: static_cast<const sparse_set<entity_type> &>(*std::get<pool_type<Comp> *>(pools))) {
+                auto curr = it++;
+
+                if(((std::is_same_v<Comp, Component> || std::get<pool_type<Component> *>(pools)->contains(entt)) && ...) && (!std::get<pool_type<Exclude> *>(pools)->contains(entt) && ...)) {
                     if constexpr(std::is_invocable_v<Func, decltype(get<Type>({}))...>) {
-                        func(get<Comp, Type>(curr, std::get<pool_type<Type> *>(pools), entity)...);
+                        func(get<Comp, Type>(curr, std::get<pool_type<Type> *>(pools), entt)...);
                     } else {
-                        func(entity, get<Comp, Type>(curr, std::get<pool_type<Type> *>(pools), entity)...);
+                        func(entt, get<Comp, Type>(curr, std::get<pool_type<Type> *>(pools), entt)...);
                     }
                 }
-            });
+            }
         } else {
-            std::for_each(begin, end, [this, &func](const auto entity) mutable {
-                if((std::get<pool_type<Other> *>(pools)->has(entity) && ...)) {
+            for(const auto entt: static_cast<const sparse_set<entity_type> &>(*std::get<pool_type<Comp> *>(pools))) {
+                if(((std::is_same_v<Comp, Component> || std::get<pool_type<Component> *>(pools)->contains(entt)) && ...) && (!std::get<pool_type<Exclude> *>(pools)->contains(entt) && ...)) {
                     if constexpr(std::is_invocable_v<Func, decltype(get<Type>({}))...>) {
-                        func(std::get<pool_type<Type> *>(pools)->get(entity)...);
+                        func(std::get<pool_type<Type> *>(pools)->get(entt)...);
                     } else {
-                        func(entity, std::get<pool_type<Type> *>(pools)->get(entity)...);
+                        func(entt, std::get<pool_type<Type> *>(pools)->get(entt)...);
                     }
                 }
-            });
+            }
         }
     }
 
@@ -195,10 +211,13 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Input iterator type. */
-    using iterator_type = iterator;
+    using iterator = view_iterator;
 
     /**
      * @brief Returns the number of existing components of the given type.
+     *
+     * This isn't the number of entities iterated by the view.
+     *
      * @tparam Comp Type of component of which to return the size.
      * @return Number of existing components of the given type.
      */
@@ -208,30 +227,30 @@ public:
     }
 
     /**
-     * @brief Estimates the number of entities that have the given components.
-     * @return Estimated number of entities that have the given components.
+     * @brief Estimates the number of entities iterated by the view.
+     * @return Estimated number of entities iterated by the view.
      */
     size_type size() const ENTT_NOEXCEPT {
         return std::min({ std::get<pool_type<Component> *>(pools)->size()... });
     }
 
     /**
-     * @brief Checks whether the pool of a given component is empty.
-     * @tparam Comp Type of component in which one is interested.
-     * @return True if the pool of the given component is empty, false
-     * otherwise.
+     * @brief Checks whether a view or some pools are empty.
+     *
+     * The view is definitely empty if one of the pools it uses is empty. In all
+     * other cases, the view may be empty and not return entities even if this
+     * function returns false.
+     *
+     * @tparam Comp Types of components in which one is interested.
+     * @return True if the view or the pools are empty, false otherwise.
      */
-    template<typename Comp>
+    template<typename... Comp>
     bool empty() const ENTT_NOEXCEPT {
-        return std::get<pool_type<Comp> *>(pools)->empty();
-    }
-
-    /**
-     * @brief Checks if the view is definitely empty.
-     * @return True if the view is definitely empty, false otherwise.
-     */
-    bool empty() const ENTT_NOEXCEPT {
-        return (std::get<pool_type<Component> *>(pools)->empty() || ...);
+        if constexpr(sizeof...(Comp) == 0) {
+            return (std::get<pool_type<Component> *>(pools)->empty() || ...);
+        } else {
+            return (std::get<pool_type<Comp> *>(pools)->empty() && ...);
+        }
     }
 
     /**
@@ -286,9 +305,10 @@ public:
      *
      * @return An iterator to the first entity that has the given components.
      */
-    iterator_type begin() const ENTT_NOEXCEPT {
-        const auto *view = candidate();
-        return iterator_type{unchecked(view), view->begin(), view->end()};
+    iterator begin() const {
+        const auto &view = candidate();
+        const filter_type ignore{std::get<pool_type<Exclude> *>(pools)...};
+        return iterator{view, unchecked(view), ignore, view.begin()};
     }
 
     /**
@@ -306,9 +326,30 @@ public:
      * @return An iterator to the entity following the last entity that has the
      * given components.
      */
-    iterator_type end() const ENTT_NOEXCEPT {
-        const auto *view = candidate();
-        return iterator_type{unchecked(view), view->end(), view->end()};
+    iterator end() const {
+        const auto &view = candidate();
+        const filter_type ignore{std::get<pool_type<Exclude> *>(pools)...};
+        return iterator{view, unchecked(view), ignore, view.end()};
+    }
+
+    /**
+     * @brief Returns the first entity that has the given components, if any.
+     * @return The first entity that has the given components if one exists, the
+     * null entity otherwise.
+     */
+    entity_type front() const {
+        const auto it = begin();
+        return it != end() ? *it : null;
+    }
+
+    /**
+     * @brief Returns the last entity that has the given components, if any.
+     * @return The last entity that has the given components if one exists, the
+     * null entity otherwise.
+     */
+    entity_type back() const {
+        const auto it = std::make_reverse_iterator(end());
+        return it != std::make_reverse_iterator(begin()) ? *it : null;
     }
 
     /**
@@ -317,9 +358,10 @@ public:
      * @return An iterator to the given entity if it's found, past the end
      * iterator otherwise.
      */
-    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
-        const auto *view = candidate();
-        iterator_type it{unchecked(view), view->find(entt), view->end()};
+    iterator find(const entity_type entt) const {
+        const auto &view = candidate();
+        const filter_type ignore{std::get<pool_type<Exclude> *>(pools)...};
+        iterator it{view, unchecked(view), ignore, view.find(entt)};
         return (it != end() && *it == entt) ? it : end();
     }
 
@@ -328,15 +370,16 @@ public:
      * @param entt A valid entity identifier.
      * @return True if the view contains the given entity, false otherwise.
      */
-    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
-        return find(entt) != end();
+    bool contains(const entity_type entt) const {
+        return (std::get<pool_type<Component> *>(pools)->contains(entt) && ...)
+                && (!std::get<pool_type<Exclude> *>(pools)->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 companion function.
+     * far better performance than its counterpart.
      *
      * @warning
      * Attempting to use an invalid component type results in a compilation
@@ -350,13 +393,16 @@ public:
      * @return The components assigned to the entity.
      */
     template<typename... Comp>
-    decltype(auto) get([[maybe_unused]] const entity_type entt) const ENTT_NOEXCEPT {
+    decltype(auto) get([[maybe_unused]] const entity_type entt) const {
         ENTT_ASSERT(contains(entt));
 
-        if constexpr(sizeof...(Comp) == 1) {
+        if constexpr(sizeof...(Comp) == 0) {
+            static_assert(sizeof...(Component) == 1);
+            return (std::get<pool_type<Component> *>(pools)->get(entt), ...);
+        } else if constexpr(sizeof...(Comp) == 1) {
             return (std::get<pool_type<Comp> *>(pools)->get(entt), ...);
         } else {
-            return std::tuple<decltype(get<Comp>(entt))...>{get<Comp>(entt)...};
+            return std::tuple<decltype(get<Comp>({}))...>{get<Comp>(entt)...};
         }
     }
 
@@ -365,55 +411,40 @@ public:
      * object to them.
      *
      * The function object is invoked for each entity. It is provided with the
-     * entity itself and a set of references to all its components. 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, Component &...);
-     * void(Component &...);
+     * void(const entity_type, Type &...);
+     * void(Type &...);
      * @endcode
      *
      * @note
-     * Empty types aren't explicitly instantiated. Therefore, temporary objects
-     * are returned during iterations. They can be caught only by copy or with
-     * const references.
+     * 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 {
-        const auto *view = candidate();
-        ((std::get<pool_type<Component> *>(pools) == view ? each<Component>(std::move(func)) : void()), ...);
+        const auto &view = candidate();
+        ((std::get<pool_type<Component> *>(pools) == &view ? each<Component>(std::move(func)) : void()), ...);
     }
 
     /**
      * @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 all its 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, Component &...);
-     * void(Component &...);
-     * @endcode
-     *
      * The pool of the suggested component is used to lead the iterations. The
      * returned entities will therefore respect the order of the pool associated
      * with that type.<br/>
      * It is no longer guaranteed that the performance is the best possible, but
      * there will be greater control over the order of iteration.
      *
-     * @note
-     * Empty types aren't explicitly instantiated. Therefore, temporary objects
-     * are returned during iterations. They can be caught only by copy or with
-     * const references.
+     * @sa each
      *
      * @tparam Comp Type of component to use to enforce the iteration order.
      * @tparam Func Type of the function object to invoke.
@@ -421,8 +452,8 @@ public:
      */
     template<typename Comp, typename Func>
     void each(Func func) const {
-        using other_type = type_list_cat_t<std::conditional_t<std::is_same_v<Comp, Component>, type_list<>, type_list<Component>>...>;
-        traverse<Comp>(std::move(func), other_type{}, type_list<Component...>{});
+        using non_empty_type = type_list_cat_t<std::conditional_t<ENTT_IS_EMPTY(Component), type_list<>, type_list<Component>>...>;
+        traverse<Comp>(std::move(func), non_empty_type{});
     }
 
     /**
@@ -440,53 +471,43 @@ public:
      * void(Type &...);
      * @endcode
      *
-     * @sa each
+     * @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>
+    [[deprecated("use ::each instead")]]
     void less(Func func) const {
-        const auto *view = candidate();
-        ((std::get<pool_type<Component> *>(pools) == view ? less<Component>(std::move(func)) : void()), ...);
+        each(std::move(func));
     }
 
     /**
      * @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
-     *
      * The pool of the suggested component is used to lead the iterations. The
      * returned entities will therefore respect the order of the pool associated
      * with that type.<br/>
      * It is no longer guaranteed that the performance is the best possible, but
      * there will be greater control over the order of iteration.
      *
-     * @sa each
+     * @sa less
      *
      * @tparam Comp Type of component to use to enforce the iteration order.
      * @tparam Func Type of the function object to invoke.
      * @param func A valid function object.
      */
     template<typename Comp, typename Func>
+    [[deprecated("use ::each instead")]]
     void less(Func func) const {
-        using other_type = type_list_cat_t<std::conditional_t<std::is_same_v<Comp, Component>, type_list<>, type_list<Component>>...>;
-        using non_empty_type = type_list_cat_t<std::conditional_t<std::is_empty_v<Component>, type_list<>, type_list<Component>>...>;
-        traverse<Comp>(std::move(func), other_type{}, non_empty_type{});
+        each<Comp>(std::move(func));
     }
 
 private:
-    const std::tuple<pool_type<Component> *...> pools;
+    const std::tuple<pool_type<Component> *..., pool_type<Exclude> *...> pools;
 };
 
 
@@ -495,10 +516,7 @@ private:
  *
  * Single component views are specialized in order to get a boost in terms of
  * performance. This kind of views can access the underlying data structure
- * directly and avoid superfluous checks.<br/>
- * Order of elements during iterations are highly dependent on the order of the
- * underlying data structure. See sparse_set and its specializations for more
- * details.
+ * directly and avoid superfluous checks.
  *
  * @b Important
  *
@@ -509,7 +527,7 @@ private:
  *   component is removed from the entity to which the iterator points).
  * * The entity currently pointed is destroyed.
  *
- * In all the other cases, modifying the pool of the given component in any way
+ * In all other cases, modifying the pool iterated by the view in any way
  * invalidates all the iterators and using them results in undefined behavior.
  *
  * @note
@@ -518,21 +536,21 @@ private:
  * made by means of the registry are immediately reflected by views.
  *
  * @warning
- * Lifetime of a view must overcome the one of the registry that generated it.
+ * 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 Component Type of component iterated by the view.
  */
 template<typename Entity, typename Component>
-class basic_view<Entity, Component> {
+class basic_view<Entity, exclude_t<>, Component> {
     /*! @brief A registry is allowed to create views. */
     friend class basic_registry<Entity>;
 
     using pool_type = std::conditional_t<std::is_const_v<Component>, const storage<Entity, std::remove_const_t<Component>>, storage<Entity, Component>>;
 
-    basic_view(pool_type *ref) ENTT_NOEXCEPT
-        : pool{ref}
+    basic_view(pool_type &ref) ENTT_NOEXCEPT
+        : pool{&ref}
     {}
 
 public:
@@ -543,7 +561,7 @@ public:
     /*! @brief Unsigned integer type. */
     using size_type = std::size_t;
     /*! @brief Input iterator type. */
-    using iterator_type = typename sparse_set<Entity>::iterator_type;
+    using iterator = typename sparse_set<Entity>::iterator;
 
     /**
      * @brief Returns the number of entities that have the given component.
@@ -554,7 +572,7 @@ public:
     }
 
     /**
-     * @brief Checks whether the view is empty.
+     * @brief Checks whether a view is empty.
      * @return True if the view is empty, false otherwise.
      */
     bool empty() const ENTT_NOEXCEPT {
@@ -607,7 +625,7 @@ public:
      *
      * @return An iterator to the first entity that has the given component.
      */
-    iterator_type begin() const ENTT_NOEXCEPT {
+    iterator begin() const ENTT_NOEXCEPT {
         return pool->sparse_set<Entity>::begin();
     }
 
@@ -626,17 +644,37 @@ public:
      * @return An iterator to the entity following the last entity that has the
      * given component.
      */
-    iterator_type end() const ENTT_NOEXCEPT {
+    iterator end() const ENTT_NOEXCEPT {
         return pool->sparse_set<Entity>::end();
     }
 
+    /**
+     * @brief Returns the first entity that has the given component, if any.
+     * @return The first entity that has the given component if one exists, the
+     * null entity otherwise.
+     */
+    entity_type front() const {
+        const auto it = begin();
+        return it != end() ? *it : null;
+    }
+
+    /**
+     * @brief Returns the last entity that has the given component, if any.
+     * @return The last entity that has the given component if one exists, the
+     * null entity otherwise.
+     */
+    entity_type back() const {
+        const auto it = std::make_reverse_iterator(end());
+        return it != std::make_reverse_iterator(begin()) ? *it : null;
+    }
+
     /**
      * @brief Finds an entity.
      * @param entt A valid entity identifier.
      * @return An iterator to the given entity if it's found, past the end
      * iterator otherwise.
      */
-    iterator_type find(const entity_type entt) const ENTT_NOEXCEPT {
+    iterator find(const entity_type entt) const {
         const auto it = pool->find(entt);
         return it != end() && *it == entt ? it : end();
     }
@@ -646,7 +684,7 @@ public:
      * @param pos Position of the element to return.
      * @return The identifier that occupies the given position.
      */
-    entity_type operator[](const size_type pos) const ENTT_NOEXCEPT {
+    entity_type operator[](const size_type pos) const {
         return begin()[pos];
     }
 
@@ -655,15 +693,15 @@ public:
      * @param entt A valid entity identifier.
      * @return True if the view contains the given entity, false otherwise.
      */
-    bool contains(const entity_type entt) const ENTT_NOEXCEPT {
-        return find(entt) != end();
+    bool contains(const entity_type entt) const {
+        return pool->contains(entt);
     }
 
     /**
      * @brief Returns the component assigned to the given entity.
      *
      * Prefer this function instead of `registry::get` during iterations. It has
-     * far better performance than its companion function.
+     * far better performance than its counterpart.
      *
      * @warning
      * Attempting to use an entity that doesn't belong to the view results in
@@ -674,7 +712,9 @@ public:
      * @param entt A valid entity identifier.
      * @return The component assigned to the entity.
      */
-    decltype(auto) get(const entity_type entt) const ENTT_NOEXCEPT {
+    template<typename Comp = Component>
+    decltype(auto) get(const entity_type entt) const {
+        static_assert(std::is_same_v<Comp, Component>);
         ENTT_ASSERT(contains(entt));
         return pool->get(entt);
     }
@@ -684,8 +724,8 @@ public:
      * object to them.
      *
      * The function object is invoked for each entity. It is provided with the
-     * entity itself and a reference to its component. The _constness_ of the
-     * component is as requested.<br/>
+     * entity itself and a reference to the component if it's a non-empty one.
+     * The _constness_ of the component is as requested.<br/>
      * The signature of the function must be equivalent to one of the following
      * forms:
      *
@@ -695,67 +735,46 @@ public:
      * @endcode
      *
      * @note
-     * Empty types aren't explicitly instantiated. Therefore, temporary objects
-     * are returned during iterations. They can be caught only by copy or with
-     * const references.
+     * 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 {
-        if constexpr(std::is_invocable_v<Func, decltype(get({}))>) {
-            std::for_each(pool->begin(), pool->end(), std::move(func));
-        } else {
-            std::for_each(pool->sparse_set<Entity>::begin(), pool->sparse_set<Entity>::end(), [&func, raw = pool->begin()](const auto entt) mutable {
-                func(entt, *(raw++));
-            });
-        }
-    }
-
-    /**
-     * @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 reference to its component if it's a non-empty one.
-     * The _constness_ of the component is as requested.<br/>
-     * The signature of the function must be equivalent to one of the following
-     * forms in case the component isn't an empty one:
-     *
-     * @code{.cpp}
-     * void(const entity_type, Component &);
-     * void(Component &);
-     * @endcode
-     *
-     * In case the component is an empty one instead, the following forms are
-     * accepted:
-     *
-     * @code{.cpp}
-     * void(const entity_type);
-     * void();
-     * @endcode
-     *
-     * @sa each
-     *
-     * @tparam Func Type of the function object to invoke.
-     * @param func A valid function object.
-     */
-    template<typename Func>
-    void less(Func func) const {
-        if constexpr(std::is_empty_v<Component>) {
+        if constexpr(ENTT_IS_EMPTY(Component)) {
             if constexpr(std::is_invocable_v<Func>) {
                 for(auto pos = pool->size(); pos; --pos) {
                     func();
                 }
             } else {
-                std::for_each(pool->sparse_set<Entity>::begin(), pool->sparse_set<Entity>::end(), std::move(func));
+                for(const auto entt: *this) {
+                    func(entt);
+                }
             }
         } else {
-            each(std::move(func));
+            if constexpr(std::is_invocable_v<Func, decltype(get({}))>) {
+                for(auto &&component: *pool) {
+                    func(component);
+                }
+            } else {
+                auto raw = pool->begin();
+
+                for(const auto entt: *this) {
+                    func(entt, *(raw++));
+                }
+            }
         }
     }
 
+    /*! @copydoc each */
+    template<typename Func>
+    [[deprecated("use ::each instead")]]
+    void less(Func func) const {
+        each(std::move(func));
+    }
+
 private:
     pool_type *pool;
 };
@@ -764,4 +783,4 @@ private:
 }
 
 
-#endif // ENTT_ENTITY_VIEW_HPP
+#endif

src/entt/entt.hpp

@@ -1,8 +1,10 @@
 #include "core/algorithm.hpp"
+#include "core/attribute.h"
 #include "core/family.hpp"
 #include "core/hashed_string.hpp"
 #include "core/ident.hpp"
 #include "core/monostate.hpp"
+#include "core/type_info.hpp"
 #include "core/type_traits.hpp"
 #include "core/utility.hpp"
 #include "entity/actor.hpp"
@@ -20,6 +22,7 @@
 #include "locator/locator.hpp"
 #include "meta/factory.hpp"
 #include "meta/meta.hpp"
+#include "meta/resolve.hpp"
 #include "meta/policy.hpp"
 #include "process/process.hpp"
 #include "process/scheduler.hpp"

src/entt/fwd.hpp

@@ -1,3 +1,4 @@
+#include "core/fwd.hpp"
 #include "entity/fwd.hpp"
 #include "resource/fwd.hpp"
 #include "signal/fwd.hpp"

src/entt/locator/locator.hpp

@@ -108,4 +108,4 @@ private:
 }
 
 
-#endif // ENTT_LOCATOR_LOCATOR_HPP
+#endif

src/entt/meta/policy.hpp

@@ -5,12 +5,21 @@
 namespace entt {
 
 
-/*! @brief Empty class type used to request the _as alias_ policy. */
-struct as_alias_t {};
+/*! @brief Empty class type used to request the _as ref_ policy. */
+struct as_ref_t {};
 
 
 /*! @brief Disambiguation tag. */
-constexpr as_alias_t as_alias;
+inline constexpr as_ref_t as_ref;
+
+
+/*! @copydoc as_ref_t */
+using as_alias_t [[deprecated("use as_ref_t instead")]] = as_ref_t;
+
+
+/*! @copydoc as_ref */
+[[deprecated("use as_ref instead")]]
+inline constexpr as_ref_t as_alias;
 
 
 /*! @brief Empty class type used to request the _as-is_ policy. */
@@ -24,4 +33,4 @@ struct as_void_t {};
 }
 
 
-#endif // ENTT_META_POLICY_HPP
+#endif

src/entt/meta/resolve.hpp

@@ -0,0 +1,79 @@
+#ifndef ENTT_META_RESOLVE_HPP
+#define ENTT_META_RESOLVE_HPP
+
+
+#include <type_traits>
+#include "meta.hpp"
+
+
+namespace entt {
+
+
+/**
+ * @brief Returns the meta type associated with a given type.
+ * @tparam Type Type to use to search for a meta type.
+ * @return The meta type associated with the given type, if any.
+ */
+template<typename Type>
+inline meta_type resolve() ENTT_NOEXCEPT {
+    return internal::meta_info<Type>::resolve();
+}
+
+
+/**
+ * @brief Returns the first meta type that satisfies specific criteria, if any.
+ * @tparam Func Type of the unary predicate to use to test the meta types.
+ * @param func Unary predicate which returns ​true for the required element.
+ * @return The first meta type satisfying the condition, if any.
+ */
+template<typename Func>
+inline meta_type resolve_if(Func func) ENTT_NOEXCEPT {
+    return internal::find_if([&func](const auto *curr) {
+        return func(meta_type{curr});
+    }, *internal::meta_context::global);
+}
+
+
+/**
+ * @brief Returns the meta type associated with a given identifier, if any.
+ * @param id Unique identifier.
+ * @return The meta type associated with the given identifier, if any.
+ */
+inline meta_type resolve_id(const id_type id) ENTT_NOEXCEPT {
+    return resolve_if([id](const auto type) { return type.id() == id; });
+}
+
+
+/**
+ * @brief Returns the meta type associated with a given type id, if any.
+ * @param id Unique identifier.
+ * @return The meta type associated with the given type id, if any.
+ */
+inline meta_type resolve_type(const id_type id) ENTT_NOEXCEPT {
+    return resolve_if([id](const auto type) { return type.type_id() == id; });
+}
+
+
+/*! @copydoc resolve_id */
+[[deprecated("use entt::resolve_id instead")]]
+inline meta_type resolve(const id_type id) ENTT_NOEXCEPT {
+    return resolve_id(id);
+}
+
+
+/**
+ * @brief Iterates all the reflected types.
+ * @tparam Op Type of the function object to invoke.
+ * @param op A valid function object.
+ */
+template<typename Op>
+inline std::enable_if_t<std::is_invocable_v<Op, meta_type>, void>
+resolve(Op op) {
+    internal::visit<meta_type>(op, *internal::meta_context::global);
+}
+
+
+}
+
+
+#endif

src/entt/process/process.hpp

@@ -5,6 +5,7 @@
 #include <utility>
 #include <type_traits>
 #include "../config/config.h"
+#include "../core/type_traits.hpp"
 
 
 namespace entt {
@@ -81,41 +82,37 @@ class process {
         FINISHED
     };
 
-    template<state value>
-    using state_value_t = std::integral_constant<state, value>;
-
     template<typename Target = Derived>
-    auto tick(int, state_value_t<state::UNINITIALIZED>)
+    auto next(integral_constant<state::UNINITIALIZED>)
     -> decltype(std::declval<Target>().init()) {
         static_cast<Target *>(this)->init();
     }
 
     template<typename Target = Derived>
-    auto tick(int, state_value_t<state::RUNNING>, Delta delta, void *data)
+    auto next(integral_constant<state::RUNNING>, Delta delta, void *data)
     -> decltype(std::declval<Target>().update(delta, data)) {
         static_cast<Target *>(this)->update(delta, data);
     }
 
     template<typename Target = Derived>
-    auto tick(int, state_value_t<state::SUCCEEDED>)
+    auto next(integral_constant<state::SUCCEEDED>)
     -> decltype(std::declval<Target>().succeeded()) {
         static_cast<Target *>(this)->succeeded();
     }
 
     template<typename Target = Derived>
-    auto tick(int, state_value_t<state::FAILED>)
+    auto next(integral_constant<state::FAILED>)
     -> decltype(std::declval<Target>().failed()) {
         static_cast<Target *>(this)->failed();
     }
 
     template<typename Target = Derived>
-    auto tick(int, state_value_t<state::ABORTED>)
+    auto next(integral_constant<state::ABORTED>)
     -> decltype(std::declval<Target>().aborted()) {
         static_cast<Target *>(this)->aborted();
     }
 
-    template<state value, typename... Args>
-    void tick(char, state_value_t<value>, Args &&...) const ENTT_NOEXCEPT {}
+    void next(...) const ENTT_NOEXCEPT {}
 
 protected:
     /**
@@ -171,7 +168,7 @@ public:
     using delta_type = Delta;
 
     /*! @brief Default destructor. */
-    virtual ~process() ENTT_NOEXCEPT {
+    virtual ~process() {
         static_assert(std::is_base_of_v<process, Derived>);
     }
 
@@ -183,12 +180,12 @@ public:
      *
      * @param immediately Requests an immediate operation.
      */
-    void abort(const bool immediately = false) ENTT_NOEXCEPT {
+    void abort(const bool immediately = false) {
         if(alive()) {
             current = state::ABORTED;
 
             if(immediately) {
-                tick(0);
+                tick({});
             }
         }
     }
@@ -233,11 +230,11 @@ public:
     void tick(const Delta delta, void *data = nullptr) {
         switch (current) {
         case state::UNINITIALIZED:
-            tick(0, state_value_t<state::UNINITIALIZED>{});
+            next(integral_constant<state::UNINITIALIZED>{});
             current = state::RUNNING;
             break;
         case state::RUNNING:
-            tick(0, state_value_t<state::RUNNING>{}, delta, data);
+            next(integral_constant<state::RUNNING>{}, delta, data);
             break;
         default:
             // suppress warnings
@@ -247,16 +244,16 @@ public:
         // if it's dead, it must be notified and removed immediately
         switch(current) {
         case state::SUCCEEDED:
-            tick(0, state_value_t<state::SUCCEEDED>{});
+            next(integral_constant<state::SUCCEEDED>{});
             current = state::FINISHED;
             break;
         case state::FAILED:
-            tick(0, state_value_t<state::FAILED>{});
+            next(integral_constant<state::FAILED>{});
             current = state::FINISHED;
             stopped = true;
             break;
         case state::ABORTED:
-            tick(0, state_value_t<state::ABORTED>{});
+            next(integral_constant<state::ABORTED>{});
             current = state::FINISHED;
             stopped = true;
             break;
@@ -337,4 +334,4 @@ struct process_adaptor: process<process_adaptor<Func, Delta>, Delta>, private Fu
 }
 
 
-#endif // ENTT_PROCESS_PROCESS_HPP
+#endif

src/entt/process/scheduler.hpp

@@ -111,10 +111,10 @@ class scheduler {
 
 public:
     /*! @brief Unsigned integer type. */
-    using size_type = typename std::vector<process_handler>::size_type;
+    using size_type = std::size_t;
 
     /*! @brief Default constructor. */
-    scheduler() ENTT_NOEXCEPT = default;
+    scheduler() = default;
 
     /*! @brief Default move constructor. */
     scheduler(scheduler &&) = default;
@@ -281,9 +281,9 @@ public:
         decltype(handlers) exec;
         exec.swap(handlers);
 
-        std::for_each(exec.begin(), exec.end(), [immediately](auto &handler) {
+        for(auto &&handler: exec) {
             handler.abort(handler, immediately);
-        });
+        }
 
         std::move(handlers.begin(), handlers.end(), std::back_inserter(exec));
         handlers.swap(exec);
@@ -297,4 +297,4 @@ private:
 }
 
 
-#endif // ENTT_PROCESS_SCHEDULER_HPP
+#endif

src/entt/resource/cache.hpp

@@ -3,10 +3,11 @@
 
 
 #include <memory>
-#include <utility>
 #include <type_traits>
 #include <unordered_map>
+#include <utility>
 #include "../config/config.h"
+#include "../core/fwd.hpp"
 #include "handle.hpp"
 #include "loader.hpp"
 #include "fwd.hpp"
@@ -26,23 +27,20 @@ namespace entt {
  * @tparam Resource Type of resources managed by a cache.
  */
 template<typename Resource>
-class resource_cache {
-    using container_type = std::unordered_map<ENTT_ID_TYPE, std::shared_ptr<Resource>>;
-
-public:
+struct cache {
     /*! @brief Unsigned integer type. */
-    using size_type = typename container_type::size_type;
+    using size_type = std::size_t;
     /*! @brief Type of resources managed by a cache. */
-    using resource_type = ENTT_ID_TYPE;
+    using resource_type = Resource;
 
     /*! @brief Default constructor. */
-    resource_cache() = default;
+    cache() = default;
 
     /*! @brief Default move constructor. */
-    resource_cache(resource_cache &&) = default;
+    cache(cache &&) = default;
 
     /*! @brief Default move assignment operator. @return This cache. */
-    resource_cache & operator=(resource_cache &&) = default;
+    cache & operator=(cache &&) = default;
 
     /**
      * @brief Number of resources managed by a cache.
@@ -93,20 +91,20 @@ public:
      * @return A handle for the given resource.
      */
     template<typename Loader, typename... Args>
-    resource_handle<Resource> load(const resource_type id, Args &&... args) {
-        static_assert(std::is_base_of_v<resource_loader<Loader, Resource>, Loader>);
-        resource_handle<Resource> handle{};
+    entt::handle<Resource> load(const id_type id, Args &&... args) {
+        static_assert(std::is_base_of_v<loader<Loader, Resource>, Loader>);
+        entt::handle<Resource> resource{};
 
         if(auto it = resources.find(id); it == resources.cend()) {
-            if(auto resource = Loader{}.get(std::forward<Args>(args)...); resource) {
-                resources[id] = resource;
-                handle = std::move(resource);
+            if(auto instance = Loader{}.get(std::forward<Args>(args)...); instance) {
+                resources[id] = instance;
+                resource = std::move(instance);
             }
         } else {
-            handle = it->second;
+            resource = it->second;
         }
 
-        return handle;
+        return resource;
     }
 
     /**
@@ -133,7 +131,7 @@ public:
      * @return A handle for the given resource.
      */
     template<typename Loader, typename... Args>
-    resource_handle<Resource> reload(const resource_type id, Args &&... args) {
+    entt::handle<Resource> reload(const id_type id, Args &&... args) {
         return (discard(id), load<Loader>(id, std::forward<Args>(args)...));
     }
 
@@ -150,7 +148,7 @@ public:
      * @return A handle for the given resource.
      */
     template<typename Loader, typename... Args>
-    resource_handle<Resource> temp(Args &&... args) const {
+    entt::handle<Resource> temp(Args &&... args) const {
         return { Loader{}.get(std::forward<Args>(args)...) };
     }
 
@@ -162,12 +160,12 @@ public:
      * cache contains the resource itself. Otherwise the returned handle is
      * uninitialized and accessing it results in undefined behavior.
      *
-     * @sa resource_handle
+     * @sa handle
      *
      * @param id Unique resource identifier.
      * @return A handle for the given resource.
      */
-    resource_handle<Resource> handle(const resource_type id) const {
+    entt::handle<Resource> handle(const id_type id) const {
         auto it = resources.find(id);
         return { it == resources.end() ? nullptr : it->second };
     }
@@ -177,7 +175,7 @@ public:
      * @param id Unique resource identifier.
      * @return True if the cache contains the resource, false otherwise.
      */
-    bool contains(const resource_type id) const ENTT_NOEXCEPT {
+    bool contains(const id_type id) const {
         return (resources.find(id) != resources.cend());
     }
 
@@ -189,7 +187,7 @@ public:
      *
      * @param id Unique resource identifier.
      */
-    void discard(const resource_type id) ENTT_NOEXCEPT {
+    void discard(const id_type id) {
         if(auto it = resources.find(id); it != resources.end()) {
             resources.erase(it);
         }
@@ -204,9 +202,9 @@ public:
      * forms:
      *
      * @code{.cpp}
-     * void(const resource_type);
-     * void(resource_handle<Resource>);
-     * void(const resource_type, resource_handle<Resource>);
+     * void(const id_type);
+     * void(handle<Resource>);
+     * void(const id_type, handle<Resource>);
      * @endcode
      *
      * @tparam Func Type of the function object to invoke.
@@ -220,22 +218,22 @@ public:
         while(begin != end) {
             auto curr = begin++;
 
-            if constexpr(std::is_invocable_v<Func, resource_type>) {
+            if constexpr(std::is_invocable_v<Func, id_type>) {
                 func(curr->first);
-            } else if constexpr(std::is_invocable_v<Func, resource_handle<Resource>>) {
-                func(resource_handle{ curr->second });
+            } else if constexpr(std::is_invocable_v<Func, entt::handle<Resource>>) {
+                func(entt::handle{ curr->second });
             } else {
-                func(curr->first, resource_handle{ curr->second });
+                func(curr->first, entt::handle{ curr->second });
             }
         }
     }
 
 private:
-    container_type resources;
+    std::unordered_map<id_type, std::shared_ptr<Resource>> resources;
 };
 
 
 }
 
 
-#endif // ENTT_RESOURCE_CACHE_HPP
+#endif

src/entt/resource/fwd.hpp

@@ -2,26 +2,23 @@
 #define ENTT_RESOURCE_FWD_HPP
 
 
-#include "../config/config.h"
-
-
 namespace entt {
 
 
-/*! @class resource_cache */
+/*! @struct cache */
 template<typename>
-class resource_cache;
+struct cache;
 
-/*! @class resource_handle */
+/*! @class handle */
 template<typename>
-class resource_handle;
+class handle;
 
-/*! @class resource_loader */
+/*! @class loader */
 template<typename, typename>
-class resource_loader;
+class loader;
 
 
 }
 
 
-#endif // ENTT_RESOURCE_FWD_HPP
+#endif

src/entt/resource/handle.hpp

@@ -24,17 +24,17 @@ namespace entt {
  * @tparam Resource Type of resource managed by a handle.
  */
 template<typename Resource>
-class resource_handle {
+class handle {
     /*! @brief Resource handles are friends of their caches. */
-    friend class resource_cache<Resource>;
+    friend struct cache<Resource>;
 
-    resource_handle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
+    handle(std::shared_ptr<Resource> res) ENTT_NOEXCEPT
         : resource{std::move(res)}
     {}
 
 public:
     /*! @brief Default constructor. */
-    resource_handle() ENTT_NOEXCEPT = default;
+    handle() ENTT_NOEXCEPT = default;
 
     /**
      * @brief Gets a reference to the managed resource.
@@ -93,7 +93,9 @@ public:
      * @brief Returns true if a handle contains a resource, false otherwise.
      * @return True if the handle contains a resource, false otherwise.
      */
-    explicit operator bool() const { return static_cast<bool>(resource); }
+    explicit operator bool() const ENTT_NOEXCEPT {
+        return static_cast<bool>(resource);
+    }
 
 private:
     std::shared_ptr<Resource> resource;
@@ -103,4 +105,4 @@ private:
 }
 
 
-#endif // ENTT_RESOURCE_HANDLE_HPP
+#endif

src/entt/resource/loader.hpp

@@ -21,7 +21,7 @@ namespace entt {
  * @code{.cpp}
  * struct my_resource {};
  *
- * struct my_loader: entt::resource_loader<my_loader, my_resource> {
+ * struct my_loader: entt::loader<my_loader, my_resource> {
  *     std::shared_ptr<my_resource> load(int) const {
  *         // use the integer value somehow
  *         return std::make_shared<my_resource>();
@@ -42,9 +42,9 @@ namespace entt {
  * @tparam Resource Type of resource for which to use the loader.
  */
 template<typename Loader, typename Resource>
-class resource_loader {
+class loader {
     /*! @brief Resource loaders are friends of their caches. */
-    friend class resource_cache<Resource>;
+    friend struct cache<Resource>;
 
     /**
      * @brief Loads the resource and returns it.
@@ -62,4 +62,4 @@ class resource_loader {
 }
 
 
-#endif // ENTT_RESOURCE_LOADER_HPP
+#endif

src/entt/signal/delegate.hpp

@@ -3,9 +3,8 @@
 
 
 #include <tuple>
-#include <cstring>
+#include <cstddef>
 #include <utility>
-#include <algorithm>
 #include <functional>
 #include <type_traits>
 #include "../config/config.h"
@@ -24,37 +23,33 @@ namespace internal {
 
 
 template<typename Ret, typename... Args>
-auto to_function_pointer(Ret(*)(Args...)) -> Ret(*)(Args...);
+auto function_pointer(Ret(*)(Args...)) -> Ret(*)(Args...);
 
 
-template<typename Ret, typename... Args, typename Type, typename Payload, typename = std::enable_if_t<std::is_convertible_v<Payload &, Type &>>>
-auto to_function_pointer(Ret(*)(Type &, Args...), Payload &) -> Ret(*)(Args...);
+template<typename Ret, typename Type, typename... Args, typename Other>
+auto function_pointer(Ret(*)(Type, Args...), Other &&) -> Ret(*)(Args...);
 
 
-template<typename Class, typename Ret, typename... Args>
-auto to_function_pointer(Ret(Class:: *)(Args...), const Class &) -> Ret(*)(Args...);
+template<typename Class, typename Ret, typename... Args, typename... Other>
+auto function_pointer(Ret(Class:: *)(Args...), Other &&...) -> Ret(*)(Args...);
 
 
-template<typename Class, typename Ret, typename... Args>
-auto to_function_pointer(Ret(Class:: *)(Args...) const, const Class &) -> Ret(*)(Args...);
+template<typename Class, typename Ret, typename... Args, typename... Other>
+auto function_pointer(Ret(Class:: *)(Args...) const, Other &&...) -> Ret(*)(Args...);
 
 
-template<typename Class, typename Type>
-auto to_function_pointer(Type Class:: *, const Class &) -> Type(*)();
+template<typename Class, typename Type, typename... Other>
+auto function_pointer(Type Class:: *, Other &&...) -> Type(*)();
 
 
-template<typename>
-struct function_extent;
+template<typename... Type>
+using function_pointer_t = decltype(internal::function_pointer(std::declval<Type>()...));
 
 
-template<typename Ret, typename... Args>
-struct function_extent<Ret(*)(Args...)> {
-    static constexpr auto value = sizeof...(Args);
-};
-
-
-template<typename Func>
-constexpr auto function_extent_v = function_extent<Func>::value;
+template<typename... Class, typename Ret, typename... Args>
+constexpr auto index_sequence_for(Ret(*)(Args...)) {
+    return std::index_sequence_for<Class..., Args...>{};
+}
 
 
 }
@@ -73,7 +68,7 @@ struct connect_arg_t {};
 
 /*! @brief Constant of type connect_arg_t used to disambiguate calls. */
 template<auto Func>
-constexpr connect_arg_t<Func> connect_arg{};
+inline constexpr connect_arg_t<Func> connect_arg{};
 
 
 /**
@@ -92,44 +87,39 @@ class delegate;
  * Unmanaged delegate for function pointers and members. Users of this class are
  * in charge of disconnecting instances before deleting them.
  *
- * A delegate can be used as general purpose invoker with no memory overhead for
- * free functions (with or without payload) and members provided along with an
- * instance on which to invoke them.
+ * A delegate can be used as a general purpose invoker without memory overhead
+ * for free functions possibly with payloads and bound or unbound members.
  *
  * @tparam Ret Return type of a function type.
  * @tparam Args Types of arguments of a function type.
  */
 template<typename Ret, typename... Args>
 class delegate<Ret(Args...)> {
-    using proto_fn_type = Ret(const void *, std::tuple<Args &&...>);
+    using proto_fn_type = Ret(const void *, Args...);
 
-    template<auto Function, std::size_t... Index>
-    void connect(std::index_sequence<Index...>) ENTT_NOEXCEPT {
-        static_assert(std::is_invocable_r_v<Ret, decltype(Function), std::tuple_element_t<Index, std::tuple<Args...>>...>);
-        data = nullptr;
-
-        fn = [](const void *, std::tuple<Args &&...> args) -> Ret {
-            // Ret(...) makes void(...) eat the return values to avoid errors
-            return Ret(std::invoke(Function, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
+    template<auto Candidate, std::size_t... Index>
+    auto wrap(std::index_sequence<Index...>) ENTT_NOEXCEPT {
+        return [](const void *, Args... args) -> Ret {
+            const auto arguments = std::forward_as_tuple(std::forward<Args>(args)...);
+            return Ret(std::invoke(Candidate, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(arguments))...));
         };
     }
 
     template<auto Candidate, typename Type, std::size_t... Index>
-    void connect(Type &value_or_instance, std::index_sequence<Index...>) ENTT_NOEXCEPT {
-        static_assert(std::is_invocable_r_v<Ret, decltype(Candidate), Type &, std::tuple_element_t<Index, std::tuple<Args...>>...>);
-        data = &value_or_instance;
+    auto wrap(Type &, std::index_sequence<Index...>) ENTT_NOEXCEPT {
+        return [](const void *payload, Args... args) -> Ret {
+            const auto arguments = std::forward_as_tuple(std::forward<Args>(args)...);
+            Type *curr = static_cast<Type *>(const_cast<std::conditional_t<std::is_const_v<Type>, const void *, void *>>(payload));
+            return Ret(std::invoke(Candidate, *curr, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(arguments))...));
+        };
+    }
 
-        fn = [](const void *payload, std::tuple<Args &&...> args) -> Ret {
-            Type *curr = nullptr;
-
-            if constexpr(std::is_const_v<Type>) {
-                curr = static_cast<Type *>(payload);
-            } else {
-                curr = static_cast<Type *>(const_cast<void *>(payload));
-            }
-
-            // Ret(...) makes void(...) eat the return values to avoid errors
-            return Ret(std::invoke(Candidate, *curr, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(args))...));
+    template<auto Candidate, typename Type, std::size_t... Index>
+    auto wrap(Type *, std::index_sequence<Index...>) ENTT_NOEXCEPT {
+        return [](const void *payload, Args... args) -> Ret {
+            const auto arguments = std::forward_as_tuple(std::forward<Args>(args)...);
+            Type *curr = static_cast<Type *>(const_cast<std::conditional_t<std::is_const_v<Type>, const void *, void *>>(payload));
+            return Ret(std::invoke(Candidate, curr, std::forward<std::tuple_element_t<Index, std::tuple<Args...>>>(std::get<Index>(arguments))...));
         };
     }
 
@@ -143,43 +133,53 @@ public:
     {}
 
     /**
-     * @brief Constructs a delegate and connects a free function to it.
-     * @tparam Function A valid free function pointer.
+     * @brief Constructs a delegate and connects a free function or an unbound
+     * member.
+     * @tparam Candidate Function or member to connect to the delegate.
      */
-    template<auto Function>
-    delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
+    template<auto Candidate>
+    delegate(connect_arg_t<Candidate>) ENTT_NOEXCEPT
         : delegate{}
     {
-        connect<Function>();
+        connect<Candidate>();
     }
 
     /**
-     * @brief Constructs a delegate and connects a member for a given instance
-     * or a free function with payload.
-     * @tparam Candidate Member or free function to connect to the delegate.
+     * @brief Constructs a delegate and connects a free function with payload or
+     * a bound member.
+     * @tparam Candidate Function or member to connect to the delegate.
      * @tparam Type Type of class or type of payload.
-     * @param value_or_instance A valid reference that fits the purpose.
+     * @param value_or_instance A valid object that fits the purpose.
      */
     template<auto Candidate, typename Type>
-    delegate(connect_arg_t<Candidate>, Type &value_or_instance) ENTT_NOEXCEPT
+    delegate(connect_arg_t<Candidate>, Type &&value_or_instance) ENTT_NOEXCEPT
         : delegate{}
     {
-        connect<Candidate>(value_or_instance);
+        connect<Candidate>(std::forward<Type>(value_or_instance));
     }
 
     /**
-     * @brief Connects a free function to a delegate.
-     * @tparam Function A valid free function pointer.
+     * @brief Connects a free function or an unbound member to a delegate.
+     * @tparam Candidate Function or member to connect to the delegate.
      */
-    template<auto Function>
+    template<auto Candidate>
     void connect() ENTT_NOEXCEPT {
-        constexpr auto extent = internal::function_extent_v<decltype(internal::to_function_pointer(std::declval<decltype(Function)>()))>;
-        connect<Function>(std::make_index_sequence<extent>{});
+        data = nullptr;
+
+        if constexpr(std::is_invocable_r_v<Ret, decltype(Candidate), Args...>) {
+            fn = [](const void *, Args... args) -> Ret {
+                return Ret(std::invoke(Candidate, std::forward<Args>(args)...));
+            };
+        } else if constexpr(std::is_member_pointer_v<decltype(Candidate)>) {
+            fn = wrap<Candidate>(internal::index_sequence_for<std::tuple_element_t<0, std::tuple<Args...>>>(internal::function_pointer_t<decltype(Candidate)>{}));
+        } else {
+            fn = wrap<Candidate>(internal::index_sequence_for(internal::function_pointer_t<decltype(Candidate)>{}));
+        }
     }
 
     /**
-     * @brief Connects a member function for a given instance or a free function
-     * with payload to a delegate.
+     * @brief Connects a free function with payload or a bound member to a
+     * delegate.
      *
      * The delegate isn't responsible for the connected object or the payload.
      * Users must always guarantee that the lifetime of the instance overcomes
@@ -188,14 +188,46 @@ public:
      * such that the instance is the first argument before the ones used to
      * define the delegate itself.
      *
-     * @tparam Candidate Member or free function to connect to the delegate.
+     * @tparam Candidate Function or member to connect to the delegate.
      * @tparam Type Type of class or type of payload.
      * @param value_or_instance A valid reference that fits the purpose.
      */
     template<auto Candidate, typename Type>
     void connect(Type &value_or_instance) ENTT_NOEXCEPT {
-        constexpr auto extent = internal::function_extent_v<decltype(internal::to_function_pointer(std::declval<decltype(Candidate)>(), value_or_instance))>;
-        connect<Candidate>(value_or_instance, std::make_index_sequence<extent>{});
+        data = &value_or_instance;
+
+        if constexpr(std::is_invocable_r_v<Ret, decltype(Candidate), Type &, Args...>) {
+            fn = [](const void *payload, Args... args) -> Ret {
+                Type *curr = static_cast<Type *>(const_cast<std::conditional_t<std::is_const_v<Type>, const void *, void *>>(payload));
+                return Ret(std::invoke(Candidate, *curr, std::forward<Args>(args)...));
+            };
+        } else {
+            fn = wrap<Candidate>(value_or_instance, internal::index_sequence_for(internal::function_pointer_t<decltype(Candidate), Type>{}));
+        }
+    }
+
+    /**
+     * @brief Connects a free function with payload or a bound member to a
+     * delegate.
+     *
+     * @sa connect(Type &)
+     *
+     * @tparam Candidate Function or member to connect to the delegate.
+     * @tparam Type Type of class or type of payload.
+     * @param value_or_instance A valid pointer that fits the purpose.
+     */
+    template<auto Candidate, typename Type>
+    void connect(Type *value_or_instance) ENTT_NOEXCEPT {
+        data = value_or_instance;
+
+        if constexpr(std::is_invocable_r_v<Ret, decltype(Candidate), Type *, Args...>) {
+            fn = [](const void *payload, Args... args) -> Ret {
+                Type *curr = static_cast<Type *>(const_cast<std::conditional_t<std::is_const_v<Type>, const void *, void *>>(payload));
+                return Ret(std::invoke(Candidate, curr, std::forward<Args>(args)...));
+            };
+        } else {
+            fn = wrap<Candidate>(value_or_instance, internal::index_sequence_for(internal::function_pointer_t<decltype(Candidate), Type>{}));
+        }
     }
 
     /**
@@ -232,7 +264,7 @@ public:
      */
     Ret operator()(Args... args) const {
         ENTT_ASSERT(fn);
-        return fn(data, std::forward_as_tuple(std::forward<Args>(args)...));
+        return fn(data, std::forward<Args>(args)...);
     }
 
     /**
@@ -241,7 +273,7 @@ public:
      */
     explicit operator bool() const ENTT_NOEXCEPT {
         // no need to test also data
-        return fn;
+        return !(fn == nullptr);
     }
 
     /**
@@ -275,33 +307,24 @@ bool operator!=(const delegate<Ret(Args...)> &lhs, const delegate<Ret(Args...)>
 
 /**
  * @brief Deduction guide.
- *
- * It allows to deduce the function type of the delegate directly from a
- * function provided to the constructor.
- *
- * @tparam Function A valid free function pointer.
+ * @tparam Candidate Function or member to connect to the delegate.
  */
-template<auto Function>
-delegate(connect_arg_t<Function>) ENTT_NOEXCEPT
--> delegate<std::remove_pointer_t<decltype(internal::to_function_pointer(Function))>>;
+template<auto Candidate>
+delegate(connect_arg_t<Candidate>) ENTT_NOEXCEPT
+-> delegate<std::remove_pointer_t<internal::function_pointer_t<decltype(Candidate)>>>;
 
 
 /**
  * @brief Deduction guide.
- *
- * It allows to deduce the function type of the delegate directly from a member
- * or a free function with payload provided to the constructor.
- *
- * @param value_or_instance A valid reference that fits the purpose.
- * @tparam Candidate Member or free function to connect to the delegate.
+ * @tparam Candidate Function or member to connect to the delegate.
  * @tparam Type Type of class or type of payload.
  */
 template<auto Candidate, typename Type>
-delegate(connect_arg_t<Candidate>, Type &value_or_instance) ENTT_NOEXCEPT
--> delegate<std::remove_pointer_t<decltype(internal::to_function_pointer(Candidate, value_or_instance))>>;
+delegate(connect_arg_t<Candidate>, Type &&) ENTT_NOEXCEPT
+-> delegate<std::remove_pointer_t<internal::function_pointer_t<decltype(Candidate), Type>>>;
 
 
 }
 
 
-#endif // ENTT_SIGNAL_DELEGATE_HPP
+#endif

src/entt/signal/dispatcher.hpp

@@ -2,13 +2,14 @@
 #define ENTT_SIGNAL_DISPATCHER_HPP
 
 
-#include <vector>
+#include <cstddef>
 #include <memory>
-#include <utility>
 #include <type_traits>
+#include <utility>
+#include <vector>
 #include "../config/config.h"
-#include "../core/family.hpp"
-#include "../core/type_traits.hpp"
+#include "../core/fwd.hpp"
+#include "../core/type_info.hpp"
 #include "sigh.hpp"
 
 
@@ -24,33 +25,34 @@ namespace entt {
  * type `Event`, listeners are such that they can be invoked with an argument of
  * type `const Event &`, no matter what the return type is.
  *
- * The types of the instances are `Class &`. Users must guarantee that the
- * lifetimes of the objects overcome the one of the dispatcher itself to avoid
- * crashes.
+ * The dispatcher creates instances of the `sigh` class internally. Refer to the
+ * documentation of the latter for more details.
  */
 class dispatcher {
-    using event_family = family<struct internal_dispatcher_event_family>;
-
-    template<typename Class, typename Event>
-    using instance_type = typename sigh<void(const Event &)>::template instance_type<Class>;
-
-    struct base_wrapper {
-        virtual ~base_wrapper() = default;
+    struct basic_pool {
+        virtual ~basic_pool() = default;
         virtual void publish() = 0;
+        virtual void clear() ENTT_NOEXCEPT = 0;
+        virtual id_type type_id() const ENTT_NOEXCEPT = 0;
     };
 
     template<typename Event>
-    struct signal_wrapper: base_wrapper {
+    struct pool_handler final: basic_pool {
         using signal_type = sigh<void(const Event &)>;
         using sink_type = typename signal_type::sink_type;
 
         void publish() override {
-            for(const auto &event: events[current]) {
-                signal.publish(event);
+            const auto length = events.size();
+
+            for(std::size_t pos{}; pos < length; ++pos) {
+                signal.publish(events[pos]);
             }
 
-            events[current++].clear();
-            current %= std::extent<decltype(events)>::value;
+            events.erase(events.cbegin(), events.cbegin()+length);
+        }
+
+        void clear() ENTT_NOEXCEPT override {
+            events.clear();
         }
 
         sink_type sink() ENTT_NOEXCEPT {
@@ -59,72 +61,46 @@ class dispatcher {
 
         template<typename... Args>
         void trigger(Args &&... args) {
-            signal.publish({ std::forward<Args>(args)... });
+            signal.publish(Event{std::forward<Args>(args)...});
         }
 
         template<typename... Args>
         void enqueue(Args &&... args) {
-            events[current].emplace_back(std::forward<Args>(args)...);
+            events.emplace_back(std::forward<Args>(args)...);
+        }
+
+        id_type type_id() const ENTT_NOEXCEPT override {
+            return type_info<Event>::id();
         }
 
     private:
         signal_type signal{};
-        std::vector<Event> events[2];
-        int current{};
-    };
-
-    struct wrapper_data {
-        std::unique_ptr<base_wrapper> wrapper;
-        ENTT_ID_TYPE runtime_type;
+        std::vector<Event> events;
     };
 
     template<typename Event>
-    static auto type() ENTT_NOEXCEPT {
-        if constexpr(is_named_type_v<Event>) {
-            return named_type_traits<Event>::value;
-        } else {
-            return event_family::type<Event>;
-        }
-    }
+    pool_handler<Event> & assure() {
+        static_assert(std::is_same_v<Event, std::decay_t<Event>>);
 
-    template<typename Event>
-    signal_wrapper<Event> & assure() {
-        const auto wtype = type<Event>();
-        wrapper_data *wdata = nullptr;
+        if constexpr(has_type_index_v<Event>) {
+            const auto index = type_index<Event>::value();
 
-        if constexpr(is_named_type_v<Event>) {
-            const auto it = std::find_if(wrappers.begin(), wrappers.end(), [wtype](const auto &candidate) {
-                return candidate.wrapper && candidate.runtime_type == wtype;
-            });
-
-            wdata = (it == wrappers.cend() ? &wrappers.emplace_back() : &(*it));
-        } else {
-            if(!(wtype < wrappers.size())) {
-                wrappers.resize(wtype+1);
+            if(!(index < pools.size())) {
+                pools.resize(index+1);
             }
 
-            wdata = &wrappers[wtype];
-
-            if(wdata->wrapper && wdata->runtime_type != wtype) {
-                wrappers.emplace_back();
-                std::swap(wrappers[wtype], wrappers.back());
-                wdata = &wrappers[wtype];
+            if(!pools[index]) {
+                pools[index].reset(new pool_handler<Event>{});
             }
-        }
 
-        if(!wdata->wrapper) {
-            wdata->wrapper = std::make_unique<signal_wrapper<Event>>();
-            wdata->runtime_type = wtype;
+            return static_cast<pool_handler<Event> &>(*pools[index]);
+        } else {
+            auto it = std::find_if(pools.begin(), pools.end(), [id = type_info<Event>::id()](const auto &cpool) { return id == cpool->type_id(); });
+            return static_cast<pool_handler<Event> &>(it == pools.cend() ? *pools.emplace_back(new pool_handler<Event>{}) : **it);
         }
-
-        return static_cast<signal_wrapper<Event> &>(*wdata->wrapper);
     }
 
 public:
-    /*! @brief Type of sink for the given event. */
-    template<typename Event>
-    using sink_type = typename signal_wrapper<Event>::sink_type;
-
     /**
      * @brief Returns a sink object for the given event.
      *
@@ -143,7 +119,7 @@ public:
      * @return A temporary sink object.
      */
     template<typename Event>
-    sink_type<Event> sink() ENTT_NOEXCEPT {
+    auto sink() {
         return assure<Event>().sink();
     }
 
@@ -205,6 +181,27 @@ public:
         assure<std::decay_t<Event>>().enqueue(std::forward<Event>(event));
     }
 
+    /**
+     * @brief Discards all the events queued so far.
+     *
+     * If no types are provided, the dispatcher will clear all the existing
+     * pools.
+     *
+     * @tparam Event Type of events to discard.
+     */
+    template<typename... Event>
+    void clear() {
+        if constexpr(sizeof...(Event) == 0) {
+            for(auto &&cpool: pools) {
+                if(cpool) {
+                    cpool->clear();
+                }
+            }
+        } else {
+            (assure<Event>().clear(), ...);
+        }
+    }
+
     /**
      * @brief Delivers all the pending events of the given type.
      *
@@ -227,21 +224,19 @@ public:
      * to reduce at a minimum the time spent in the bodies of the listeners.
      */
     void update() const {
-        for(auto pos = wrappers.size(); pos; --pos) {
-            auto &wdata = wrappers[pos-1];
-
-            if(wdata.wrapper) {
-                wdata.wrapper->publish();
+        for(auto pos = pools.size(); pos; --pos) {
+            if(auto &&cpool = pools[pos-1]; cpool) {
+                cpool->publish();
             }
         }
     }
 
 private:
-    std::vector<wrapper_data> wrappers;
+    std::vector<std::unique_ptr<basic_pool>> pools;
 };
 
 
 }
 
 
-#endif // ENTT_SIGNAL_DISPATCHER_HPP
+#endif

src/entt/signal/emitter.hpp

@@ -2,16 +2,17 @@
 #define ENTT_SIGNAL_EMITTER_HPP
 
 
-#include <type_traits>
-#include <functional>
 #include <algorithm>
-#include <utility>
-#include <memory>
-#include <vector>
+#include <functional>
+#include <iterator>
 #include <list>
+#include <memory>
+#include <type_traits>
+#include <utility>
+#include <vector>
 #include "../config/config.h"
-#include "../core/family.hpp"
-#include "../core/type_traits.hpp"
+#include "../core/fwd.hpp"
+#include "../core/type_info.hpp"
 
 
 namespace entt {
@@ -29,7 +30,7 @@ namespace entt {
  * }
  * @endcode
  *
- * Handlers for the type of events are created internally on the fly. It's not
+ * Pools for the type of events are created internally on the fly. It's not
  * required to specify in advance the full list of accepted types.<br/>
  * Moreover, whenever an event is published, an emitter provides the listeners
  * with a reference to itself along with a const reference to the event.
@@ -40,16 +41,15 @@ namespace entt {
  */
 template<typename Derived>
 class emitter {
-    using handler_family = family<struct internal_emitter_handler_family>;
-
-    struct base_handler {
-        virtual ~base_handler() = default;
+    struct basic_pool {
+        virtual ~basic_pool() = default;
         virtual bool empty() const ENTT_NOEXCEPT = 0;
         virtual void clear() ENTT_NOEXCEPT = 0;
+        virtual id_type type_id() const ENTT_NOEXCEPT = 0;
     };
 
     template<typename Event>
-    struct event_handler: base_handler {
+    struct pool_handler final: basic_pool {
         using listener_type = std::function<void(const Event &, Derived &)>;
         using element_type = std::pair<bool, listener_type>;
         using container_type = std::list<element_type>;
@@ -64,9 +64,13 @@ class emitter {
 
         void clear() ENTT_NOEXCEPT override {
             if(publishing) {
-                auto func = [](auto &&element) { element.first = true; };
-                std::for_each(once_list.begin(), once_list.end(), func);
-                std::for_each(on_list.begin(), on_list.end(), func);
+                for(auto &&element: once_list) {
+                    element.first = true;
+                }
+
+                for(auto &&element: on_list) {
+                    element.first = true;
+                }
             } else {
                 once_list.clear();
                 on_list.clear();
@@ -81,7 +85,7 @@ class emitter {
             return on_list.emplace(on_list.cend(), false, std::move(listener));
         }
 
-        void erase(connection_type conn) ENTT_NOEXCEPT {
+        void erase(connection_type conn) {
             conn->first = true;
 
             if(!publishing) {
@@ -95,77 +99,62 @@ class emitter {
             container_type swap_list;
             once_list.swap(swap_list);
 
-            auto func = [&event, &ref](auto &&element) {
-                return element.first ? void() : element.second(event, ref);
-            };
-
             publishing = true;
 
-            std::for_each(on_list.rbegin(), on_list.rend(), func);
-            std::for_each(swap_list.rbegin(), swap_list.rend(), func);
+            for(auto &&element: on_list) {
+                element.first ? void() : element.second(event, ref);
+            }
+
+            for(auto &&element: swap_list) {
+                element.first ? void() : element.second(event, ref);
+            }
 
             publishing = false;
 
             on_list.remove_if([](auto &&element) { return element.first; });
         }
 
+        id_type type_id() const ENTT_NOEXCEPT override {
+            return type_info<Event>::id();
+        }
+
     private:
         bool publishing{false};
         container_type once_list{};
         container_type on_list{};
     };
 
-    struct handler_data {
-        std::unique_ptr<base_handler> handler;
-        ENTT_ID_TYPE runtime_type;
-    };
-
     template<typename Event>
-    static auto type() ENTT_NOEXCEPT {
-        if constexpr(is_named_type_v<Event>) {
-            return named_type_traits<Event>::value;
+    const pool_handler<Event> & assure() const {
+        static_assert(std::is_same_v<Event, std::decay_t<Event>>);
+
+        if constexpr(has_type_index_v<Event>) {
+            const auto index = type_index<Event>::value();
+
+            if(!(index < pools.size())) {
+                pools.resize(index+1);
+            }
+
+            if(!pools[index]) {
+                pools[index].reset(new pool_handler<Event>{});
+            }
+
+            return static_cast<pool_handler<Event> &>(*pools[index]);
         } else {
-            return handler_family::type<Event>;
+            auto it = std::find_if(pools.begin(), pools.end(), [id = type_info<Event>::id()](const auto &cpool) { return id == cpool->type_id(); });
+            return static_cast<pool_handler<Event> &>(it == pools.cend() ? *pools.emplace_back(new pool_handler<Event>{}) : **it);
         }
     }
 
     template<typename Event>
-    event_handler<Event> * assure() const ENTT_NOEXCEPT {
-        const auto htype = type<Event>();
-        handler_data *hdata = nullptr;
-
-        if constexpr(is_named_type_v<Event>) {
-            const auto it = std::find_if(handlers.begin(), handlers.end(), [htype](const auto &candidate) {
-                return candidate.handler && candidate.runtime_type == htype;
-            });
-
-            hdata = (it == handlers.cend() ? &handlers.emplace_back() : &(*it));
-        } else {
-            if(!(htype < handlers.size())) {
-                handlers.resize(htype+1);
-            }
-
-            hdata = &handlers[htype];
-
-            if(hdata->handler && hdata->runtime_type != htype) {
-                handlers.emplace_back();
-                std::swap(handlers[htype], handlers.back());
-                hdata = &handlers[htype];
-            }
-        }
-
-        if(!hdata->handler) {
-            hdata->handler = std::make_unique<event_handler<Event>>();
-            hdata->runtime_type = htype;
-        }
-
-        return static_cast<event_handler<Event> *>(hdata->handler.get());
+    pool_handler<Event> & assure() {
+        return const_cast<pool_handler<Event> &>(std::as_const(*this).template assure<Event>());
     }
 
 public:
     /** @brief Type of listeners accepted for the given event. */
     template<typename Event>
-    using listener = typename event_handler<Event>::listener_type;
+    using listener = typename pool_handler<Event>::listener_type;
 
     /**
      * @brief Generic connection type for events.
@@ -177,27 +166,27 @@ public:
      * @tparam Event Type of event for which the connection is created.
      */
     template<typename Event>
-    struct connection: private event_handler<Event>::connection_type {
+    struct connection: private pool_handler<Event>::connection_type {
         /** @brief Event emitters are friend classes of connections. */
         friend class emitter;
 
         /*! @brief Default constructor. */
-        connection() ENTT_NOEXCEPT = default;
+        connection() = default;
 
         /**
          * @brief Creates a connection that wraps its underlying instance.
          * @param conn A connection object to wrap.
          */
-        connection(typename event_handler<Event>::connection_type conn)
-            : event_handler<Event>::connection_type{std::move(conn)}
+        connection(typename pool_handler<Event>::connection_type conn)
+            : pool_handler<Event>::connection_type{std::move(conn)}
         {}
     };
 
     /*! @brief Default constructor. */
-    emitter() ENTT_NOEXCEPT = default;
+    emitter() = default;
 
     /*! @brief Default destructor. */
-    virtual ~emitter() ENTT_NOEXCEPT {
+    virtual ~emitter() {
         static_assert(std::is_base_of_v<emitter<Derived>, Derived>);
     }
 
@@ -220,7 +209,7 @@ public:
      */
     template<typename Event, typename... Args>
     void publish(Args &&... args) {
-        assure<Event>()->publish({ std::forward<Args>(args)... }, *static_cast<Derived *>(this));
+        assure<Event>().publish(Event{std::forward<Args>(args)...}, *static_cast<Derived *>(this));
     }
 
     /**
@@ -245,7 +234,7 @@ public:
      */
     template<typename Event>
     connection<Event> on(listener<Event> instance) {
-        return assure<Event>()->on(std::move(instance));
+        return assure<Event>().on(std::move(instance));
     }
 
     /**
@@ -270,7 +259,7 @@ public:
      */
     template<typename Event>
     connection<Event> once(listener<Event> instance) {
-        return assure<Event>()->once(std::move(instance));
+        return assure<Event>().once(std::move(instance));
     }
 
     /**
@@ -283,8 +272,8 @@ public:
      * @param conn A valid connection.
      */
     template<typename Event>
-    void erase(connection<Event> conn) ENTT_NOEXCEPT {
-        assure<Event>()->erase(std::move(conn));
+    void erase(connection<Event> conn) {
+        assure<Event>().erase(std::move(conn));
     }
 
     /**
@@ -296,8 +285,8 @@ public:
      * @tparam Event Type of event to reset.
      */
     template<typename Event>
-    void clear() ENTT_NOEXCEPT {
-        assure<Event>()->clear();
+    void clear() {
+        assure<Event>().clear();
     }
 
     /**
@@ -307,9 +296,11 @@ public:
      * results in undefined behavior.
      */
     void clear() ENTT_NOEXCEPT {
-        std::for_each(handlers.begin(), handlers.end(), [](auto &&hdata) {
-            return hdata.handler ? hdata.handler->clear() : void();
-        });
+        for(auto &&cpool: pools) {
+            if(cpool) {
+                cpool->clear();
+            }
+        }
     }
 
     /**
@@ -318,8 +309,8 @@ public:
      * @return True if there are no listeners registered, false otherwise.
      */
     template<typename Event>
-    bool empty() const ENTT_NOEXCEPT {
-        return assure<Event>()->empty();
+    bool empty() const {
+        return assure<Event>().empty();
     }
 
     /**
@@ -327,17 +318,17 @@ public:
      * @return True if there are no listeners registered, false otherwise.
      */
     bool empty() const ENTT_NOEXCEPT {
-        return std::all_of(handlers.cbegin(), handlers.cend(), [](auto &&hdata) {
-            return !hdata.handler || hdata.handler->empty();
+        return std::all_of(pools.cbegin(), pools.cend(), [](auto &&cpool) {
+            return !cpool || cpool->empty();
         });
     }
 
 private:
-    mutable std::vector<handler_data> handlers{};
+    mutable std::vector<std::unique_ptr<basic_pool>> pools{};
 };
 
 
 }
 
 
-#endif // ENTT_SIGNAL_EMITTER_HPP
+#endif

src/entt/signal/fwd.hpp

@@ -2,9 +2,6 @@
 #define ENTT_SIGNAL_FWD_HPP
 
 
-#include "../config/config.h"
-
-
 namespace entt {
 
 
@@ -12,6 +9,19 @@ namespace entt {
 template<typename>
 class delegate;
 
+/*! @class dispatcher */
+class dispatcher;
+
+/*! @class emitter */
+template<typename>
+class emitter;
+
+/*! @class connection */
+class connection;
+
+/*! @class scoped_connection */
+struct scoped_connection;
+
 /*! @class sink */
 template<typename>
 class sink;
@@ -24,4 +34,4 @@ class sigh;
 }
 
 
-#endif // ENTT_SIGNAL_FWD_HPP
+#endif

src/entt/signal/sigh.hpp

@@ -2,9 +2,10 @@
 #define ENTT_SIGNAL_SIGH_HPP
 
 
-#include <algorithm>
-#include <utility>
 #include <vector>
+#include <utility>
+#include <iterator>
+#include <algorithm>
 #include <functional>
 #include <type_traits>
 #include "../config/config.h"
@@ -61,7 +62,7 @@ class sigh<Ret(Args...)> {
 
 public:
     /*! @brief Unsigned integer type. */
-    using size_type = typename std::vector<delegate<Ret(Args...)>>::size_type;
+    using size_type = std::size_t;
     /*! @brief Sink type. */
     using sink_type = entt::sink<Ret(Args...)>;
 
@@ -96,8 +97,8 @@ public:
      * @param args Arguments to use to invoke listeners.
      */
     void publish(Args... args) const {
-        for(auto pos = calls.size(); pos; --pos) {
-            calls[pos-1](args...);
+        for(auto &&call: std::as_const(calls)) {
+            call(args...);
         }
     }
 
@@ -117,22 +118,20 @@ public:
      */
     template<typename Func>
     void collect(Func func, Args... args) const {
-        bool stop = false;
-
-        for(auto pos = calls.size(); pos && !stop; --pos) {
+        for(auto &&call: calls) {
             if constexpr(std::is_void_v<Ret>) {
                 if constexpr(std::is_invocable_r_v<bool, Func>) {
-                    calls[pos-1](args...);
-                    stop = func();
+                    call(args...);
+                    if(func()) { break; }
                 } else {
-                    calls[pos-1](args...);
+                    call(args...);
                     func();
                 }
             } else {
                 if constexpr(std::is_invocable_r_v<bool, Func, Ret>) {
-                    stop = func(calls[pos-1](args...));
+                    if(func(call(args...))) { break; }
                 } else {
-                    func(calls[pos-1](args...));
+                    func(call(args...));
                 }
             }
         }
@@ -163,38 +162,6 @@ public:
     /*! @brief Default constructor. */
     connection() = default;
 
-    /*! @brief Default copy constructor. */
-    connection(const connection &) = default;
-
-    /**
-     * @brief Default move constructor.
-     * @param other The instance to move from.
-     */
-    connection(connection &&other)
-        : connection{}
-    {
-        std::swap(disconnect, other.disconnect);
-        std::swap(signal, other.signal);
-    }
-
-    /*! @brief Default copy assignment operator. @return This connection. */
-    connection & operator=(const connection &) = default;
-
-    /**
-     * @brief Default move assignment operator.
-     * @param other The instance to move from.
-     * @return This connection.
-     */
-    connection & operator=(connection &&other) {
-        if(this != &other) {
-            auto tmp{std::move(other)};
-            disconnect = tmp.disconnect;
-            signal = tmp.signal;
-        }
-
-        return *this;
-    }
-
     /**
      * @brief Checks whether a connection is properly initialized.
      * @return True if the connection is properly initialized, false otherwise.
@@ -226,27 +193,24 @@ private:
  * A scoped connection automatically breaks the link between the two objects
  * when it goes out of scope.
  */
-struct scoped_connection: private connection {
+struct scoped_connection {
     /*! @brief Default constructor. */
     scoped_connection() = default;
 
     /**
      * @brief Constructs a scoped connection from a basic connection.
-     * @param conn A valid connection object.
+     * @param other A valid connection object.
      */
-    scoped_connection(const connection &conn)
-        : connection{conn}
+    scoped_connection(const connection &other)
+        : conn{other}
     {}
 
     /*! @brief Default copy constructor, deleted on purpose. */
     scoped_connection(const scoped_connection &) = delete;
 
-    /*! @brief Default move constructor. */
-    scoped_connection(scoped_connection &&) = default;
-
     /*! @brief Automatically breaks the link on destruction. */
     ~scoped_connection() {
-        connection::release();
+        conn.release();
     }
 
     /**
@@ -256,33 +220,30 @@ struct scoped_connection: private connection {
     scoped_connection & operator=(const scoped_connection &) = delete;
 
     /**
-     * @brief Default move assignment operator.
+     * @brief Acquires a connection.
+     * @param other The connection object to acquire.
      * @return This scoped connection.
      */
-    scoped_connection & operator=(scoped_connection &&) = default;
-
-    /**
-     * @brief Copies a connection.
-     * @param other The connection object to copy.
-     * @return This scoped connection.
-     */
-    scoped_connection & operator=(const connection &other) {
-        static_cast<connection &>(*this) = other;
+    scoped_connection & operator=(connection other) {
+        conn = std::move(other);
         return *this;
     }
 
     /**
-     * @brief Moves a connection.
-     * @param other The connection object to move.
-     * @return This scoped connection.
+     * @brief Checks whether a scoped connection is properly initialized.
+     * @return True if the connection is properly initialized, false otherwise.
      */
-    scoped_connection & operator=(connection &&other) {
-        static_cast<connection &>(*this) = std::move(other);
-        return *this;
+    explicit operator bool() const ENTT_NOEXCEPT {
+        return static_cast<bool>(conn);
     }
 
-    using connection::operator bool;
-    using connection::release;
+    /*! @brief Breaks the connection. */
+    void release() {
+        conn.release();
+    }
+
+private:
+    connection conn;
 };
 
 
@@ -303,15 +264,16 @@ struct scoped_connection: private connection {
 template<typename Ret, typename... Args>
 class sink<Ret(Args...)> {
     using signal_type = sigh<Ret(Args...)>;
+    using difference_type = typename std::iterator_traits<typename decltype(signal_type::calls)::iterator>::difference_type;
 
     template<auto Candidate, typename Type>
-    static void release(Type &value_or_instance, void *signal) {
+    static void release(Type value_or_instance, void *signal) {
         sink{*static_cast<signal_type *>(signal)}.disconnect<Candidate>(value_or_instance);
     }
 
-    template<auto Function>
+    template<auto Candidate>
     static void release(void *signal) {
-        sink{*static_cast<signal_type *>(signal)}.disconnect<Function>();
+        sink{*static_cast<signal_type *>(signal)}.disconnect<Candidate>();
     }
 
 public:
@@ -320,7 +282,8 @@ public:
      * @param ref A valid reference to a signal object.
      */
     sink(sigh<Ret(Args...)> &ref) ENTT_NOEXCEPT
-        : signal{&ref}
+        : offset{},
+          signal{&ref}
     {}
 
     /**
@@ -332,88 +295,194 @@ public:
     }
 
     /**
-     * @brief Connects a free function to a signal.
-     *
-     * The signal handler performs checks to avoid multiple connections for free
-     * functions.
-     *
+     * @brief Returns a sink that connects before a given free function or an
+     * unbound member.
      * @tparam Function A valid free function pointer.
-     * @return A properly initialized connection object.
+     * @return A properly initialized sink object.
      */
     template<auto Function>
+    sink before() {
+        delegate<Ret(Args...)> call{};
+        call.template connect<Function>();
+
+        const auto &calls = signal->calls;
+        const auto it = std::find(calls.cbegin(), calls.cend(), std::move(call));
+
+        sink other{*this};
+        other.offset = std::distance(it, calls.cend());
+        return other;
+    }
+
+    /**
+     * @brief Returns a sink that connects before a free function with payload
+     * or a bound member.
+     * @tparam Candidate Member or free function to look for.
+     * @tparam Type Type of class or type of payload.
+     * @param value_or_instance A valid object that fits the purpose.
+     * @return A properly initialized sink object.
+     */
+    template<auto Candidate, typename Type>
+    sink before(Type &&value_or_instance) {
+        delegate<Ret(Args...)> call{};
+        call.template connect<Candidate>(std::forward<Type>(value_or_instance));
+
+        const auto &calls = signal->calls;
+        const auto it = std::find(calls.cbegin(), calls.cend(), std::move(call));
+
+        sink other{*this};
+        other.offset = std::distance(it, calls.cend());
+        return other;
+    }
+
+    /**
+     * @brief Returns a sink that connects before a given instance or specific
+     * payload.
+     * @tparam Type Type of class or type of payload.
+     * @param value_or_instance A valid object that fits the purpose.
+     * @return A properly initialized sink object.
+     */
+    template<typename Type>
+    sink before(Type &value_or_instance) {
+        return before(&value_or_instance);
+    }
+
+    /**
+     * @brief Returns a sink that connects before a given instance or specific
+     * payload.
+     * @tparam Type Type of class or type of payload.
+     * @param value_or_instance A valid pointer that fits the purpose.
+     * @return A properly initialized sink object.
+     */
+    template<typename Type>
+    sink before(Type *value_or_instance) {
+        sink other{*this};
+
+        if(value_or_instance) {
+            const auto &calls = signal->calls;
+            const auto it = std::find_if(calls.cbegin(), calls.cend(), [value_or_instance](const auto &delegate) {
+                return delegate.instance() == value_or_instance;
+            });
+
+            other.offset = std::distance(it, calls.cend());
+        }
+
+        return other;
+    }
+
+    /**
+     * @brief Returns a sink that connects before anything else.
+     * @return A properly initialized sink object.
+     */
+    sink before() {
+        sink other{*this};
+        other.offset = signal->calls.size();
+        return other;
+    }
+
+    /**
+     * @brief Connects a free function or an unbound member to a signal.
+     *
+     * The signal handler performs checks to avoid multiple connections for the
+     * same function.
+     *
+     * @tparam Candidate Function or member to connect to the signal.
+     * @return A properly initialized connection object.
+     */
+    template<auto Candidate>
     connection connect() {
-        disconnect<Function>();
+        disconnect<Candidate>();
+
+        delegate<Ret(Args...)> call{};
+        call.template connect<Candidate>();
+        signal->calls.insert(signal->calls.end() - offset, std::move(call));
+
         delegate<void(void *)> conn{};
-        conn.template connect<&release<Function>>();
-        signal->calls.emplace_back(delegate<Ret(Args...)>{connect_arg<Function>});
+        conn.template connect<&release<Candidate>>();
         return { std::move(conn), signal };
     }
 
     /**
-     * @brief Connects a member function or a free function with payload to a
+     * @brief Connects a free function with payload or a bound member to a
      * signal.
      *
      * The signal isn't responsible for the connected object or the payload.
      * Users must always guarantee that the lifetime of the instance overcomes
-     * the one  of the delegate. On the other side, the signal handler performs
+     * the one of the signal. On the other side, the signal handler performs
      * checks to avoid multiple connections for the same function.<br/>
      * When used to connect a free function with payload, its signature must be
      * such that the instance is the first argument before the ones used to
-     * define the delegate itself.
+     * define the signal itself.
      *
-     * @tparam Candidate Member or free function to connect to the signal.
+     * @tparam Candidate Function or member to connect to the signal.
      * @tparam Type Type of class or type of payload.
-     * @param value_or_instance A valid reference that fits the purpose.
+     * @param value_or_instance A valid object that fits the purpose.
      * @return A properly initialized connection object.
      */
     template<auto Candidate, typename Type>
-    connection connect(Type &value_or_instance) {
+    connection connect(Type &&value_or_instance) {
         disconnect<Candidate>(value_or_instance);
+
+        delegate<Ret(Args...)> call{};
+        call.template connect<Candidate>(value_or_instance);
+        signal->calls.insert(signal->calls.end() - offset, std::move(call));
+
         delegate<void(void *)> conn{};
-        conn.template connect<&sink::release<Candidate, Type>>(value_or_instance);
-        signal->calls.emplace_back(delegate<Ret(Args...)>{connect_arg<Candidate>, value_or_instance});
+        conn.template connect<&release<Candidate, Type>>(value_or_instance);
         return { std::move(conn), signal };
     }
 
     /**
-     * @brief Disconnects a free function from a signal.
-     * @tparam Function A valid free function pointer.
+     * @brief Disconnects a free function or an unbound member from a signal.
+     * @tparam Candidate Function or member to disconnect from the signal.
      */
-    template<auto Function>
+    template<auto Candidate>
     void disconnect() {
         auto &calls = signal->calls;
-        delegate<Ret(Args...)> delegate{};
-        delegate.template connect<Function>();
-        calls.erase(std::remove(calls.begin(), calls.end(), delegate), calls.end());
+        delegate<Ret(Args...)> call{};
+        call.template connect<Candidate>();
+        calls.erase(std::remove(calls.begin(), calls.end(), std::move(call)), calls.end());
     }
 
     /**
-     * @brief Disconnects a member function or a free function with payload from
-     * a signal.
-     * @tparam Candidate Member or free function to disconnect from the signal.
+     * @brief Disconnects a free function with payload or a bound member from a
+     * signal.
+     * @tparam Candidate Function or member to disconnect from the signal.
      * @tparam Type Type of class or type of payload.
-     * @param value_or_instance A valid reference that fits the purpose.
+     * @param value_or_instance A valid object that fits the purpose.
      */
     template<auto Candidate, typename Type>
-    void disconnect(Type &value_or_instance) {
+    void disconnect(Type &&value_or_instance) {
         auto &calls = signal->calls;
-        delegate<Ret(Args...)> delegate{};
-        delegate.template connect<Candidate>(value_or_instance);
-        calls.erase(std::remove(calls.begin(), calls.end(), delegate), calls.end());
+        delegate<Ret(Args...)> call{};
+        call.template connect<Candidate>(std::forward<Type>(value_or_instance));
+        calls.erase(std::remove(calls.begin(), calls.end(), std::move(call)), calls.end());
     }
 
     /**
-     * @brief Disconnects member functions or free functions based on an
-     * instance or specific payload.
+     * @brief Disconnects free functions with payload or bound members from a
+     * signal.
      * @tparam Type Type of class or type of payload.
-     * @param value_or_instance A valid reference that fits the purpose.
+     * @param value_or_instance A valid object that fits the purpose.
      */
     template<typename Type>
-    void disconnect(const Type &value_or_instance) {
-        auto &calls = signal->calls;
-        calls.erase(std::remove_if(calls.begin(), calls.end(), [&value_or_instance](const auto &delegate) {
-            return delegate.instance() == &value_or_instance;
-        }), calls.end());
+    void disconnect(Type &value_or_instance) {
+        disconnect(&value_or_instance);
+    }
+
+    /**
+     * @brief Disconnects free functions with payload or bound members from a
+     * signal.
+     * @tparam Type Type of class or type of payload.
+     * @param value_or_instance A valid object that fits the purpose.
+     */
+    template<typename Type>
+    void disconnect(Type *value_or_instance) {
+        if(value_or_instance) {
+            auto &calls = signal->calls;
+            calls.erase(std::remove_if(calls.begin(), calls.end(), [value_or_instance](const auto &delegate) {
+                return delegate.instance() == value_or_instance;
+            }), calls.end());
+        }
     }
 
     /*! @brief Disconnects all the listeners from a signal. */
@@ -422,6 +491,7 @@ public:
     }
 
 private:
+    difference_type offset;
     signal_type *signal;
 };
 
@@ -442,4 +512,4 @@ sink(sigh<Ret(Args...)> &) ENTT_NOEXCEPT -> sink<Ret(Args...)>;
 }
 
 
-#endif // ENTT_SIGNAL_SIGH_HPP
+#endif

test/CMakeLists.txt

@@ -2,128 +2,193 @@
 # Tests configuration
 #
 
+include(FetchContent)
+
+set(THREADS_PREFER_PTHREAD_FLAG ON)
+find_package(Threads REQUIRED)
+
+if(FIND_GTEST_PACKAGE)
+    find_package(GTest REQUIRED)
+else()
+    FetchContent_Declare(
+        googletest
+        GIT_REPOSITORY https://github.com/google/googletest.git
+        GIT_TAG master
+        GIT_SHALLOW 1
+    )
+
+    FetchContent_GetProperties(googletest)
+
+    if(NOT googletest_POPULATED)
+        FetchContent_Populate(googletest)
+        set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
+        add_subdirectory(${googletest_SOURCE_DIR} ${googletest_BINARY_DIR})
+    endif()
+
+    add_library(GTest::Main ALIAS gtest_main)
+
+    target_compile_features(gtest PUBLIC cxx_std_17)
+    target_compile_features(gtest_main PUBLIC cxx_std_17)
+    target_compile_features(gmock PUBLIC cxx_std_17)
+    target_compile_features(gmock_main PUBLIC cxx_std_17)
+endif()
+
 include_directories($<TARGET_PROPERTY:EnTT,INTERFACE_INCLUDE_DIRECTORIES>)
 add_compile_options($<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_OPTIONS>)
 
-macro(SETUP_LIBRARY_TARGET LIB_TARGET)
-    set_target_properties(${LIB_TARGET} PROPERTIES CXX_EXTENSIONS OFF)
-    target_compile_definitions(${LIB_TARGET} PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_DEFINITIONS>)
-    target_compile_features(${LIB_TARGET} PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_FEATURES>)
-    target_compile_options(${LIB_TARGET} PRIVATE $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-pedantic -Wall>)
-    target_compile_options(${LIB_TARGET} PRIVATE $<$<CXX_COMPILER_ID:MSVC>:/EHsc>)
-endmacro()
+function(SETUP_TARGET TARGET_NAME)
+    set_target_properties(${TARGET_NAME} PROPERTIES CXX_EXTENSIONS OFF)
+    target_link_libraries(${TARGET_NAME} PRIVATE EnTT)
+
+    target_compile_options(
+        ${TARGET_NAME}
+        PRIVATE
+            $<$<NOT:$<PLATFORM_ID:Windows>>:-pedantic -fvisibility=hidden -Wall -Wshadow -Wno-deprecated-declarations>
+            $<$<PLATFORM_ID:Windows>:/EHsc /W1 /wd4996 /w14800>
+    )
+
+    target_compile_options(
+        ${TARGET_NAME}
+        PRIVATE
+            $<$<AND:$<CONFIG:Debug>,$<NOT:$<PLATFORM_ID:Windows>>>:-O0 -g>
+            $<$<AND:$<CONFIG:Release>,$<NOT:$<PLATFORM_ID:Windows>>>:-O2>
+            $<$<AND:$<CONFIG:Debug>,$<PLATFORM_ID:Windows>>:/Od>
+            $<$<AND:$<CONFIG:Release>,$<PLATFORM_ID:Windows>>:/O2>
+    )
+endfunction()
 
 add_library(odr OBJECT odr.cpp)
-SETUP_LIBRARY_TARGET(odr)
+SETUP_TARGET(odr)
 
-macro(SETUP_AND_ADD_TEST TEST_NAME TEST_SOURCE)
-    add_executable(${TEST_NAME} $<TARGET_OBJECTS:odr> ${TEST_SOURCE})
-    set_target_properties(${TEST_NAME} PROPERTIES CXX_EXTENSIONS OFF)
-    target_link_libraries(${TEST_NAME} PRIVATE EnTT GTest::Main Threads::Threads)
-    target_compile_definitions(${TEST_NAME} PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_DEFINITIONS>)
-    target_compile_features(${TEST_NAME} PRIVATE $<TARGET_PROPERTY:EnTT,INTERFACE_COMPILE_FEATURES>)
-    target_compile_options(${TEST_NAME} PRIVATE $<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-pedantic -Wall>)
-    target_compile_options(${TEST_NAME} PRIVATE $<$<CXX_COMPILER_ID:MSVC>:/EHsc>)
+function(SETUP_BASIC_TEST TEST_NAME TEST_SOURCES)
+    add_executable(${TEST_NAME} $<TARGET_OBJECTS:odr> ${TEST_SOURCES})
+    target_link_libraries(${TEST_NAME} PRIVATE GTest::Main Threads::Threads)
+    SETUP_TARGET(${TEST_NAME})
     add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
-endmacro()
+endfunction()
+
+function(SETUP_LIB_TEST TEST_NAME)
+    add_library(_${TEST_NAME} SHARED lib/${TEST_NAME}/lib.cpp)
+    SETUP_TARGET(_${TEST_NAME})
+    SETUP_BASIC_TEST(lib_${TEST_NAME} lib/${TEST_NAME}/main.cpp)
+    target_compile_definitions(_${TEST_NAME} PRIVATE ENTT_API_EXPORT ${ARGV1})
+    target_compile_definitions(lib_${TEST_NAME} PRIVATE ENTT_API_IMPORT ${ARGV1})
+    target_link_libraries(lib_${TEST_NAME} PRIVATE _${TEST_NAME})
+endfunction()
+
+function(SETUP_PLUGIN_TEST TEST_NAME)
+    add_library(_${TEST_NAME} MODULE lib/${TEST_NAME}/plugin.cpp)
+    SETUP_TARGET(_${TEST_NAME})
+    SETUP_BASIC_TEST(lib_${TEST_NAME} lib/${TEST_NAME}/main.cpp)
+    target_include_directories(_${TEST_NAME} PRIVATE ${cr_INCLUDE_DIR})
+    target_include_directories(lib_${TEST_NAME} PRIVATE ${cr_INCLUDE_DIR})
+    target_compile_definitions(lib_${TEST_NAME} PRIVATE NOMINMAX PLUGIN="$<TARGET_FILE:_${TEST_NAME}>" ${ARGV1})
+    target_compile_definitions(_${TEST_NAME} PRIVATE NOMINMAX ${ARGV1})
+    target_link_libraries(lib_${TEST_NAME} PRIVATE ${CMAKE_DL_LIBS})
+endfunction()
 
 # Test benchmark
 
 if(BUILD_BENCHMARK)
-    SETUP_AND_ADD_TEST(benchmark benchmark/benchmark.cpp)
+    SETUP_BASIC_TEST(benchmark benchmark/benchmark.cpp)
 endif()
 
 # Test lib
 
 if(BUILD_LIB)
-    add_library(a_module_shared SHARED lib/a_module.cpp)
-    add_library(a_module_static STATIC lib/a_module.cpp)
-    add_library(another_module_shared SHARED lib/another_module.cpp)
-    add_library(another_module_static STATIC lib/another_module.cpp)
+    FetchContent_Declare(
+        cr
+        GIT_REPOSITORY https://github.com/fungos/cr.git
+        GIT_TAG master
+        GIT_SHALLOW 1
+    )
 
-    SETUP_LIBRARY_TARGET(a_module_shared)
-    SETUP_LIBRARY_TARGET(a_module_static)
-    SETUP_LIBRARY_TARGET(another_module_shared)
-    SETUP_LIBRARY_TARGET(another_module_static)
+    FetchContent_GetProperties(cr)
 
-    SETUP_AND_ADD_TEST(lib_shared lib/lib.cpp)
-    target_link_libraries(lib_shared PRIVATE a_module_shared another_module_shared)
+    if(NOT cr_POPULATED)
+        FetchContent_Populate(cr)
+        set(cr_INCLUDE_DIR ${cr_SOURCE_DIR})
+    endif()
 
-    SETUP_AND_ADD_TEST(lib_static lib/lib.cpp)
-    target_link_libraries(lib_static PRIVATE a_module_static another_module_static)
-endif()
+    SETUP_LIB_TEST(dispatcher)
+    SETUP_LIB_TEST(emitter)
+    SETUP_LIB_TEST(meta)
+    SETUP_LIB_TEST(registry)
 
-# Test mod
+    SETUP_PLUGIN_TEST(dispatcher_plugin)
+    SETUP_PLUGIN_TEST(emitter_plugin)
+    SETUP_PLUGIN_TEST(meta_plugin)
+    SETUP_PLUGIN_TEST(registry_plugin)
 
-if(BUILD_MOD)
-    set(DUKTAPE_DEPS_DIR ${EnTT_SOURCE_DIR}/deps/duktape)
-    configure_file(${EnTT_SOURCE_DIR}/cmake/in/duktape.in ${DUKTAPE_DEPS_DIR}/CMakeLists.txt)
-    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY ${DUKTAPE_DEPS_DIR})
-    execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${DUKTAPE_DEPS_DIR})
-    set(DUKTAPE_SRC_DIR ${DUKTAPE_DEPS_DIR}/src/src)
-
-    set(MOD_TEST_SOURCE ${DUKTAPE_SRC_DIR}/duktape.c mod/mod.cpp)
-    SETUP_AND_ADD_TEST(mod "${MOD_TEST_SOURCE}")
-    target_include_directories(mod PRIVATE ${DUKTAPE_SRC_DIR})
+    SETUP_PLUGIN_TEST(meta_plugin_std ENTT_STANDARD_CPP)
 endif()
 
 # Test snapshot
 
 if(BUILD_SNAPSHOT)
-    set(CEREAL_DEPS_DIR ${EnTT_SOURCE_DIR}/deps/cereal)
-    configure_file(${EnTT_SOURCE_DIR}/cmake/in/cereal.in ${CEREAL_DEPS_DIR}/CMakeLists.txt)
-    execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" . WORKING_DIRECTORY ${CEREAL_DEPS_DIR})
-    execute_process(COMMAND ${CMAKE_COMMAND} --build . WORKING_DIRECTORY ${CEREAL_DEPS_DIR})
-    set(CEREAL_SRC_DIR ${CEREAL_DEPS_DIR}/src/include)
+    FetchContent_Declare(
+        cereal
+        GIT_REPOSITORY https://github.com/USCiLab/cereal.git
+        GIT_TAG v1.2.2
+        GIT_SHALLOW 1
+    )
 
-    SETUP_AND_ADD_TEST(cereal snapshot/snapshot.cpp)
-    target_include_directories(cereal PRIVATE ${CEREAL_SRC_DIR})
+    FetchContent_GetProperties(cereal)
+
+    if(NOT cereal_POPULATED)
+        FetchContent_Populate(cereal)
+        set(cereal_INCLUDE_DIR ${cereal_SOURCE_DIR}/include)
+    endif()
+
+    SETUP_BASIC_TEST(cereal snapshot/snapshot.cpp)
+    target_include_directories(cereal PRIVATE ${cereal_INCLUDE_DIR})
 endif()
 
 # Test core
 
-SETUP_AND_ADD_TEST(algorithm entt/core/algorithm.cpp)
-SETUP_AND_ADD_TEST(family entt/core/family.cpp)
-SETUP_AND_ADD_TEST(hashed_string entt/core/hashed_string.cpp)
-SETUP_AND_ADD_TEST(ident entt/core/ident.cpp)
-SETUP_AND_ADD_TEST(monostate entt/core/monostate.cpp)
-SETUP_AND_ADD_TEST(type_traits entt/core/type_traits.cpp)
-SETUP_AND_ADD_TEST(utility entt/core/utility.cpp)
+SETUP_BASIC_TEST(algorithm entt/core/algorithm.cpp)
+SETUP_BASIC_TEST(family entt/core/family.cpp)
+SETUP_BASIC_TEST(hashed_string entt/core/hashed_string.cpp)
+SETUP_BASIC_TEST(ident entt/core/ident.cpp)
+SETUP_BASIC_TEST(monostate entt/core/monostate.cpp)
+SETUP_BASIC_TEST(type_info entt/core/type_info.cpp)
+SETUP_BASIC_TEST(type_traits entt/core/type_traits.cpp)
+SETUP_BASIC_TEST(utility entt/core/utility.cpp)
 
 # Test entity
 
-SETUP_AND_ADD_TEST(actor entt/entity/actor.cpp)
-SETUP_AND_ADD_TEST(entity entt/entity/entity.cpp)
-SETUP_AND_ADD_TEST(group entt/entity/group.cpp)
-SETUP_AND_ADD_TEST(helper entt/entity/helper.cpp)
-SETUP_AND_ADD_TEST(observer entt/entity/observer.cpp)
-SETUP_AND_ADD_TEST(registry entt/entity/registry.cpp)
-SETUP_AND_ADD_TEST(runtime_view entt/entity/runtime_view.cpp)
-SETUP_AND_ADD_TEST(snapshot entt/entity/snapshot.cpp)
-SETUP_AND_ADD_TEST(sparse_set entt/entity/sparse_set.cpp)
-SETUP_AND_ADD_TEST(storage entt/entity/storage.cpp)
-SETUP_AND_ADD_TEST(view entt/entity/view.cpp)
+SETUP_BASIC_TEST(actor entt/entity/actor.cpp)
+SETUP_BASIC_TEST(entity entt/entity/entity.cpp)
+SETUP_BASIC_TEST(group entt/entity/group.cpp)
+SETUP_BASIC_TEST(helper entt/entity/helper.cpp)
+SETUP_BASIC_TEST(observer entt/entity/observer.cpp)
+SETUP_BASIC_TEST(registry entt/entity/registry.cpp)
+SETUP_BASIC_TEST(runtime_view entt/entity/runtime_view.cpp)
+SETUP_BASIC_TEST(snapshot entt/entity/snapshot.cpp)
+SETUP_BASIC_TEST(sparse_set entt/entity/sparse_set.cpp)
+SETUP_BASIC_TEST(storage entt/entity/storage.cpp)
+SETUP_BASIC_TEST(view entt/entity/view.cpp)
 
 # Test locator
 
-SETUP_AND_ADD_TEST(locator entt/locator/locator.cpp)
+SETUP_BASIC_TEST(locator entt/locator/locator.cpp)
 
 # Test meta
 
-SETUP_AND_ADD_TEST(meta entt/meta/meta.cpp)
+SETUP_BASIC_TEST(meta entt/meta/meta.cpp)
 
 # Test process
 
-SETUP_AND_ADD_TEST(process entt/process/process.cpp)
-SETUP_AND_ADD_TEST(scheduler entt/process/scheduler.cpp)
+SETUP_BASIC_TEST(process entt/process/process.cpp)
+SETUP_BASIC_TEST(scheduler entt/process/scheduler.cpp)
 
 # Test resource
 
-SETUP_AND_ADD_TEST(resource entt/resource/resource.cpp)
+SETUP_BASIC_TEST(resource entt/resource/resource.cpp)
 
 # Test signal
 
-SETUP_AND_ADD_TEST(delegate entt/signal/delegate.cpp)
-SETUP_AND_ADD_TEST(dispatcher entt/signal/dispatcher.cpp)
-SETUP_AND_ADD_TEST(emitter entt/signal/emitter.cpp)
-SETUP_AND_ADD_TEST(sigh entt/signal/sigh.cpp)
+SETUP_BASIC_TEST(delegate entt/signal/delegate.cpp)
+SETUP_BASIC_TEST(dispatcher entt/signal/dispatcher.cpp)
+SETUP_BASIC_TEST(emitter entt/signal/emitter.cpp)
+SETUP_BASIC_TEST(sigh entt/signal/sigh.cpp)

test/benchmark/BUILD.bazel

@@ -1,11 +0,0 @@
-load("//bazel:copts.bzl", "entt_copts")
-
-cc_binary(
-    name = "benchmark",
-    srcs = ["benchmark.cpp"],
-    copts = entt_copts,
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)

test/benchmark/benchmark.cpp

@@ -4,6 +4,7 @@
 #include <chrono>
 #include <iterator>
 #include <gtest/gtest.h>
+#include <entt/core/type_info.hpp>
 #include <entt/entity/registry.hpp>
 
 struct position {
@@ -44,9 +45,9 @@ void pathological(Func func) {
 
     for(auto i = 0; i < 10; ++i) {
         registry.each([i = 0, &registry](const auto entity) mutable {
-            if(!(++i % 7)) { registry.reset<position>(entity); }
-            if(!(++i % 11)) { registry.reset<velocity>(entity); }
-            if(!(++i % 13)) { registry.reset<comp<0>>(entity); }
+            if(!(++i % 7)) { registry.remove_if_exists<position>(entity); }
+            if(!(++i % 11)) { registry.remove_if_exists<velocity>(entity); }
+            if(!(++i % 13)) { registry.remove_if_exists<comp<0>>(entity); }
             if(!(++i % 17)) { registry.destroy(entity); }
         });
 
@@ -63,10 +64,10 @@ void pathological(Func func) {
     });
 }
 
-TEST(Benchmark, Construct) {
+TEST(Benchmark, Create) {
     entt::registry registry;
 
-    std::cout << "Constructing 1000000 entities" << std::endl;
+    std::cout << "Creating 1000000 entities" << std::endl;
 
     timer timer;
 
@@ -77,22 +78,22 @@ TEST(Benchmark, Construct) {
     timer.elapsed();
 }
 
-TEST(Benchmark, ConstructMany) {
+TEST(Benchmark, CreateMany) {
     entt::registry registry;
     std::vector<entt::entity> entities(1000000);
 
-    std::cout << "Constructing 1000000 entities at once" << std::endl;
+    std::cout << "Creating 1000000 entities at once" << std::endl;
 
     timer timer;
     registry.create(entities.begin(), entities.end());
     timer.elapsed();
 }
 
-TEST(Benchmark, ConstructManyAndAssignComponents) {
+TEST(Benchmark, CreateManyAndAssignComponents) {
     entt::registry registry;
     std::vector<entt::entity> entities(1000000);
 
-    std::cout << "Constructing 1000000 entities at once and assign components" << std::endl;
+    std::cout << "Creating 1000000 entities at once and assign components" << std::endl;
 
     timer timer;
 
@@ -106,14 +107,16 @@ TEST(Benchmark, ConstructManyAndAssignComponents) {
     timer.elapsed();
 }
 
-TEST(Benchmark, ConstructManyWithComponents) {
+TEST(Benchmark, CreateManyWithComponents) {
     entt::registry registry;
     std::vector<entt::entity> entities(1000000);
 
-    std::cout << "Constructing 1000000 entities at once with components" << std::endl;
+    std::cout << "Creating 1000000 entities at once with components" << std::endl;
 
     timer timer;
-    registry.create<position, velocity>(entities.begin(), entities.end());
+    registry.create(entities.begin(), entities.end());
+    registry.assign<position>(entities.begin(), entities.end());
+    registry.assign<velocity>(entities.begin(), entities.end());
     timer.elapsed();
 }
 
@@ -167,7 +170,7 @@ TEST(Benchmark, IterateSingleComponentRuntime1M) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = { registry.type<position>() };
+        ENTT_ID_TYPE types[] = { entt::type_info<position>::id() };
 
         timer timer;
         registry.runtime_view(std::begin(types), std::end(types)).each(func);
@@ -332,7 +335,10 @@ TEST(Benchmark, IterateTwoComponentsRuntime1M) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = { registry.type<position>(), registry.type<velocity>() };
+        ENTT_ID_TYPE types[] = {
+            entt::type_info<position>::id(),
+            entt::type_info<velocity>::id()
+        };
 
         timer timer;
         registry.runtime_view(std::begin(types), std::end(types)).each(func);
@@ -360,7 +366,10 @@ TEST(Benchmark, IterateTwoComponentsRuntime1MHalf) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = { registry.type<position>(), registry.type<velocity>() };
+        ENTT_ID_TYPE types[] = {
+            entt::type_info<position>::id(),
+            entt::type_info<velocity>::id()
+        };
 
         timer timer;
         registry.runtime_view(std::begin(types), std::end(types)).each(func);
@@ -388,7 +397,10 @@ TEST(Benchmark, IterateTwoComponentsRuntime1MOne) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = { registry.type<position>(), registry.type<velocity>() };
+        ENTT_ID_TYPE types[] = {
+            entt::type_info<position>::id(),
+            entt::type_info<velocity>::id()
+        };
 
         timer timer;
         registry.runtime_view(std::begin(types), std::end(types)).each(func);
@@ -561,7 +573,11 @@ TEST(Benchmark, IterateThreeComponentsRuntime1M) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = { registry.type<position>(), registry.type<velocity>(), registry.type<comp<0>>() };
+        ENTT_ID_TYPE types[] = {
+            entt::type_info<position>::id(),
+            entt::type_info<velocity>::id(),
+            entt::type_info<comp<0>>::id()
+        };
 
         timer timer;
         registry.runtime_view(std::begin(types), std::end(types)).each(func);
@@ -591,7 +607,11 @@ TEST(Benchmark, IterateThreeComponentsRuntime1MHalf) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = { registry.type<position>(), registry.type<velocity>(), registry.type<comp<0>>() };
+        ENTT_ID_TYPE types[] = {
+            entt::type_info<position>::id(),
+            entt::type_info<velocity>::id(),
+            entt::type_info<comp<0>>::id()
+        };
 
         timer timer;
         registry.runtime_view(std::begin(types), std::end(types)).each(func);
@@ -621,7 +641,11 @@ TEST(Benchmark, IterateThreeComponentsRuntime1MOne) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = { registry.type<position>(), registry.type<velocity>(), registry.type<comp<0>>() };
+        ENTT_ID_TYPE types[] = {
+            entt::type_info<position>::id(),
+            entt::type_info<velocity>::id(),
+            entt::type_info<comp<0>>::id()
+        };
 
         timer timer;
         registry.runtime_view(std::begin(types), std::end(types)).each(func);
@@ -835,12 +859,12 @@ TEST(Benchmark, IterateFiveComponentsRuntime1M) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = {
-            registry.type<position>(),
-            registry.type<velocity>(),
-            registry.type<comp<0>>(),
-            registry.type<comp<1>>(),
-            registry.type<comp<2>>()
+        ENTT_ID_TYPE types[] = {
+            entt::type_info<position>::id(),
+            entt::type_info<velocity>::id(),
+            entt::type_info<comp<0>>::id(),
+            entt::type_info<comp<1>>::id(),
+            entt::type_info<comp<2>>::id()
         };
 
         timer timer;
@@ -875,12 +899,12 @@ TEST(Benchmark, IterateFiveComponentsRuntime1MHalf) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = {
-            registry.type<position>(),
-            registry.type<velocity>(),
-            registry.type<comp<0>>(),
-            registry.type<comp<1>>(),
-            registry.type<comp<2>>()
+        ENTT_ID_TYPE types[] = {
+            entt::type_info<position>::id(),
+            entt::type_info<velocity>::id(),
+            entt::type_info<comp<0>>::id(),
+            entt::type_info<comp<1>>::id(),
+            entt::type_info<comp<2>>::id()
         };
 
         timer timer;
@@ -915,12 +939,12 @@ TEST(Benchmark, IterateFiveComponentsRuntime1MOne) {
     }
 
     auto test = [&registry](auto func) {
-        entt::component types[] = {
-            registry.type<position>(),
-            registry.type<velocity>(),
-            registry.type<comp<0>>(),
-            registry.type<comp<1>>(),
-            registry.type<comp<2>>()
+        ENTT_ID_TYPE types[] = {
+            entt::type_info<position>::id(),
+            entt::type_info<velocity>::id(),
+            entt::type_info<comp<0>>::id(),
+            entt::type_info<comp<1>>::id(),
+            entt::type_info<comp<2>>::id()
         };
 
         timer timer;

test/entt/core/BUILD.bazel

@@ -1,71 +0,0 @@
-load("//bazel:copts.bzl", "entt_copts")
-
-cc_test(
-    name = "algorithm",
-    srcs = ["algorithm.cpp"],
-    copts = entt_copts,
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "family",
-    srcs = ["family.cpp"],
-    copts = entt_copts,
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "hashed_string",
-    srcs = ["hashed_string.cpp"],
-    copts = entt_copts,
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "ident",
-    srcs = ["ident.cpp"],
-    copts = entt_copts,
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "monostate",
-    srcs = ["monostate.cpp"],
-    copts = entt_copts,
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "type_traits",
-    srcs = ["type_traits.cpp"],
-    copts = entt_copts,
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "utility",
-    srcs = ["utility.cpp"],
-    copts = entt_copts,
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)

test/entt/core/family.cpp

@@ -16,7 +16,7 @@ TEST(Family, Functionalities) {
 }
 
 TEST(Family, Uniqueness) {
-    ASSERT_EQ(a_family::type<int>, a_family::type<int &>);
-    ASSERT_EQ(a_family::type<int>, a_family::type<int &&>);
-    ASSERT_EQ(a_family::type<int>, a_family::type<const int &>);
+    ASSERT_NE(a_family::type<int>, a_family::type<int &>);
+    ASSERT_NE(a_family::type<int>, a_family::type<int &&>);
+    ASSERT_NE(a_family::type<int>, a_family::type<const int &>);
 }

test/entt/core/hashed_string.cpp

@@ -52,15 +52,15 @@ TEST(HashedString, ToValue) {
 
     const char *foobar = "foobar";
 
-    ASSERT_EQ(entt::hashed_string::to_value(foobar), 0xbf9cf968);
+    ASSERT_EQ(entt::hashed_string::value(foobar), 0xbf9cf968);
     // how would you test a constexpr otherwise?
-    (void)std::integral_constant<hash_type, entt::hashed_string::to_value("quux")>{};
+    (void)std::integral_constant<hash_type, entt::hashed_string::value("quux")>{};
 }
 
 TEST(HashedString, StringView) {
     std::string str{"__foobar__"};
     std::string_view view{str.data()+2, 6};
-    ASSERT_EQ(entt::hashed_string::to_value(view.data(), view.size()), 0xbf9cf968);
+    ASSERT_EQ(entt::hashed_string::value(view.data(), view.size()), 0xbf9cf968);
 }
 
 TEST(HashedWString, Functionalities) {
@@ -111,15 +111,15 @@ TEST(HashedWString, ToValue) {
 
     const wchar_t *foobar = L"foobar";
 
-    ASSERT_EQ(entt::hashed_wstring::to_value(foobar), 0xbf9cf968);
+    ASSERT_EQ(entt::hashed_wstring::value(foobar), 0xbf9cf968);
     // how would you test a constexpr otherwise?
-    (void)std::integral_constant<hash_type, entt::hashed_wstring::to_value(L"quux")>{};
+    (void)std::integral_constant<hash_type, entt::hashed_wstring::value(L"quux")>{};
 }
 
 TEST(HashedWString, StringView) {
     std::wstring str{L"__foobar__"};
     std::wstring_view view{str.data()+2, 6};
-    ASSERT_EQ(entt::hashed_wstring::to_value(view.data(), view.size()), 0xbf9cf968);
+    ASSERT_EQ(entt::hashed_wstring::value(view.data(), view.size()), 0xbf9cf968);
 }
 
 TEST(BasicHashedString, DeductionGuide) {

test/entt/core/type_info.cpp

@@ -0,0 +1,16 @@
+#include <gtest/gtest.h>
+#include <entt/core/hashed_string.hpp>
+#include <entt/core/type_info.hpp>
+
+TEST(TypeInfo, Functionalities) {
+    ASSERT_NE(entt::type_info<int>::id(), entt::type_info<const int>::id());
+    ASSERT_NE(entt::type_info<int>::id(), entt::type_info<char>::id());
+    ASSERT_EQ(entt::type_info<int>::id(), entt::type_info<int>::id());
+}
+
+TEST(TypeIndex, Functionalities) {
+    ASSERT_EQ(entt::type_index<int>::value(), entt::type_index<int>::value());
+    ASSERT_NE(entt::type_index<int>::value(), entt::type_index<char>::value());
+    ASSERT_NE(entt::type_index<int>::value(), entt::type_index<int &&>::value());
+    ASSERT_NE(entt::type_index<int &>::value(), entt::type_index<const int &>::value());
+}

test/entt/core/type_traits.cpp

@@ -1,6 +1,21 @@
+#include <type_traits>
 #include <gtest/gtest.h>
+#include <entt/config/config.h>
+#include <entt/core/hashed_string.hpp>
 #include <entt/core/type_traits.hpp>
 
+TEST(IntegralConstant, Functionalities) {
+    entt::integral_constant<3> constant;
+
+    ASSERT_TRUE((std::is_same_v<typename entt::integral_constant<3>::value_type, int>));
+    ASSERT_EQ(constant.value, 3);
+}
+
+TEST(Choice, Functionalities) {
+    ASSERT_TRUE((std::is_base_of_v<entt::choice_t<0>, entt::choice_t<1>>));
+    ASSERT_FALSE((std::is_base_of_v<entt::choice_t<1>, entt::choice_t<0>>));
+}
+
 TEST(TypeList, Functionalities) {
     using type = entt::type_list<int, char>;
     using other = entt::type_list<double>;
@@ -12,3 +27,25 @@ TEST(TypeList, Functionalities) {
     ASSERT_TRUE((std::is_same_v<entt::type_list_cat_t<type, type>, entt::type_list<int, char, int, char>>));
     ASSERT_TRUE((std::is_same_v<entt::type_list_unique_t<entt::type_list_cat_t<type, type>>, entt::type_list<int, char>>));
 }
+
+TEST(IsEqualityComparable, Functionalities) {
+    ASSERT_TRUE(entt::is_equality_comparable_v<int>);
+    ASSERT_FALSE(entt::is_equality_comparable_v<void>);
+}
+
+TEST(MemberClass, Functionalities) {
+    struct clazz {
+        char foo(int) { return {}; }
+        int bar(double, float) const { return {}; }
+        bool quux;
+    };
+
+    ASSERT_TRUE((std::is_same_v<clazz, entt::member_class_t<decltype(&clazz::foo)>>));
+    ASSERT_TRUE((std::is_same_v<clazz, entt::member_class_t<decltype(&clazz::bar)>>));
+    ASSERT_TRUE((std::is_same_v<clazz, entt::member_class_t<decltype(&clazz::quux)>>));
+}
+
+TEST(Tag, Functionalities) {
+    ASSERT_EQ(entt::tag<"foobar"_hs>::value, entt::hashed_string::value("foobar"));
+    ASSERT_TRUE((std::is_same_v<typename entt::tag<"foobar"_hs>::value_type, ENTT_ID_TYPE>));
+}

test/entt/core/utility.cpp

@@ -1,7 +1,8 @@
+#include <utility>
 #include <gtest/gtest.h>
 #include <entt/core/utility.hpp>
 
-struct Functions {
+struct functions {
     static void foo(int) {}
     static void foo() {}
 
@@ -18,9 +19,42 @@ TEST(Utility, Identity) {
 }
 
 TEST(Utility, Overload) {
-    ASSERT_EQ(entt::overload<void(int)>(&Functions::foo), static_cast<void(*)(int)>(&Functions::foo));
-    ASSERT_EQ(entt::overload<void()>(&Functions::foo), static_cast<void(*)()>(&Functions::foo));
+    ASSERT_EQ(entt::overload<void(int)>(&functions::foo), static_cast<void(*)(int)>(&functions::foo));
+    ASSERT_EQ(entt::overload<void()>(&functions::foo), static_cast<void(*)()>(&functions::foo));
 
-    ASSERT_EQ(entt::overload<void(int)>(&Functions::bar), static_cast<void(Functions:: *)(int)>(&Functions::bar));
-    ASSERT_EQ(entt::overload<void()>(&Functions::bar), static_cast<void(Functions:: *)()>(&Functions::bar));
+    ASSERT_EQ(entt::overload<void(int)>(&functions::bar), static_cast<void(functions:: *)(int)>(&functions::bar));
+    ASSERT_EQ(entt::overload<void()>(&functions::bar), static_cast<void(functions:: *)()>(&functions::bar));
+
+    functions instance;
+
+    ASSERT_NO_THROW(entt::overload<void(int)>(&functions::foo)(0));
+    ASSERT_NO_THROW(entt::overload<void()>(&functions::foo)());
+
+    ASSERT_NO_THROW((instance.*entt::overload<void(int)>(&functions::bar))(0));
+    ASSERT_NO_THROW((instance.*entt::overload<void()>(&functions::bar))());
+}
+
+TEST(Utility, Overloaded) {
+    int iv = 0;
+    char cv = '\0';
+
+    entt::overloaded func{
+        [&iv](int value) { iv = value; },
+        [&cv](char value) { cv = value; }
+    };
+
+    func(42);
+    func('c');
+
+    ASSERT_EQ(iv, 42);
+    ASSERT_EQ(cv, 'c');
+}
+
+TEST(Utility, YCombinator) {
+    entt::y_combinator gauss([](const auto &self, auto value) -> unsigned int {
+        return value ? (value + self(value-1u)) : 0;
+    });
+
+    ASSERT_EQ(gauss(3u), 3u*4u/2u);
+    ASSERT_EQ(std::as_const(gauss)(7u), 7u*8u/2u);
 }

test/entt/entity/BUILD.bazel

@@ -1,121 +0,0 @@
-load("//bazel:copts.bzl", "entt_copts")
-
-cc_test(
-    name = "actor",
-    copts = entt_copts,
-    srcs = ["actor.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "entity",
-    copts = entt_copts,
-    srcs = ["entity.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "group",
-    copts = entt_copts,
-    srcs = ["group.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "helper",
-    copts = entt_copts,
-    srcs = ["helper.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "observer",
-    copts = entt_copts,
-    srcs = ["observer.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",  
-    ],
-)
-
-cc_test(
-    name = "prototype",
-    copts = entt_copts,
-    srcs = ["prototype.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "registry",
-    copts = entt_copts,
-    srcs = ["registry.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "runtime_view",
-    copts = entt_copts,
-    srcs = ["runtime_view.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "snapshot",
-    copts = entt_copts,
-    srcs = ["snapshot.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",  
-    ],
-)
-
-cc_test(
-    name = "sparse_set",
-    copts = entt_copts,
-    srcs = ["sparse_set.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "storage",
-    copts = entt_copts,
-    srcs = ["storage.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)
-
-cc_test(
-    name = "view",
-    copts = entt_copts,
-    srcs = ["view.cpp"],
-    deps = [
-        "//:entt",
-        "@com_google_googletest//:gtest_main",
-    ],
-)

test/entt/entity/entity.cpp

@@ -12,6 +12,7 @@ TEST(Entity, Null) {
 
     registry.assign<int>(entity, 42);
 
+    ASSERT_FALSE(entt::entity{} == entt::null);
     ASSERT_TRUE(entt::entity{traits_type::entity_mask} == entt::null);
     ASSERT_TRUE(entt::entity{~typename traits_type::entity_type{}} == entt::null);
 

test/entt/entity/group.cpp

@@ -10,14 +10,18 @@
 struct empty_type {};
 struct boxed_int { int value; };
 
+bool operator==(const boxed_int &lhs, const boxed_int &rhs) {
+    return lhs.value == rhs.value;
+}
+
 TEST(NonOwningGroup, Functionalities) {
     entt::registry registry;
     auto group = registry.group(entt::get<int, char>);
     auto cgroup = std::as_const(registry).group(entt::get<const int, const char>);
 
     ASSERT_TRUE(group.empty());
-    ASSERT_TRUE(group.empty<int>());
-    ASSERT_TRUE(cgroup.empty<const char>());
+    ASSERT_TRUE((group.empty<int, char>()));
+    ASSERT_TRUE((cgroup.empty<const int, const char>()));
 
     const auto e0 = registry.create();
     registry.assign<char>(e0);
@@ -27,8 +31,8 @@ TEST(NonOwningGroup, Functionalities) {
     registry.assign<char>(e1);
 
     ASSERT_FALSE(group.empty());
-    ASSERT_FALSE(group.empty<int>());
-    ASSERT_FALSE(cgroup.empty<const char>());
+    ASSERT_FALSE((group.empty<int>()));
+    ASSERT_FALSE((cgroup.empty<const char>()));
     ASSERT_NO_THROW((group.begin()++));
     ASSERT_NO_THROW((++cgroup.begin()));
 
@@ -170,10 +174,12 @@ TEST(NonOwningGroup, Sort) {
     const auto e0 = registry.create();
     const auto e1 = registry.create();
     const auto e2 = registry.create();
+    const auto e3 = registry.create();
 
     registry.assign<unsigned int>(e0, 0u);
     registry.assign<unsigned int>(e1, 1u);
     registry.assign<unsigned int>(e2, 2u);
+    registry.assign<unsigned int>(e3, 3u);
 
     registry.assign<int>(e0, 0);
     registry.assign<int>(e1, 1);
@@ -207,6 +213,12 @@ TEST(NonOwningGroup, Sort) {
     ASSERT_EQ(*(group.data() + 1u), e1);
     ASSERT_EQ(*(group.data() + 2u), e0);
 
+    ASSERT_EQ((group.get<const int, unsigned int>(e0)), (std::make_tuple(0, 0u)));
+    ASSERT_EQ((group.get<const int, unsigned int>(e1)), (std::make_tuple(1, 1u)));
+    ASSERT_EQ((group.get<const int, unsigned int>(e2)), (std::make_tuple(2, 2u)));
+
+    ASSERT_FALSE(group.contains(e3));
+
     group.sort<const int>([](const int lhs, const int rhs) {
         return lhs > rhs;
     });
@@ -214,6 +226,12 @@ TEST(NonOwningGroup, Sort) {
     ASSERT_EQ(*(group.data() + 0u), e0);
     ASSERT_EQ(*(group.data() + 1u), e1);
     ASSERT_EQ(*(group.data() + 2u), e2);
+
+    ASSERT_EQ((group.get<const int, unsigned int>(e0)), (std::make_tuple(0, 0u)));
+    ASSERT_EQ((group.get<const int, unsigned int>(e1)), (std::make_tuple(1, 1u)));
+    ASSERT_EQ((group.get<const int, unsigned int>(e2)), (std::make_tuple(2, 2u)));
+
+    ASSERT_FALSE(group.contains(e3));
 }
 
 TEST(NonOwningGroup, SortAsAPool) {
@@ -223,6 +241,7 @@ TEST(NonOwningGroup, SortAsAPool) {
     const auto e0 = registry.create();
     const auto e1 = registry.create();
     const auto e2 = registry.create();
+    const auto e3 = registry.create();
 
     auto uval = 0u;
     auto ival = 0;
@@ -230,6 +249,7 @@ TEST(NonOwningGroup, SortAsAPool) {
     registry.assign<unsigned int>(e0, uval++);
     registry.assign<unsigned int>(e1, uval++);
     registry.assign<unsigned int>(e2, uval++);
+    registry.assign<unsigned int>(e3, uval+1);
 
     registry.assign<int>(e0, ival++);
     registry.assign<int>(e1, ival++);
@@ -243,6 +263,12 @@ TEST(NonOwningGroup, SortAsAPool) {
     registry.sort<unsigned int>(std::less<unsigned int>{});
     group.sort<unsigned int>();
 
+    ASSERT_EQ((group.get<const int, unsigned int>(e0)), (std::make_tuple(0, 0u)));
+    ASSERT_EQ((group.get<const int, unsigned int>(e1)), (std::make_tuple(1, 1u)));
+    ASSERT_EQ((group.get<const int, unsigned int>(e2)), (std::make_tuple(2, 2u)));
+
+    ASSERT_FALSE(group.contains(e3));
+
     for(auto entity: group) {
         ASSERT_EQ(group.get<unsigned int>(entity), uval++);
         ASSERT_EQ(group.get<const int>(entity), ival++);
@@ -279,28 +305,25 @@ TEST(NonOwningGroup, IndexRebuiltOnDestroy) {
 
 TEST(NonOwningGroup, ConstNonConstAndAllInBetween) {
     entt::registry registry;
-    auto group = registry.group(entt::get<int, const char, std::true_type>);
+    auto group = registry.group(entt::get<int, const char>);
 
     ASSERT_EQ(group.size(), decltype(group.size()){0});
 
     const auto entity = registry.create();
     registry.assign<int>(entity, 0);
     registry.assign<char>(entity, 'c');
-    registry.assign<std::true_type>(entity);
 
     ASSERT_EQ(group.size(), decltype(group.size()){1});
 
     ASSERT_TRUE((std::is_same_v<decltype(group.get<int>({})), int &>));
     ASSERT_TRUE((std::is_same_v<decltype(group.get<const char>({})), const char &>));
-    ASSERT_TRUE((std::is_same_v<decltype(group.get<std::true_type>({})), std::true_type>));
-    ASSERT_TRUE((std::is_same_v<decltype(group.get<int, const char, std::true_type>({})), std::tuple<int &, const char &, std::true_type>>));
+    ASSERT_TRUE((std::is_same_v<decltype(group.get<int, const char>({})), std::tuple<int &, const char &>>));
     ASSERT_TRUE((std::is_same_v<decltype(group.raw<const char>()), const char *>));
     ASSERT_TRUE((std::is_same_v<decltype(group.raw<int>()), int *>));
 
-    group.each([](auto &&i, auto &&c, auto &&e) {
+    group.each([](auto &&i, auto &&c) {
         ASSERT_TRUE((std::is_same_v<decltype(i), int &>));
         ASSERT_TRUE((std::is_same_v<decltype(c), const char &>));
-        ASSERT_TRUE((std::is_same_v<decltype(e), std::true_type &&>));
     });
 }
 
@@ -369,12 +392,12 @@ TEST(NonOwningGroup, ExcludedComponents) {
     registry.assign<char>(e3);
 
     for(const auto entity: group) {
+        ASSERT_TRUE(entity == e0 || entity == e2);
+
         if(entity == e0) {
             ASSERT_EQ(group.get<int>(e0), 0);
         } else if(entity == e2) {
             ASSERT_EQ(group.get<int>(e2), 2);
-        } else {
-            FAIL();
         }
     }
 
@@ -387,12 +410,12 @@ TEST(NonOwningGroup, ExcludedComponents) {
     registry.remove<char>(e3);
 
     for(const auto entity: group) {
+        ASSERT_TRUE(entity == e1 || entity == e3);
+
         if(entity == e1) {
             ASSERT_EQ(group.get<int>(e1), 1);
         } else if(entity == e3) {
             ASSERT_EQ(group.get<int>(e3), 3);
-        } else {
-            FAIL();
         }
     }
 }
@@ -415,7 +438,7 @@ TEST(NonOwningGroup, EmptyAndNonEmptyTypes) {
         ASSERT_TRUE(entity == e0 || entity == e1);
     }
 
-    group.each([e0, e1](const auto entity, const int &, empty_type) {
+    group.each([e0, e1](const auto entity, const int &) {
         ASSERT_TRUE(entity == e0 || entity == e1);
     });
 
@@ -442,8 +465,11 @@ TEST(NonOwningGroup, TrackEntitiesOnComponentDestruction) {
 
 TEST(NonOwningGroup, Less) {
     entt::registry registry;
-    const auto entity = std::get<0>(registry.create<int, entt::tag<"empty"_hs>>());
-    registry.create<char>();
+    const auto entity = registry.create();
+
+    registry.assign<int>(entity);
+    registry.assign<char>(entity);
+    registry.assign<entt::tag<"empty"_hs>>(entity);
 
     registry.group(entt::get<int, char, entt::tag<"empty"_hs>>).less([entity](const auto entt, int, char) {
         ASSERT_EQ(entity, entt);
@@ -458,9 +484,40 @@ TEST(NonOwningGroup, Less) {
         ASSERT_EQ(entity, entt);
     });
 
-    registry.group(entt::get<int, char, double>).less([entity](const auto entt, int, char, double) {
-        ASSERT_EQ(entity, entt);
-    });
+    registry.group(entt::get<int, char, double>).less([](const auto, int, char, double) { FAIL(); });
+}
+
+TEST(NonOwningGroup, FrontBack) {
+    entt::registry registry;
+    auto group = registry.group<>(entt::get<const int, const char>);
+
+    ASSERT_EQ(group.front(), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(group.back(), static_cast<entt::entity>(entt::null));
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    const auto entity = registry.create();
+    registry.assign<char>(entity);
+
+    ASSERT_EQ(group.front(), e1);
+    ASSERT_EQ(group.back(), e0);
+}
+
+TEST(NonOwningGroup, SignalRace) {
+    entt::registry registry;
+    registry.on_construct<double>().connect<&entt::registry::assign_or_replace<int>>();
+    registry.group(entt::get<int, double>);
+
+    auto entity = registry.create();
+    registry.assign<double>(entity);
+
+    ASSERT_EQ(registry.group(entt::get<int, double>).size(), 1u);
 }
 
 TEST(OwningGroup, Functionalities) {
@@ -469,8 +526,8 @@ TEST(OwningGroup, Functionalities) {
     auto cgroup = std::as_const(registry).group<const int>(entt::get<const char>);
 
     ASSERT_TRUE(group.empty());
-    ASSERT_TRUE(group.empty<int>());
-    ASSERT_TRUE(cgroup.empty<const char>());
+    ASSERT_TRUE((group.empty<int, char>()));
+    ASSERT_TRUE((cgroup.empty<const int, const char>()));
 
     const auto e0 = registry.create();
     registry.assign<char>(e0);
@@ -480,8 +537,8 @@ TEST(OwningGroup, Functionalities) {
     registry.assign<char>(e1);
 
     ASSERT_FALSE(group.empty());
-    ASSERT_FALSE(group.empty<int>());
-    ASSERT_FALSE(cgroup.empty<const char>());
+    ASSERT_FALSE((group.empty<int>()));
+    ASSERT_FALSE((cgroup.empty<const char>()));
     ASSERT_NO_THROW((group.begin()++));
     ASSERT_NO_THROW((++cgroup.begin()));
 
@@ -617,13 +674,8 @@ TEST(OwningGroup, SortOrdered) {
     entt::registry registry;
     auto group = registry.group<boxed_int, char>();
 
-    entt::entity entities[5] = {
-        registry.create(),
-        registry.create(),
-        registry.create(),
-        registry.create(),
-        registry.create()
-    };
+    entt::entity entities[5]{};
+    registry.create(std::begin(entities), std::end(entities));
 
     registry.assign<boxed_int>(entities[0], 12);
     registry.assign<char>(entities[0], 'a');
@@ -656,19 +708,21 @@ TEST(OwningGroup, SortOrdered) {
     ASSERT_EQ(*(group.raw<char>() + 0u), 'a');
     ASSERT_EQ(*(group.raw<char>() + 1u), 'b');
     ASSERT_EQ(*(group.raw<char>() + 2u), 'c');
+
+    ASSERT_EQ((group.get<boxed_int, char>(entities[0])), (std::make_tuple(boxed_int{12}, 'a')));
+    ASSERT_EQ((group.get<boxed_int, char>(entities[1])), (std::make_tuple(boxed_int{9}, 'b')));
+    ASSERT_EQ((group.get<boxed_int, char>(entities[2])), (std::make_tuple(boxed_int{6}, 'c')));
+
+    ASSERT_FALSE(group.contains(entities[3]));
+    ASSERT_FALSE(group.contains(entities[4]));
 }
 
 TEST(OwningGroup, SortReverse) {
     entt::registry registry;
     auto group = registry.group<boxed_int, char>();
 
-    entt::entity entities[5] = {
-        registry.create(),
-        registry.create(),
-        registry.create(),
-        registry.create(),
-        registry.create()
-    };
+    entt::entity entities[5]{};
+    registry.create(std::begin(entities), std::end(entities));
 
     registry.assign<boxed_int>(entities[0], 6);
     registry.assign<char>(entities[0], 'a');
@@ -701,21 +755,21 @@ TEST(OwningGroup, SortReverse) {
     ASSERT_EQ(*(group.raw<char>() + 0u), 'c');
     ASSERT_EQ(*(group.raw<char>() + 1u), 'b');
     ASSERT_EQ(*(group.raw<char>() + 2u), 'a');
+
+    ASSERT_EQ((group.get<boxed_int, char>(entities[0])), (std::make_tuple(boxed_int{6}, 'a')));
+    ASSERT_EQ((group.get<boxed_int, char>(entities[1])), (std::make_tuple(boxed_int{9}, 'b')));
+    ASSERT_EQ((group.get<boxed_int, char>(entities[2])), (std::make_tuple(boxed_int{12}, 'c')));
+
+    ASSERT_FALSE(group.contains(entities[3]));
+    ASSERT_FALSE(group.contains(entities[4]));
 }
 
 TEST(OwningGroup, SortUnordered) {
     entt::registry registry;
     auto group = registry.group<boxed_int>(entt::get<char>);
 
-    entt::entity entities[7] = {
-        registry.create(),
-        registry.create(),
-        registry.create(),
-        registry.create(),
-        registry.create(),
-        registry.create(),
-        registry.create()
-    };
+    entt::entity entities[7]{};
+    registry.create(std::begin(entities), std::end(entities));
 
     registry.assign<boxed_int>(entities[0], 6);
     registry.assign<char>(entities[0], 'c');
@@ -760,6 +814,52 @@ TEST(OwningGroup, SortUnordered) {
     ASSERT_EQ(*(group.raw<char>() + 2u), 'a');
     ASSERT_EQ(*(group.raw<char>() + 3u), 'd');
     ASSERT_EQ(*(group.raw<char>() + 4u), 'e');
+
+    ASSERT_EQ((group.get<boxed_int, char>(entities[0])), (std::make_tuple(boxed_int{6}, 'c')));
+    ASSERT_EQ((group.get<boxed_int, char>(entities[1])), (std::make_tuple(boxed_int{3}, 'b')));
+    ASSERT_EQ((group.get<boxed_int, char>(entities[2])), (std::make_tuple(boxed_int{1}, 'a')));
+    ASSERT_EQ((group.get<boxed_int, char>(entities[3])), (std::make_tuple(boxed_int{9}, 'd')));
+    ASSERT_EQ((group.get<boxed_int, char>(entities[4])), (std::make_tuple(boxed_int{12}, 'e')));
+
+    ASSERT_FALSE(group.contains(entities[5]));
+    ASSERT_FALSE(group.contains(entities[6]));
+}
+
+TEST(OwningGroup, SortWithExclusionList) {
+    entt::registry registry;
+    auto group = registry.group<boxed_int>(entt::exclude<char>);
+
+    entt::entity entities[5]{};
+    registry.create(std::begin(entities), std::end(entities));
+
+    registry.assign<boxed_int>(entities[0], 0);
+    registry.assign<boxed_int>(entities[1], 1);
+    registry.assign<boxed_int>(entities[2], 2);
+    registry.assign<boxed_int>(entities[3], 3);
+    registry.assign<boxed_int>(entities[4], 4);
+
+    registry.assign<char>(entities[2]);
+
+    group.sort([](const entt::entity lhs, const entt::entity rhs) {
+        return lhs < rhs;
+    });
+
+    ASSERT_EQ(*(group.data() + 0u), entities[4]);
+    ASSERT_EQ(*(group.data() + 1u), entities[3]);
+    ASSERT_EQ(*(group.data() + 2u), entities[1]);
+    ASSERT_EQ(*(group.data() + 3u), entities[0]);
+
+    ASSERT_EQ((group.raw<boxed_int>() + 0u)->value, 4);
+    ASSERT_EQ((group.raw<boxed_int>() + 1u)->value, 3);
+    ASSERT_EQ((group.raw<boxed_int>() + 2u)->value, 1);
+    ASSERT_EQ((group.raw<boxed_int>() + 3u)->value, 0);
+
+    ASSERT_EQ(group.get<boxed_int>(entities[0]).value, 0);
+    ASSERT_EQ(group.get<boxed_int>(entities[1]).value, 1);
+    ASSERT_EQ(group.get<boxed_int>(entities[3]).value, 3);
+    ASSERT_EQ(group.get<boxed_int>(entities[4]).value, 4);
+
+    ASSERT_FALSE(group.contains(entities[2]));
 }
 
 TEST(OwningGroup, IndexRebuiltOnDestroy) {
@@ -792,7 +892,7 @@ TEST(OwningGroup, IndexRebuiltOnDestroy) {
 
 TEST(OwningGroup, ConstNonConstAndAllInBetween) {
     entt::registry registry;
-    auto group = registry.group<int, const char>(entt::get<double, const float, std::true_type>);
+    auto group = registry.group<int, const char>(entt::get<double, const float>);
 
     ASSERT_EQ(group.size(), decltype(group.size()){0});
 
@@ -801,7 +901,6 @@ TEST(OwningGroup, ConstNonConstAndAllInBetween) {
     registry.assign<char>(entity, 'c');
     registry.assign<double>(entity, 0.);
     registry.assign<float>(entity, 0.f);
-    registry.assign<std::true_type>(entity);
 
     ASSERT_EQ(group.size(), decltype(group.size()){1});
 
@@ -809,19 +908,17 @@ TEST(OwningGroup, ConstNonConstAndAllInBetween) {
     ASSERT_TRUE((std::is_same_v<decltype(group.get<const char>({})), const char &>));
     ASSERT_TRUE((std::is_same_v<decltype(group.get<double>({})), double &>));
     ASSERT_TRUE((std::is_same_v<decltype(group.get<const float>({})), const float &>));
-    ASSERT_TRUE((std::is_same_v<decltype(group.get<std::true_type>({})), std::true_type>));
-    ASSERT_TRUE((std::is_same_v<decltype(group.get<int, const char, double, const float, std::true_type>({})), std::tuple<int &, const char &, double &, const float &, std::true_type>>));
+    ASSERT_TRUE((std::is_same_v<decltype(group.get<int, const char, double, const float>({})), std::tuple<int &, const char &, double &, const float &>>));
     ASSERT_TRUE((std::is_same_v<decltype(group.raw<const float>()), const float *>));
     ASSERT_TRUE((std::is_same_v<decltype(group.raw<double>()), double *>));
     ASSERT_TRUE((std::is_same_v<decltype(group.raw<const char>()), const char *>));
     ASSERT_TRUE((std::is_same_v<decltype(group.raw<int>()), int *>));
 
-    group.each([](auto &&i, auto &&c, auto &&d, auto &&f, auto &&e) {
+    group.each([](auto &&i, auto &&c, auto &&d, auto &&f) {
         ASSERT_TRUE((std::is_same_v<decltype(i), int &>));
         ASSERT_TRUE((std::is_same_v<decltype(c), const char &>));
         ASSERT_TRUE((std::is_same_v<decltype(d), double &>));
         ASSERT_TRUE((std::is_same_v<decltype(f), const float &>));
-        ASSERT_TRUE((std::is_same_v<decltype(e), std::true_type &&>));
     });
 }
 
@@ -890,12 +987,12 @@ TEST(OwningGroup, ExcludedComponents) {
     registry.assign<double>(e3);
 
     for(const auto entity: group) {
+        ASSERT_TRUE(entity == e0 || entity == e2);
+
         if(entity == e0) {
             ASSERT_EQ(group.get<int>(e0), 0);
         } else if(entity == e2) {
             ASSERT_EQ(group.get<int>(e2), 2);
-        } else {
-            FAIL();
         }
     }
 
@@ -908,19 +1005,19 @@ TEST(OwningGroup, ExcludedComponents) {
     registry.remove<double>(e3);
 
     for(const auto entity: group) {
+        ASSERT_TRUE(entity == e1 || entity == e3);
+
         if(entity == e1) {
             ASSERT_EQ(group.get<int>(e1), 1);
         } else if(entity == e3) {
             ASSERT_EQ(group.get<int>(e3), 3);
-        } else {
-            FAIL();
         }
     }
 }
 
 TEST(OwningGroup, EmptyAndNonEmptyTypes) {
     entt::registry registry;
-    const auto group = registry.group<empty_type>(entt::get<int>);
+    const auto group = registry.group<int>(entt::get<empty_type>);
 
     const auto e0 = registry.create();
     registry.assign<empty_type>(e0);
@@ -936,7 +1033,7 @@ TEST(OwningGroup, EmptyAndNonEmptyTypes) {
         ASSERT_TRUE(entity == e0 || entity == e1);
     }
 
-    group.each([e0, e1](const auto entity, empty_type, const int &) {
+    group.each([e0, e1](const auto entity, const int &) {
         ASSERT_TRUE(entity == e0 || entity == e1);
     });
 
@@ -963,8 +1060,11 @@ TEST(OwningGroup, TrackEntitiesOnComponentDestruction) {
 
 TEST(OwningGroup, Less) {
     entt::registry registry;
-    const auto entity = std::get<0>(registry.create<int, entt::tag<"empty"_hs>>());
-    registry.create<char>();
+    const auto entity = registry.create();
+
+    registry.assign<int>(entity);
+    registry.assign<char>(entity);
+    registry.assign<entt::tag<"empty"_hs>>(entity);
 
     registry.group<int>(entt::get<char, entt::tag<"empty"_hs>>).less([entity](const auto entt, int, char) {
         ASSERT_EQ(entity, entt);
@@ -979,7 +1079,68 @@ TEST(OwningGroup, Less) {
         ASSERT_EQ(entity, entt);
     });
 
-    registry.group<double>(entt::get<int, char>).less([entity](const auto entt, double, int, char) {
+    registry.group<double>(entt::get<int, char>).less([](const auto, double, int, char) { FAIL(); });
+}
+
+TEST(OwningGroup, FrontBack) {
+    entt::registry registry;
+    auto group = registry.group<const char>(entt::get<const int>);
+
+    ASSERT_EQ(group.front(), static_cast<entt::entity>(entt::null));
+    ASSERT_EQ(group.back(), static_cast<entt::entity>(entt::null));
+
+    const auto e0 = registry.create();
+    registry.assign<int>(e0);
+    registry.assign<char>(e0);
+
+    const auto e1 = registry.create();
+    registry.assign<int>(e1);
+    registry.assign<char>(e1);
+
+    const auto entity = registry.create();
+    registry.assign<char>(entity);
+
+    ASSERT_EQ(group.front(), e1);
+    ASSERT_EQ(group.back(), e0);
+}
+
+TEST(OwningGroup, SignalRace) {
+    entt::registry registry;
+    registry.on_construct<double>().connect<&entt::registry::assign_or_replace<int>>();
+    registry.group<int>(entt::get<double>);
+
+    auto entity = registry.create();
+    registry.assign<double>(entity);
+
+    ASSERT_EQ(registry.group<int>(entt::get<double>).size(), 1u);
+}
+
+TEST(OwningGroup, StableLateInitialization) {
+    entt::registry registry;
+
+    for(std::size_t i{}; i < 30u; ++i) {
+        auto entity = registry.create();
+        if(!(i % 2u)) registry.assign<int>(entity);
+        if(!(i % 3u)) registry.assign<char>(entity);
+    }
+
+    // thanks to @pgruenbacher for pointing out this corner case
+    ASSERT_EQ((registry.group<int, char>().size()), 5u);
+}
+
+TEST(OwningGroup, PreventEarlyOptOut) {
+    entt::registry registry;
+
+    registry.assign<int>(registry.create(), 3);
+
+    const auto entity = registry.create();
+    registry.assign<char>(entity, 'c');
+    registry.assign<int>(entity, 2);
+
+    // thanks to @pgruenbacher for pointing out this corner case
+    registry.group<char, int>().each([entity](const auto entt, const auto &c, const auto &i) {
         ASSERT_EQ(entity, entt);
+        ASSERT_EQ(c, 'c');
+        ASSERT_EQ(i, 2);
     });
 }

test/entt/entity/helper.cpp

@@ -1,16 +1,23 @@
 #include <gtest/gtest.h>
 #include <entt/core/hashed_string.hpp>
 #include <entt/entity/helper.hpp>
+#include <entt/entity/entity.hpp>
 #include <entt/entity/registry.hpp>
 #include <entt/core/type_traits.hpp>
 
+struct clazz {
+    void func(entt::registry &, entt::entity curr) { entt = curr; }
+    entt::entity entt{entt::null};
+};
+
 TEST(Helper, AsView) {
     entt::registry registry;
     const entt::registry cregistry;
 
-    ([](entt::view<int, char>) {})(entt::as_view{registry});
-    ([](entt::view<const int, char>) {})(entt::as_view{registry});
-    ([](entt::view<const double>) {})(entt::as_view{cregistry});
+    ([](entt::view<entt::exclude_t<>, int>) {})(entt::as_view{registry});
+    ([](entt::view<entt::exclude_t<int>, char, double>) {})(entt::as_view{registry});
+    ([](entt::view<entt::exclude_t<int>, const char, double>) {})(entt::as_view{registry});
+    ([](entt::view<entt::exclude_t<int>, const char, const double>) {})(entt::as_view{registry});
 }
 
 TEST(Helper, AsGroup) {
@@ -18,32 +25,16 @@ TEST(Helper, AsGroup) {
     const entt::registry cregistry;
 
     ([](entt::group<entt::exclude_t<int>, entt::get_t<char>, double>) {})(entt::as_group{registry});
-    ([](entt::group<entt::exclude_t<const int>, entt::get_t<char>, double>) {})(entt::as_group{registry});
-    ([](entt::group<entt::exclude_t<const int>, entt::get_t<const char>, double>) {})(entt::as_group{registry});
-    ([](entt::group<entt::exclude_t<const int>, entt::get_t<const char>, const double>) {})(entt::as_group{registry});
+    ([](entt::group<entt::exclude_t<int>, entt::get_t<const char>, double>) {})(entt::as_group{registry});
+    ([](entt::group<entt::exclude_t<int>, entt::get_t<const char>, const double>) {})(entt::as_group{registry});
 }
 
-TEST(Helper, Tag) {
+TEST(Invoke, MemberFunction) {
     entt::registry registry;
     const auto entity = registry.create();
-    registry.assign<entt::tag<"foobar"_hs>>(entity);
-    registry.assign<int>(entity, 42);
-    int counter{};
 
-    ASSERT_FALSE(registry.has<entt::tag<"barfoo"_hs>>(entity));
-    ASSERT_TRUE(registry.has<entt::tag<"foobar"_hs>>(entity));
+    registry.on_construct<clazz>().connect<entt::invoke<&clazz::func>>();
+    registry.assign<clazz>(entity);
 
-    for(auto entt: registry.view<int, entt::tag<"foobar"_hs>>()) {
-        (void)entt;
-        ++counter;
-    }
-
-    ASSERT_NE(counter, 0);
-
-    for(auto entt: registry.view<entt::tag<"foobar"_hs>>()) {
-        (void)entt;
-        --counter;
-    }
-
-    ASSERT_EQ(counter, 0);
+    ASSERT_EQ(entity, registry.get<clazz>(entity).entt);
 }

test/entt/entity/observer.cpp

@@ -1,4 +1,5 @@
 #include <tuple>
+#include <cstddef>
 #include <type_traits>
 #include <gtest/gtest.h>
 #include <entt/entity/observer.hpp>
@@ -8,14 +9,15 @@ TEST(Observer, Functionalities) {
     entt::registry registry;
     entt::observer observer{registry, entt::collector.group<int>()};
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{});
+    ASSERT_EQ(observer.size(), 0u);
     ASSERT_TRUE(observer.empty());
     ASSERT_EQ(observer.data(), nullptr);
     ASSERT_EQ(observer.begin(), observer.end());
 
-    const auto entity = std::get<0>(registry.create<int>());
+    const auto entity = registry.create();
+    registry.assign<int>(entity);
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{1});
+    ASSERT_EQ(observer.size(), 1u);
     ASSERT_FALSE(observer.empty());
     ASSERT_NE(observer.data(), nullptr);
     ASSERT_EQ(*observer.data(), entity);
@@ -25,14 +27,14 @@ TEST(Observer, Functionalities) {
 
     observer.clear();
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{});
+    ASSERT_EQ(observer.size(), 0u);
     ASSERT_TRUE(observer.empty());
 
     observer.disconnect();
     registry.remove<int>(entity);
     registry.assign<int>(entity);
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{});
+    ASSERT_EQ(observer.size(), 0u);
     ASSERT_TRUE(observer.empty());
 }
 
@@ -50,7 +52,7 @@ TEST(Observer, AllOf) {
     registry.assign<int>(entity);
     registry.assign<char>(entity);
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{1});
+    ASSERT_EQ(observer.size(), 1u);
     ASSERT_FALSE(observer.empty());
     ASSERT_EQ(*observer.data(), entity);
 
@@ -79,7 +81,7 @@ TEST(Observer, AllOf) {
     observer.disconnect();
     registry.assign_or_replace<int>(entity);
     registry.assign_or_replace<char>(entity);
-    registry.reset<float>(entity);
+    registry.remove_if_exists<float>(entity);
 
     ASSERT_TRUE(observer.empty());
 }
@@ -96,7 +98,7 @@ TEST(Observer, AllOfFiltered) {
 
     registry.assign<int>(entity);
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{});
+    ASSERT_EQ(observer.size(), 0u);
     ASSERT_TRUE(observer.empty());
     ASSERT_EQ(observer.data(), nullptr);
 
@@ -111,7 +113,7 @@ TEST(Observer, AllOfFiltered) {
     registry.remove<double>(entity);
     registry.assign<int>(entity);
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{1});
+    ASSERT_EQ(observer.size(), 1u);
     ASSERT_FALSE(observer.empty());
     ASSERT_EQ(*observer.data(), entity);
 
@@ -144,7 +146,7 @@ TEST(Observer, Observe) {
 
     registry.assign_or_replace<int>(entity);
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{1});
+    ASSERT_EQ(observer.size(), 1u);
     ASSERT_FALSE(observer.empty());
     ASSERT_EQ(*observer.data(), entity);
 
@@ -177,7 +179,7 @@ TEST(Observer, ObserveFiltered) {
     registry.assign<int>(entity);
     registry.replace<int>(entity);
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{});
+    ASSERT_EQ(observer.size(), 0u);
     ASSERT_TRUE(observer.empty());
     ASSERT_EQ(observer.data(), nullptr);
 
@@ -190,7 +192,7 @@ TEST(Observer, ObserveFiltered) {
     registry.remove<double>(entity);
     registry.replace<int>(entity);
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{1});
+    ASSERT_EQ(observer.size(), 1u);
     ASSERT_FALSE(observer.empty());
     ASSERT_EQ(*observer.data(), entity);
 
@@ -222,7 +224,7 @@ TEST(Observer, AllOfObserve) {
     registry.replace<char>(entity);
     registry.remove<int>(entity);
 
-    ASSERT_EQ(observer.size(), entt::observer::size_type{1});
+    ASSERT_EQ(observer.size(), 1u);
     ASSERT_FALSE(observer.empty());
     ASSERT_EQ(*observer.data(), entity);
 
@@ -262,22 +264,79 @@ TEST(Observer, CrossRulesCornerCase) {
 TEST(Observer, Each) {
     entt::registry registry;
     entt::observer observer{registry, entt::collector.group<int>()};
-    const auto entity = std::get<0>(registry.create<int>());
+    const auto entity = registry.create();
+    registry.assign<int>(entity);
 
     ASSERT_FALSE(observer.empty());
-    ASSERT_EQ(observer.size(), entt::observer::size_type{1});
+    ASSERT_EQ(observer.size(), 1u);
 
     std::as_const(observer).each([entity](const auto entt) {
         ASSERT_EQ(entity, entt);
     });
 
     ASSERT_FALSE(observer.empty());
-    ASSERT_EQ(observer.size(), entt::observer::size_type{1});
+    ASSERT_EQ(observer.size(), 1u);
 
     observer.each([entity](const auto entt) {
         ASSERT_EQ(entity, entt);
     });
 
     ASSERT_TRUE(observer.empty());
-    ASSERT_EQ(observer.size(), entt::observer::size_type{});
+    ASSERT_EQ(observer.size(), 0u);
+}
+
+TEST(Observer, MultipleFilters) {
+    constexpr auto collector =  entt::collector
+            .replace<int>().where<char>()
+            .replace<double>().where<float>();
+
+    entt::registry registry;
+    entt::observer observer{registry, collector};
+    const auto entity = registry.create();
+
+    ASSERT_TRUE(observer.empty());
+
+    registry.assign_or_replace<int>(entity);
+    registry.assign<char>(entity);
+
+    ASSERT_TRUE(observer.empty());
+
+    registry.assign_or_replace<int>(entity);
+
+    ASSERT_EQ(observer.size(), 1u);
+    ASSERT_FALSE(observer.empty());
+    ASSERT_EQ(*observer.data(), entity);
+
+    observer.clear();
+    registry.assign<double>(entity);
+
+    ASSERT_TRUE(observer.empty());
+
+    registry.assign_or_replace<double>(entity);
+    registry.assign<float>(entity);
+
+    ASSERT_TRUE(observer.empty());
+
+    registry.assign_or_replace<double>(entity);
+
+    ASSERT_EQ(observer.size(), 1u);
+    ASSERT_FALSE(observer.empty());
+    ASSERT_EQ(*observer.data(), entity);
+
+    registry.remove<float>(entity);
+
+    ASSERT_TRUE(observer.empty());
+
+    registry.assign_or_replace<int>(entity);
+
+    ASSERT_EQ(observer.size(), 1u);
+    ASSERT_FALSE(observer.empty());
+    ASSERT_EQ(*observer.data(), entity);
+
+    observer.clear();
+    observer.disconnect();
+
+    registry.assign_or_replace<int>(entity);
+
+    ASSERT_TRUE(observer.empty());
 }