Update ci.yml

Feature/foa fast iteration

.drone.jsonnet

@@ -6,11 +6,12 @@ local library = "unordered";
 
 local triggers =
 {
-    branch: [ "master", "develop", "feature/*", "bugfix/*" ]
+    branch: [ "master", "develop", "feature/*", "bugfix/*", "fix/*", "pr/*" ]
 };
 
 local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
 local asan = { ASAN: '1' };
+local tsan = { TSAN: '1' };
 
 local linux_pipeline(name, image, environment, packages = "", sources = [], arch = "amd64") =
 {
@@ -224,6 +225,13 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         "g++-12-multilib",
     ),
 
+    linux_pipeline(
+        "Linux 22.04 GCC 12 64 TSAN (11,14,17,20,2b)",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'gcc', COMPILER: 'g++-12', CXXSTD: '11,14,17,20,2b', ADDRMD: '64', TARGET: 'libs/unordered/test//cfoa_tests' } + tsan,
+        "g++-12-multilib",
+    ),
+
     linux_pipeline(
         "Linux 16.04 Clang 3.5",
         "cppalliance/droneubuntu1604:1",
@@ -343,6 +351,13 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
         "clang-14",
     ),
 
+    linux_pipeline(
+        "Linux 22.04 Clang 14 libc++ 64 TSAN",
+        "cppalliance/droneubuntu2204:1",
+        { TOOLSET: 'clang', COMPILER: 'clang++-14', ADDRMD: '64', TARGET: 'libs/unordered/test//cfoa_tests', CXXSTD: '11,14,17,20', STDLIB: 'libc++' } + tsan,
+        "clang-14 libc++-14-dev libc++abi-14-dev",
+    ),
+
     linux_pipeline(
         "Linux 22.04 Clang 15",
         "cppalliance/droneubuntu2204:1",
@@ -359,7 +374,13 @@ local windows_pipeline(name, image, environment, arch = "amd64") =
     macos_pipeline(
         "MacOS 12.4 Xcode 13.4.1 ASAN",
         { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '03,11,14,1z' } + asan,
-        xcode_version = "13.4.1", osx_version = "monterey",
+        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
+    ),
+
+    macos_pipeline(
+        "MacOS 12.4 Xcode 13.4.1 TSAN",
+        { TOOLSET: 'clang', COMPILER: 'clang++', CXXSTD: '11,14,1z', TARGET: 'libs/unordered/test//cfoa_tests' } + tsan,
+        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
     ),
 
     windows_pipeline(

.drone/drone.sh

@@ -7,6 +7,8 @@
 set -ex
 export PATH=~/.local/bin:/usr/local/bin:$PATH
 
+: ${TARGET:="libs/$LIBRARY/test"}
+
 DRONE_BUILD_DIR=$(pwd)
 
 BOOST_BRANCH=develop
@@ -22,4 +24,4 @@ python tools/boostdep/depinst/depinst.py $LIBRARY
 ./b2 -d0 headers
 
 echo "using $TOOLSET : : $COMPILER ;" > ~/user-config.jam
-./b2 -j3 libs/$LIBRARY/test toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}
+./b2 -j3 $TARGET toolset=$TOOLSET cxxstd=$CXXSTD variant=debug,release ${ADDRMD:+address-model=$ADDRMD} ${STDLIB:+stdlib=$STDLIB} ${UBSAN:+undefined-sanitizer=norecover debug-symbols=on} ${ASAN:+address-sanitizer=norecover debug-symbols=on} ${TSAN:+thread-sanitizer=norecover debug-symbols=on} ${LINKFLAGS:+linkflags=$LINKFLAGS}

.github/workflows/ci.yml

@@ -19,9 +19,9 @@ on:
       - fix/**
       - pr/**
 
-concurrency:
-  group: ${{format('{0}:{1}', github.repository, github.ref)}}
-  cancel-in-progress: true
+#concurrency:
+#  group: ${{format('{0}:{1}', github.repository, github.ref)}}
+#  cancel-in-progress: true
 
 env:
   GIT_FETCH_JOBS: 8
@@ -42,39 +42,52 @@ jobs:
       matrix:
         include:
           # Linux, gcc
-          - { compiler: gcc-7,     cxxstd: '03,11,14,17',    os: ubuntu-20.04, install: 'g++-7' }
-          - { compiler: gcc-8,     cxxstd: '03,11,14,17',    os: ubuntu-20.04, install: 'g++-8' }
-          - { compiler: gcc-9,     cxxstd: '03,11,14,17',    os: ubuntu-20.04, install: 'g++-9' }
-          - { compiler: gcc-10,    cxxstd: '03,11,14,17,20', os: ubuntu-22.04, install: 'g++-10' }
-          - { compiler: gcc-11,    cxxstd: '03,11,14,17,20', os: ubuntu-22.04, install: 'g++-11' }
-          - { name: "gcc-12 w/ sanitizers (03,11,14)", sanitize: yes,
-              compiler: gcc-12,    cxxstd: '03,11,14',       os: ubuntu-22.04, ccache_key: "san1" }
-          - { name: "gcc-12 w/ sanitizers (17,20,2b)", sanitize: yes,
-              compiler: gcc-12,    cxxstd: '17,20,2b',       os: ubuntu-22.04, ccache_key: "san2" }
-          - { name: Collect coverage, coverage: yes,
-              compiler: gcc-8,     cxxstd: '03,11',          os: ubuntu-20.04, install: 'g++-8-multilib', address-model: '32,64', ccache_key: "cov" }
+#          - { compiler: gcc-7,     cxxstd: '03,11,14,17',    os: ubuntu-20.04, install: 'g++-7' }
+#          - { compiler: gcc-8,     cxxstd: '03,11,14,17',    os: ubuntu-20.04, install: 'g++-8' }
+#          - { compiler: gcc-9,     cxxstd: '03,11,14,17',    os: ubuntu-20.04, install: 'g++-9' }
+#          - { compiler: gcc-10,    cxxstd: '03,11,14,17,20', os: ubuntu-22.04, install: 'g++-10' }
+#          - { compiler: gcc-11,    cxxstd: '03,11,14,17,20', os: ubuntu-22.04, install: 'g++-11' }
+#          - { name: "gcc-12 w/ sanitizers (03,11,14)", sanitize: yes,
+#              compiler: gcc-12,    cxxstd: '03,11,14',       os: ubuntu-22.04, ccache_key: "san1" }
+#          - { name: "gcc-12 w/ sanitizers (17,20,2b)", sanitize: yes,
+#              compiler: gcc-12,    cxxstd: '17,20,2b',       os: ubuntu-22.04, ccache_key: "san2" }
+#          - { name: Collect coverage, coverage: yes,
+#              compiler: gcc-8,     cxxstd: '03,11',          os: ubuntu-20.04, install: 'g++-8-multilib', address-model: '32,64', ccache_key: "cov" }
+
+          - { name: "cfoa tsan (gcc)", cxxstd: '11,14,17,20,2b', os: ubuntu-22.04, compiler: gcc-12,
+              targets: 'libs/unordered/test//cfoa_tests', thread-sanitize: yes, ccache_key: "tsan-gcc" }
 
           # Linux, clang, libc++
-          - { compiler: clang-7,   cxxstd: '03,11,14,17',       os: ubuntu-20.04, stdlib: libc++, install: 'clang-7 libc++-7-dev libc++abi-7-dev' }
-          - { compiler: clang-10,  cxxstd: '03,11,14,17,20',    os: ubuntu-20.04, stdlib: libc++, install: 'clang-10 libc++-10-dev libc++abi-10-dev' }
-          - { compiler: clang-11,  cxxstd: '03,11,14,17,20',    os: ubuntu-22.04, stdlib: libc++, install: 'clang-11 libc++-11-dev libc++abi-11-dev' }
+#          - { compiler: clang-7,   cxxstd: '03,11,14,17',       os: ubuntu-20.04, stdlib: libc++, install: 'clang-7 libc++-7-dev libc++abi-7-dev' }
+#          - { compiler: clang-10,  cxxstd: '03,11,14,17,20',    os: ubuntu-20.04, stdlib: libc++, install: 'clang-10 libc++-10-dev libc++abi-10-dev' }
+#          - { compiler: clang-11,  cxxstd: '03,11,14,17,20',    os: ubuntu-22.04, stdlib: libc++, install: 'clang-11 libc++-11-dev libc++abi-11-dev' }
           # clang-12 doesn't work on ubuntu-22.04, the linker can't find -lunwind for some reason
-          - { name: "clang-12 w/ sanitizers (03,11,14)", sanitize: yes,
-              compiler: clang-12,  cxxstd: '03,11,14',          os: ubuntu-20.04, stdlib: libc++, install: 'clang-12 libc++-12-dev libc++abi-12-dev', ccache_key: "san1" }
-          - { name: "clang-12 w/ sanitizers (17,20,2b)", sanitize: yes,
-              compiler: clang-12,  cxxstd: '17,20,2b',          os: ubuntu-20.04, stdlib: libc++, install: 'clang-12 libc++-12-dev libc++abi-12-dev', ccache_key: "san2" }
-          - { compiler: clang-13,  cxxstd: '03,11,14,17,20,2b', os: ubuntu-22.04, stdlib: libc++, install: 'clang-13 libc++-13-dev libc++abi-13-dev' }
-          - { compiler: clang-14,  cxxstd: '03,11,14,17,20,2b', os: ubuntu-22.04, stdlib: libc++, install: 'clang-14 libc++-14-dev libc++abi-14-dev' }
+#          - { name: "clang-12 w/ sanitizers (03,11,14)", sanitize: yes,
+#              compiler: clang-12,  cxxstd: '03,11,14',          os: ubuntu-20.04, stdlib: libc++, install: 'clang-12 libc++-12-dev libc++abi-12-dev', ccache_key: "san1" }
+#          - { name: "clang-12 w/ sanitizers (17,20,2b)", sanitize: yes,
+#              compiler: clang-12,  cxxstd: '17,20,2b',          os: ubuntu-20.04, stdlib: libc++, install: 'clang-12 libc++-12-dev libc++abi-12-dev', ccache_key: "san2" }
+#          - { compiler: clang-13,  cxxstd: '03,11,14,17,20,2b', os: ubuntu-22.04, stdlib: libc++, install: 'clang-13 libc++-13-dev libc++abi-13-dev' }
+#          - { compiler: clang-14,  cxxstd: '03,11,14,17,20,2b', os: ubuntu-22.04, stdlib: libc++, install: 'clang-14 libc++-14-dev libc++abi-14-dev' }
+
           # not using libc++ because of https://github.com/llvm/llvm-project/issues/52771
-          - { name: "clang-14 w/ sanitizers (03,11,14)", sanitize: yes,
-              compiler: clang-14,  cxxstd: '03,11,14',          os: ubuntu-22.04, ccache_key: "san1" }
-          - { name: "clang-14 w/ sanitizers (17,20,2b)", sanitize: yes,
-              compiler: clang-14,  cxxstd: '17,20,2b',          os: ubuntu-22.04, ccache_key: "san2" }
+#          - { name: "clang-14 w/ sanitizers (03,11,14)", sanitize: yes,
+#              compiler: clang-14,  cxxstd: '03,11,14',          os: ubuntu-22.04, ccache_key: "san1" }
+#          - { name: "clang-14 w/ sanitizers (17,20,2b)", sanitize: yes,
+#              compiler: clang-14,  cxxstd: '17,20,2b',          os: ubuntu-22.04, ccache_key: "san2" }
+
+          - { name: "cfoa tsan (clang)", cxxstd: '11,14,17,20,2b', os: ubuntu-22.04, compiler: clang-14,
+              targets: 'libs/unordered/test//cfoa_tests', thread-sanitize: yes,
+              stdlib: libc++, install: 'clang-14 libc++-14-dev libc++abi-14-dev', ccache_key: "tsan-clang" }
 
           # OSX, clang
-          - { compiler: clang,     cxxstd: '03,11,14,17,2a',    os: macos-11, sanitize: yes }
+          - { compiler: clang,     cxxstd: '11,14',    os: macos-11, ccache_key: "11-14" }
+          - { compiler: clang,     cxxstd: '17,2a',    os: macos-11, ccache_key: "17-2a" }
+          - { compiler: clang,     cxxstd: '11,14',    os: macos-12, sanitize: yes, ccache_key: "11-14" }
+          - { compiler: clang,     cxxstd: '17,2a',    os: macos-12, sanitize: yes, ccache_key: "17-2a" }
+          - { compiler: clang,     cxxstd: '11,14',    os: macos-12, thread-sanitize: yes, targets: 'libs/unordered/test//cfoa_tests', ccache_key: "tsan-macos-1" }
+          - { compiler: clang,     cxxstd: '17,2a',    os: macos-12, thread-sanitize: yes, targets: 'libs/unordered/test//cfoa_tests', ccache_key: "tsan-macos-2" }
 
-    timeout-minutes: 120
+    timeout-minutes: 240
     runs-on: ${{matrix.os}}
     container: ${{matrix.container}}
     env: {B2_USE_CCACHE: 1}
@@ -183,6 +196,8 @@ jobs:
           B2_COMPILER: ${{matrix.compiler}}
           B2_CXXSTD: ${{matrix.cxxstd}}
           B2_SANITIZE: ${{matrix.sanitize}}
+          B2_TSAN: ${{matrix.thread-sanitize}}
+          B2_TARGETS: ${{matrix.targets}}
           B2_STDLIB: ${{matrix.stdlib}}
           # More entries can be added in the same way, see the B2_ARGS assignment in ci/enforce.sh for the possible keys.
           # B2_DEFINES: ${{matrix.defines}}
@@ -196,7 +211,7 @@ jobs:
 
       - name: Run tests
         if: '!matrix.coverity'
-        run: ci/build.sh
+        run: B2_TARGETS=${{matrix.targets}} B2_FLAGS='-l 3600' ci/build.sh
 
       - name: Upload coverage
         if: matrix.coverage
@@ -208,187 +223,3 @@ jobs:
         env:
           COVERITY_SCAN_NOTIFICATION_EMAIL: ${{ secrets.COVERITY_SCAN_NOTIFICATION_EMAIL }}
           COVERITY_SCAN_TOKEN: ${{ secrets.COVERITY_SCAN_TOKEN }}
-
-  windows:
-    defaults:
-      run:
-        shell: cmd
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { toolset: msvc-14.0, cxxstd: '14,latest',       addrmd: '32,64', os: windows-2019, variant: 'debug,release' }
-          - { toolset: msvc-14.2, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2019, variant: 'debug,release' }
-          - { toolset: msvc-14.3, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2022, variant: 'debug,release' }
-          - { toolset: msvc-14.3, cxxstd: '14',              addrmd: '64',    os: windows-2022, variant: 'debug', defines: '_ALLOW_RTCc_IN_STL', cxxflags: '/RTCc'              }
-          - { toolset: msvc-14.3, cxxstd: '14',              addrmd: '32',    os: windows-2022, variant: 'debug', defines: '_ALLOW_RTCc_IN_STL', cxxflags: '"/RTCc /arch:IA32"' }
-          - { toolset: clang-win, cxxstd: '14,17,latest',    addrmd: '32,64', os: windows-2022, variant: 'debug,release' }
-          - { toolset: gcc,       cxxstd: '03,11,14,17,2a',  addrmd: '64',    os: windows-2019, variant: 'debug,release' }
-
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Fetch Boost.CI
-        uses: actions/checkout@v3
-        with:
-          repository: boostorg/boost-ci
-          ref: master
-          path: boost-ci-cloned
-      - name: Get CI scripts folder
-        run: |
-            REM Copy ci folder if not testing Boost.CI
-            if "%GITHUB_REPOSITORY%" == "%GITHUB_REPOSITORY:boost-ci=%" xcopy /s /e /q /i /y boost-ci-cloned\ci .\ci
-            rmdir /s /q boost-ci-cloned
-
-      - name: Setup Boost
-        run: ci\github\install.bat
-
-      - name: Run tests
-        if: '!matrix.coverage'
-        run: ci\build.bat
-        env:
-          B2_TOOLSET: ${{matrix.toolset}}
-          B2_CXXSTD: ${{matrix.cxxstd}}
-          B2_ADDRESS_MODEL: ${{matrix.addrmd}}
-          B2_DEFINES: ${{matrix.defines}}
-          B2_VARIANT: ${{matrix.variant}}
-          B2_CXXFLAGS: ${{matrix.cxxflags}}
-
-      - name: Collect coverage
-        shell: powershell
-        if: matrix.coverage
-        run: ci\opencppcoverage.ps1
-        env:
-          B2_TOOLSET: ${{matrix.toolset}}
-          B2_CXXSTD: ${{matrix.cxxstd}}
-          B2_ADDRESS_MODEL: ${{matrix.addrmd}}
-
-      - name: Upload coverage
-        if: matrix.coverage
-        uses: codecov/codecov-action@v2
-        with:
-          files: __out/cobertura.xml
-
-  MSYS2:
-    defaults:
-      run:
-        shell: msys2 {0}
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { sys: MINGW32, compiler: gcc, cxxstd: '03,11,17,20' }
-          - { sys: MINGW64, compiler: gcc, cxxstd: '03,11,17,20' }
-
-    runs-on: windows-latest
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Setup MSYS2 environment
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: ${{matrix.sys}}
-          update: true
-          install: git python
-          pacboy: gcc:p cmake:p ninja:p
-
-      - name: Fetch Boost.CI
-        uses: actions/checkout@v3
-        with:
-          repository: boostorg/boost-ci
-          ref: master
-          path: boost-ci-cloned
-      - name: Get CI scripts folder
-        run: |
-            # Copy ci folder if not testing Boost.CI
-            [[ "$GITHUB_REPOSITORY" =~ "boost-ci" ]] || cp -r boost-ci-cloned/ci .
-            rm -rf boost-ci-cloned
-
-      - name: Setup Boost
-        env:
-          B2_COMPILER: ${{matrix.compiler}}
-          B2_CXXSTD: ${{matrix.cxxstd}}
-          B2_SANITIZE: ${{matrix.sanitize}}
-          B2_STDLIB: ${{matrix.stdlib}}
-        run: ci/github/install.sh
-
-      - name: Run tests
-        run: ci/build.sh
-
-      # Run also the CMake tests to avoid having to setup another matrix for CMake on MSYS
-      - name: Run CMake tests
-        run: |
-            cd "$BOOST_ROOT"
-            mkdir __build_cmake_test__ && cd __build_cmake_test__
-            cmake -G Ninja -DCMAKE_BUILD_TYPE=Debug -DBOOST_INCLUDE_LIBRARIES=$SELF -DBUILD_SHARED_LIBS=ON -DBUILD_TESTING=ON -DBoost_VERBOSE=ON ..
-            cmake --build . --target tests --config Debug -j$B2_JOBS
-            ctest --output-on-failure --build-config Debug
-
-  CMake:
-    defaults:
-      run:
-        shell: bash
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - { os: ubuntu-20.04, build_shared: ON,  build_type: Debug, generator: 'Unix Makefiles' }
-          - { os: windows-2019, build_shared: ON,  build_type: Debug, generator: 'Visual Studio 16 2019' }
-
-    timeout-minutes: 120
-    runs-on: ${{matrix.os}}
-
-    steps:
-      - uses: actions/checkout@v3
-      - name: Fetch Boost.CI
-        uses: actions/checkout@v3
-        with:
-          repository: boostorg/boost-ci
-          ref: master
-          path: boost-ci-cloned
-      - name: Get CI scripts folder
-        run: |
-            # Copy ci folder if not testing Boost.CI
-            [[ "$GITHUB_REPOSITORY" =~ "boost-ci" ]] || cp -r boost-ci-cloned/ci .
-            rm -rf boost-ci-cloned
-      - name: Setup Boost
-        env: {B2_DONT_BOOTSTRAP: 1}
-        run: source ci/github/install.sh
-
-      - name: Run CMake tests
-        run: |
-            cd "$BOOST_ROOT"
-            mkdir __build_cmake_test__ && cd __build_cmake_test__
-            cmake -G "${{matrix.generator}}" -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DBOOST_INCLUDE_LIBRARIES=$SELF -DBUILD_SHARED_LIBS=${{matrix.build_shared}} -DBUILD_TESTING=ON -DBoost_VERBOSE=ON ..
-            cmake --build . --target tests --config ${{matrix.build_type}} -j$B2_JOBS
-            ctest --output-on-failure --build-config ${{matrix.build_type}}
-
-      - name: Run CMake subdir tests
-        run: |
-            cmake_test_folder="$BOOST_ROOT/libs/$SELF/test/cmake_test" # New unified folder
-            [ -d "$cmake_test_folder" ] || cmake_test_folder="$BOOST_ROOT/libs/$SELF/test/cmake_subdir_test"
-            cd "$cmake_test_folder"
-            mkdir __build_cmake_subdir_test__ && cd __build_cmake_subdir_test__
-            cmake -G "${{matrix.generator}}" -DBOOST_CI_INSTALL_TEST=OFF -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DBUILD_SHARED_LIBS=${{matrix.build_shared}} ..
-            cmake --build . --config ${{matrix.build_type}} -j$B2_JOBS
-            ctest --output-on-failure --build-config ${{matrix.build_type}}
-
-      - name: Install Library
-        run: |
-            cd "$BOOST_ROOT"
-            mkdir __build_cmake_install_test__ && cd __build_cmake_install_test__
-            cmake -G "${{matrix.generator}}" -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DBOOST_INCLUDE_LIBRARIES=$SELF -DBUILD_SHARED_LIBS=${{matrix.build_shared}} -DCMAKE_INSTALL_PREFIX=~/.local -DBoost_VERBOSE=ON -DBoost_DEBUG=ON ..
-            cmake --build . --target install --config ${{matrix.build_type}} -j$B2_JOBS
-      - name: Run CMake install tests
-        run: |
-            cmake_test_folder="$BOOST_ROOT/libs/$SELF/test/cmake_test" # New unified folder
-            [ -d "$cmake_test_folder" ] || cmake_test_folder="$BOOST_ROOT/libs/$SELF/test/cmake_install_test"
-            cd "$cmake_test_folder"
-            mkdir __build_cmake_install_test__ && cd __build_cmake_install_test__
-            cmake -G "${{matrix.generator}}" -DBOOST_CI_INSTALL_TEST=ON -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DBUILD_SHARED_LIBS=${{matrix.build_shared}} -DCMAKE_PREFIX_PATH=~/.local ..
-            cmake --build . --config ${{matrix.build_type}} -j$B2_JOBS
-            ctest --output-on-failure --build-config ${{matrix.build_type}}

.gitignore

@@ -1 +1,2 @@
 /doc/html/
+/doc/pdf/

benchmark/string.cpp

@@ -1,4 +1,5 @@
 // Copyright 2021 Peter Dimov.
+// Copyright 2023 Joaquin M Lopez Munoz.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -6,6 +7,7 @@
 #define _SILENCE_CXX20_CISO646_REMOVED_WARNING
 
 #include <boost/unordered_map.hpp>
+#include <boost/unordered/unordered_node_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
@@ -272,6 +274,9 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
     boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map =
+    boost::unordered_node_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map =
     boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -345,6 +350,9 @@ std::unordered_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
 template<class K, class V> using boost_unordered_map_fnv1a =
     boost::unordered_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map_fnv1a =
+    boost::unordered_node_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map_fnv1a =
     boost::unordered_flat_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -373,6 +381,7 @@ int main()
 
     test<std_unordered_map>( "std::unordered_map" );
     test<boost_unordered_map>( "boost::unordered_map" );
+    test<boost_unordered_node_map>( "boost::unordered_node_map" );
     test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE
@@ -390,6 +399,7 @@ int main()
 
     test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
     test<boost_unordered_map_fnv1a>( "boost::unordered_map, FNV-1a" );
+    test<boost_unordered_node_map_fnv1a>( "boost::unordered_node_map, FNV-1a" );
     test<boost_unordered_flat_map_fnv1a>( "boost::unordered_flat_map, FNV-1a" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE

benchmark/string_view.cpp

@@ -1,4 +1,5 @@
 // Copyright 2021 Peter Dimov.
+// Copyright 2023 Joaquin M Lopez Munoz.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -6,6 +7,7 @@
 #define _SILENCE_CXX20_CISO646_REMOVED_WARNING
 
 #include <boost/unordered_map.hpp>
+#include <boost/unordered/unordered_node_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
@@ -273,6 +275,9 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
     boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map =
+    boost::unordered_node_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map =
     boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -346,6 +351,9 @@ std::unordered_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
 template<class K, class V> using boost_unordered_map_fnv1a =
     boost::unordered_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map_fnv1a =
+    boost::unordered_node_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map_fnv1a =
     boost::unordered_flat_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -374,6 +382,7 @@ int main()
 
     test<std_unordered_map>( "std::unordered_map" );
     test<boost_unordered_map>( "boost::unordered_map" );
+    test<boost_unordered_node_map>( "boost::unordered_node_map" );
     test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE
@@ -391,6 +400,7 @@ int main()
 
     test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
     test<boost_unordered_map_fnv1a>( "boost::unordered_map, FNV-1a" );
+    test<boost_unordered_node_map_fnv1a>( "boost::unordered_node_map, FNV-1a" );
     test<boost_unordered_flat_map_fnv1a>( "boost::unordered_flat_map, FNV-1a" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE

benchmark/uint32.cpp

@@ -1,4 +1,5 @@
 // Copyright 2021 Peter Dimov.
+// Copyright 2023 Joaquin M Lopez Munoz.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -6,6 +7,7 @@
 #define _SILENCE_CXX20_CISO646_REMOVED_WARNING
 
 #include <boost/unordered_map.hpp>
+#include <boost/unordered/unordered_node_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
 #include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
@@ -289,6 +291,9 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
     boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map =
+    boost::unordered_node_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map =
     boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -315,6 +320,7 @@ int main()
 
     test<std_unordered_map>( "std::unordered_map" );
     test<boost_unordered_map>( "boost::unordered_map" );
+    test<boost_unordered_node_map>( "boost::unordered_node_map" );
     test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE

benchmark/uint64.cpp

@@ -1,4 +1,5 @@
 // Copyright 2021 Peter Dimov.
+// Copyright 2023 Joaquin M Lopez Munoz.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -6,6 +7,7 @@
 #define _SILENCE_CXX20_CISO646_REMOVED_WARNING
 
 #include <boost/unordered_map.hpp>
+#include <boost/unordered/unordered_node_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
 #include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
@@ -289,6 +291,9 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
     boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map =
+    boost::unordered_node_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map =
     boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -325,6 +330,7 @@ int main()
 #endif
 
     test<boost_unordered_map>( "boost::unordered_map" );
+    test<boost_unordered_node_map>( "boost::unordered_node_map" );
     test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE

benchmark/uuid.cpp

@@ -1,4 +1,5 @@
 // Copyright 2021, 2022 Peter Dimov.
+// Copyright 2023 Joaquin M Lopez Munoz.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -6,6 +7,7 @@
 #define _SILENCE_CXX20_CISO646_REMOVED_WARNING
 
 #include <boost/unordered_map.hpp>
+#include <boost/unordered/unordered_node_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
 #include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
@@ -340,6 +342,9 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
     boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map =
+    boost::unordered_node_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map =
     boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -366,6 +371,7 @@ int main()
 
     test<std_unordered_map>( "std::unordered_map" );
     test<boost_unordered_map>( "boost::unordered_map" );
+    test<boost_unordered_node_map>( "boost::unordered_node_map" );
     test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE

benchmark/word_count.cpp

@@ -1,4 +1,5 @@
 // Copyright 2021, 2022 Peter Dimov.
+// Copyright 2023 Joaquin M Lopez Munoz.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -6,6 +7,7 @@
 #define _SILENCE_CXX20_CISO646_REMOVED_WARNING
 
 #include <boost/unordered_map.hpp>
+#include <boost/unordered/unordered_node_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
 #include <boost/regex.hpp>
 #ifdef HAVE_ABSEIL
@@ -227,6 +229,9 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
     boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map =
+    boost::unordered_node_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map =
     boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -300,6 +305,9 @@ std::unordered_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
 template<class K, class V> using boost_unordered_map_fnv1a =
     boost::unordered_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map_fnv1a =
+    boost::unordered_node_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map_fnv1a =
     boost::unordered_flat_map<K, V, fnv1a_hash, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -328,6 +336,7 @@ int main()
 
     test<std_unordered_map>( "std::unordered_map" );
     test<boost_unordered_map>( "boost::unordered_map" );
+    test<boost_unordered_node_map>( "boost::unordered_node_map" );
     test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE
@@ -345,6 +354,7 @@ int main()
 
     test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
     test<boost_unordered_map_fnv1a>( "boost::unordered_map, FNV-1a" );
+    test<boost_unordered_node_map_fnv1a>( "boost::unordered_node_map, FNV-1a" );
     test<boost_unordered_flat_map_fnv1a>( "boost::unordered_flat_map, FNV-1a" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE

benchmark/word_size.cpp

@@ -1,4 +1,5 @@
 // Copyright 2021, 2022 Peter Dimov.
+// Copyright 2023 Joaquin M Lopez Munoz.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -6,6 +7,7 @@
 #define _SILENCE_CXX20_CISO646_REMOVED_WARNING
 
 #include <boost/unordered_map.hpp>
+#include <boost/unordered/unordered_node_map.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
 #include <boost/regex.hpp>
 #ifdef HAVE_ABSEIL
@@ -181,6 +183,9 @@ template<class K, class V> using std_unordered_map =
 template<class K, class V> using boost_unordered_map =
     boost::unordered_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
+template<class K, class V> using boost_unordered_node_map =
+    boost::unordered_node_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
+
 template<class K, class V> using boost_unordered_flat_map =
     boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
 
@@ -207,6 +212,7 @@ int main()
 
     test<std_unordered_map>( "std::unordered_map" );
     test<boost_unordered_map>( "boost::unordered_map" );
+    test<boost_unordered_node_map>( "boost::unordered_node_map" );
     test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE

doc/unordered/benchmarks.adoc

@@ -278,13 +278,14 @@ max load factor 5
 
 |===
 
-== boost::unordered_flat_map
+== boost::unordered_(flat|node)_map
 
 All benchmarks were created using:
 
 * `https://abseil.io/docs/cpp/guides/container[absl::flat_hash_map^]<uint64_t, uint64_t>`
-* `boost::unordered_flat_map<uint64_t, uint64_t>`
 * `boost::unordered_map<uint64_t, uint64_t>`
+* `boost::unordered_flat_map<uint64_t, uint64_t>`
+* `boost::unordered_node_map<uint64_t, uint64_t>`
 
 The source code can be https://github.com/boostorg/boost_unordered_benchmarks/tree/boost_unordered_flat_map[found here^].
 

doc/unordered/buckets.adoc

@@ -134,7 +134,8 @@ h|*Method* h|*Description*
 |Changes the number of buckets so that there at least `n` buckets, and so that the load factor is less than the maximum load factor.
 
 2+^h| *Open-addressing containers only* +
-`boost::unordered_flat_set`, `boost::unordered_flat_map` 
+`boost::unordered_flat_set`, `boost::unordered_flat_map` +
+`boost::unordered_node_set`, `boost::unordered_node_map` +
 h|*Method* h|*Description*
 
 |`size_type max_load() const`
@@ -160,8 +161,9 @@ change the number of buckets when this happens. Iterators can be
 invalidated by calls to `insert`, `rehash` and `reserve`.
 
 As for pointers and references,
-they are never invalidated for closed-addressing containers (`boost::unordered_[multi]set`, `boost::unordered_[multi]map`),
-but they will when rehashing occurs for open-addressing
+they are never invalidated for node-based containers 
+(`boost::unordered_[multi]set`, `boost::unordered_[multi]map`, `boost::unordered_node_set`, `boost::unordered_node_map`),
+but they will when rehashing occurs for
 `boost::unordered_flat_set` and `boost::unordered_flat_map`: this is because
 these containers store elements directly into their holding buckets, so
 when allocating a new bucket array the elements must be transferred by means of move construction.
@@ -252,15 +254,16 @@ xref:#rationale_boostunordered_multiset_and_boostunordered_multimap[correspondin
 
 == Open Addressing Implementation
 
-The diagram shows the basic internal layout of `boost::unordered_flat_map` and
-`boost:unordered_flat_set`.
+The diagram shows the basic internal layout of `boost::unordered_flat_map`/`unordered_node_map` and
+`boost:unordered_flat_set`/`unordered_node_set`.
 
 
 [#img-foa-layout]
 .Open-addressing layout used by Boost.Unordered.
 image::foa.png[align=center]
 
-As with all open-addressing containers, elements are stored directly in the bucket array.
+As with all open-addressing containers, elements (or pointers to the element nodes in the case of
+`boost::unordered_node_map` and `boost::unordered_node_set`) are stored directly in the bucket array.
 This array is logically divided into 2^_n_^ _groups_ of 15 elements each.
 In addition to the bucket array, there is an associated _metadata array_ with 2^_n_^
 16-byte words.

doc/unordered/changes.adoc

@@ -6,6 +6,24 @@
 :github-pr-url: https://github.com/boostorg/unordered/pull
 :cpp: C++
 
+== Release 1.83.0
+
+* Sped up iteration of open-addressing containers.
+
+== Release 1.82.0 - Major update
+
+* {cpp}03 support is planned for deprecation. Boost 1.84.0 will no longer support
+  {cpp}03 mode and {cpp}11 will become the new minimum for using the library.
+* Added node-based, open-addressing containers
+  `boost::unordered_node_map` and `boost::unordered_node_set`.
+* Extended heterogeneous lookup to more member functions as specified in
+  https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2363r5.html[P2363].
+* Replaced the previous post-mixing process for open-addressing containers with 
+  a new algorithm based on extended multiplication by a constant.
+* Fixed bug in internal emplace() impl where stack-local types were not properly
+  constructed using the Allocator of the container which breaks uses-allocator
+  construction.
+
 == Release 1.81.0 - Major update
 
 * Added fast containers `boost::unordered_flat_map` and `boost::unordered_flat_set`

doc/unordered/comparison.adoc

@@ -33,8 +33,8 @@
 
 |Iterators, pointers and references to the container's elements are never invalidated.
 |<<buckets_iterator_invalidation,Iterators can be invalidated by calls to insert or rehash>>. +
-**Closed-addressing containers:** Pointers and references to the container's elements are never invalidated. +
-**Open-addressing containers:** Pointers and references to the container's elements are invalidated when rehashing occurs.
+**Node-based containers:** Pointers and references to the container's elements are never invalidated. +
+**Flat containers:** Pointers and references to the container's elements are invalidated when rehashing occurs.
 
 |Iterators iterate through the container in the order defined by the comparison object.
 |Iterators iterate through the container in an arbitrary order, that can change as elements are inserted, although equivalent elements are always adjacent.

doc/unordered/compliance.adoc

@@ -5,9 +5,9 @@
 
 :cpp: C++
 
-== Closed-addressing containers: unordered_[multi]set, unordered_[multi]map
+== Closed-addressing containers
 
-The intent of Boost.Unordered is to provide a conformant
+`unordered_[multi]set` and `unordered_[multi]map` are intended to provide a conformant
 implementation of the {cpp}20 standard that will work with {cpp}98 upwards.
 This wide compatibility does mean some compromises have to be made.
 With a compiler and library that fully support {cpp}11, the differences should
@@ -117,27 +117,31 @@ Variadic constructor arguments for `emplace` are only used when both
 rvalue references and variadic template parameters are available.
 Otherwise `emplace` can only take up to 10 constructors arguments.
 
-== Open-addressing containers: unordered_flat_set, unordered_flat_map
+== Open-addressing containers
 
 The C++ standard does not currently provide any open-addressing container
-specification to adhere to, so `boost::unordered_flat_set` and
-`boost::unordered_flat_map` take inspiration from `std::unordered_set` and
+specification to adhere to, so `boost::unordered_flat_set`/`unordered_node_set` and
+`boost::unordered_flat_map`/`unordered_node_map` take inspiration from `std::unordered_set` and
 `std::unordered_map`, respectively, and depart from their interface where
 convenient or as dictated by their internal data structure, which is
-radically different from that imposed by the standard (closed addressing, node based).
+radically different from that imposed by the standard (closed addressing).
 
-`unordered_flat_set` and `unordered_flat_map` only work with reasonably
+Open-addressing containers provided by Boost.Unordered only work with reasonably
 compliant C++11 (or later) compilers. Language-level features such as move semantics
 and variadic template parameters are then not emulated. 
-`unordered_flat_set` and `unordered_flat_map` are fully https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer[AllocatorAware^].
+The containers are fully https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer[AllocatorAware^].
 
 The main differences with C++ unordered associative containers are:
 
-* `value_type` must be move-constructible.
-* Pointer stability is not kept under rehashing.
-* `begin()` is not constant-time.
-* `erase(iterator)` returns `void` instead of an iterator to the following element.
-* There is no API for bucket handling (except `bucket_count`) or node extraction/insertion.
-* The maximum load factor of the container is managed internally and can't be set by the user. The maximum load,
-exposed through the public function `max_load`, may decrease on erasure under high-load conditions.
+* In general:
+  ** `begin()` is not constant-time.
+  ** `erase(iterator)` returns `void` instead of an iterator to the following element.
+  ** There is no API for bucket handling (except `bucket_count`).
+  ** The maximum load factor of the container is managed internally and can't be set by the user. The maximum load,
+     exposed through the public function `max_load`, may decrease on erasure under high-load conditions.
+* Flat containers (`boost::unordered_flat_set` and `boost::unordered_flat_map`):
+  ** `value_type` must be move-constructible.
+  ** Pointer stability is not kept under rehashing.
+  ** There is no API for node extraction/insertion.
 
+//-

doc/unordered/copyright.adoc

@@ -9,10 +9,10 @@ Copyright (C) 2003, 2004 Jeremy B. Maitin-Shepard
 
 Copyright (C) 2005-2008 Daniel James
 
-Copyright (C) 2022 Christian Mazakas
+Copyright (C) 2022-2023 Christian Mazakas
 
-Copyright (C) 2022 Joaquín M López Muñoz
+Copyright (C) 2022-2023 Joaquín M López Muñoz
 
-Copyright (C) 2022 Peter Dimov
+Copyright (C) 2022-2023 Peter Dimov
 
 Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

doc/unordered/intro.adoc

@@ -106,8 +106,69 @@ namespace boost {
 }
 ----
 
-`boost::unordered_flat_set` and `boost::unordered_flat_map` require a
-reasonably compliant C++11 compiler.
+Starting in Boost 1.82, the containers `boost::unordered_node_set` and `boost::unordered_node_map`
+are introduced: they use open addressing like `boost::unordered_flat_set` and `boost::unordered_flat_map`,
+but internally store element _nodes_, like `boost::unordered_set` and `boost::unordered_map`,
+which provide stability of pointers and references to the elements:
+
+[source,c++]
+----
+// #include <boost/unordered/unordered_node_set.hpp>
+//
+// Note: no multiset version
+
+namespace boost {
+    template <
+        class Key,
+        class Hash = boost::hash<Key>,
+        class Pred = std::equal_to<Key>,
+        class Alloc = std::allocator<Key> >
+    class unordered_node_set;
+}
+----
+
+[source,c++]
+----
+// #include <boost/unordered/unordered_node_map.hpp>
+//
+// Note: no multimap version
+
+namespace boost {
+    template <
+        class Key, class Mapped,
+        class Hash = boost::hash<Key>,
+        class Pred = std::equal_to<Key>,
+        class Alloc = std::allocator<std::pair<Key const, Mapped> > >
+    class unordered_node_map;
+}
+----
+
+These are all the containers provided by Boost.Unordered:
+
+[caption=, title='Table {counter:table-counter}. Boost.Unordered containers']
+[cols="1,1,.^1", frame=all, grid=rows]
+|===
+^h|
+^h|*Node-based*
+^h|*Flat*
+
+^.^h|*Closed addressing*
+^| `boost::unordered_set` +
+`boost::unordered_map` +
+`boost::unordered_multiset` +
+`boost::unordered_multimap`
+^| 
+
+^.^h|*Open addressing*
+^| `boost::unordered_node_set` +
+`boost::unordered_node_map`
+^| `boost::unordered_flat_set` +
+`boost::unordered_flat_map`
+
+|===
+
+Closed-addressing containers are pass:[C++]98-compatible. Open-addressing containers require a
+reasonably compliant pass:[C++]11 compiler.
 
 Boost.Unordered containers are used in a similar manner to the normal associative
 containers:

doc/unordered/rationale.adoc

@@ -4,9 +4,10 @@
 
 = Implementation Rationale
 
-== boost::unordered_[multi]set and boost::unordered_[multi]map
+== Closed-addressing containers 
 
-These containers adhere to the standard requirements for unordered associative
+`boost::unordered_[multi]set` and `boost::unordered_[multi]map`
+adhere to the standard requirements for unordered associative
 containers, so the interface was fixed. But there are
 still some implementation decisions to make. The priorities are
 conformance to the standard and portability.
@@ -64,8 +65,8 @@ of bits in the hash value, so it was only used when `size_t` was 64 bit.
 
 Since release 1.79.0, https://en.wikipedia.org/wiki/Hash_function#Fibonacci_hashing[Fibonacci hashing]
 is used instead. With this implementation, the bucket number is determined
-by using `(h * m) >> (w - k)`, where `h` is the hash value, `m` is the golden
-ratio multiplied by `2^w`, `w` is the word size (32 or 64), and `2^k` is the
+by using `(h * m) >> (w - k)`, where `h` is the hash value, `m` is `2^w` divided
+by the golden ratio, `w` is the word size (32 or 64), and `2^k` is the
 number of buckets. This provides a good compromise between speed and
 distribution.
 
@@ -73,7 +74,7 @@ Since release 1.80.0, prime numbers are chosen for the number of buckets in
 tandem with sophisticated modulo arithmetic. This removes the need for "mixing"
 the result of the user's hash function as was used for release 1.79.0.
 
-== boost::unordered_flat_set and boost::unordered_flat_map
+== Open-addresing containers 
 
 The C++ standard specification of unordered associative containers impose
 severe limitations on permissible implementations, the most important being
@@ -81,29 +82,32 @@ that closed addressing is implicitly assumed. Slightly relaxing this specificati
 opens up the possibility of providing container variations taking full
 advantage of open-addressing techniques.
 
-The design of `boost::unordered_flat_set` and `boost::unordered_flat_map` has been
+The design of `boost::unordered_flat_set`/`unordered_node_set` and `boost::unordered_flat_map`/`unordered_node_map` has been
 guided by Peter Dimov's https://pdimov.github.io/articles/unordered_dev_plan.html[Development Plan for Boost.Unordered^].
 We discuss here the most relevant principles.
 
 === Hash function
 
 Given its rich functionality and cross-platform interoperability,
-`boost::hash` remains the default hash function of `boost::unordered_flat_set` and `boost::unordered_flat_map`.
+`boost::hash` remains the default hash function of open-addressing containers.
 As it happens, `boost::hash` for integral and other basic types does not possess
 the statistical properties required by open addressing; to cope with this,
 we implement a post-mixing stage:
 
-*  64-bit architectures: we use the `xmx` function defined in
-Jon Maiga's http://jonkagstrom.com/bit-mixer-construction/index.html[The construct of a bit mixer^].
-*  32-bit architectures: the mixer used was selected from a set generated with https://github.com/skeeto/hash-prospector[Hash Function Prospector^]
-as the best overall performer in our internal benchmarks. Score assigned by Hash Prospector is 333.7934929677524.
+{nbsp}{nbsp}{nbsp}{nbsp} _a_ <- _h_ *mulx* _C_, +
+{nbsp}{nbsp}{nbsp}{nbsp} _h_ <- *high*(_a_) *xor* *low*(_a_),
+
+where *mulx* is an _extended multiplication_ (128 bits in 64-bit architectures, 64 bits in 32-bit environments),
+and *high* and *low* are the upper and lower halves of an extended word, respectively.
+In 64-bit architectures, _C_ is the integer part of 2^64^&#8725;https://en.wikipedia.org/wiki/Golden_ratio[_&phi;_],
+whereas in 32 bits _C_ = 0xE817FB2Du has been obtained from https://arxiv.org/abs/2001.05304[Steele and Vigna (2021)^].
 
 When using a hash function directly suitable for open addressing, post-mixing can be opted out by via a dedicated <<hash_traits_hash_is_avalanching,`hash_is_avalanching`>>trait.
 `boost::hash` specializations for string types are marked as avalanching.
 
 === Platform interoperability
 
-The observable behavior of `boost::unordered_flat_set` and `boost::unordered_flat_map` is deterministically
+The observable behavior of `boost::unordered_flat_set`/`unordered_node_set` and `boost::unordered_flat_map`/`unordered_node_map` is deterministically
 identical across different compilers as long as their ``std::size_type``s are the same size and the user-provided
 hash function and equality predicate are also interoperable
 &#8212;this includes elements being ordered in exactly the same way for the same sequence of

doc/unordered/ref.adoc

@@ -8,3 +8,5 @@ include::unordered_multiset.adoc[]
 include::hash_traits.adoc[]
 include::unordered_flat_map.adoc[]
 include::unordered_flat_set.adoc[]
+include::unordered_node_map.adoc[]
+include::unordered_node_set.adoc[]

doc/unordered/unordered_flat_map.adoc

@@ -98,9 +98,8 @@ namespace boost {
     xref:#unordered_flat_map_destructor[~unordered_flat_map]();
     unordered_flat_map& xref:#unordered_flat_map_copy_assignment[operator++=++](const unordered_flat_map& other);
     unordered_flat_map& xref:#unordered_flat_map_move_assignment[operator++=++](unordered_flat_map&& other)
-      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
-               boost::is_nothrow_move_assignable_v<Hash> &&
-               boost::is_nothrow_move_assignable_v<Pred>);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
+              boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
     unordered_flat_map& xref:#unordered_flat_map_initializer_list_assignment[operator++=++](std::initializer_list<value_type>);
     allocator_type xref:#unordered_flat_map_get_allocator[get_allocator]() const noexcept;
 
@@ -135,28 +134,35 @@ namespace boost {
       std::pair<iterator, bool> xref:#unordered_flat_map_try_emplace[try_emplace](const key_type& k, Args&&... args);
     template<class... Args>
       std::pair<iterator, bool> xref:#unordered_flat_map_try_emplace[try_emplace](key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      std::pair<iterator, bool> xref:#unordered_flat_map_try_emplace[try_emplace](K&& k, Args&&... args);
     template<class... Args>
       iterator xref:#unordered_flat_map_try_emplace_with_hint[try_emplace](const_iterator hint, const key_type& k, Args&&... args);
     template<class... Args>
       iterator xref:#unordered_flat_map_try_emplace_with_hint[try_emplace](const_iterator hint, key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      iterator xref:#unordered_flat_map_try_emplace_with_hint[try_emplace](const_iterator hint, K&& k, Args&&... args);
     template<class M>
       std::pair<iterator, bool> xref:#unordered_flat_map_insert_or_assign[insert_or_assign](const key_type& k, M&& obj);
     template<class M>
       std::pair<iterator, bool> xref:#unordered_flat_map_insert_or_assign[insert_or_assign](key_type&& k, M&& obj);
+    template<class K, class M>
+      std::pair<iterator, bool> xref:#unordered_flat_map_insert_or_assign[insert_or_assign](K&& k, M&& obj);
     template<class M>
       iterator xref:#unordered_flat_map_insert_or_assign_with_hint[insert_or_assign](const_iterator hint, const key_type& k, M&& obj);
     template<class M>
       iterator xref:#unordered_flat_map_insert_or_assign_with_hint[insert_or_assign](const_iterator hint, key_type&& k, M&& obj);
+    template<class K, class M>
+      iterator xref:#unordered_flat_map_insert_or_assign_with_hint[insert_or_assign](const_iterator hint, K&& k, M&& obj);
 
     void      xref:#unordered_flat_map_erase_by_position[erase](iterator position);
     void      xref:#unordered_flat_map_erase_by_position[erase](const_iterator position);
     size_type xref:#unordered_flat_map_erase_by_key[erase](const key_type& k);
-    template<class K> size_type xref:#unordered_flat_map_transparent_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_flat_map_erase_by_key[erase](K&& k);
     iterator  xref:#unordered_flat_map_erase_range[erase](const_iterator first, const_iterator last);
     void      xref:#unordered_flat_map_swap[swap](unordered_flat_map& other)
-      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
-               boost::is_nothrow_swappable_v<Hash> &&
-               boost::is_nothrow_swappable_v<Pred>);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
+               boost::allocator_traits<Allocator>::propagate_on_container_swap::value);
     void      xref:#unordered_flat_map_clear[clear]() noexcept;
 
     template<class H2, class P2>
@@ -191,8 +197,11 @@ namespace boost {
     // element access
     mapped_type& xref:#unordered_flat_map_operator[operator[+]+](const key_type& k);
     mapped_type& xref:#unordered_flat_map_operator[operator[+]+](key_type&& k);
+    template<class K> mapped_type& xref:#unordered_flat_map_operator[operator[+]+](K&& k);
     mapped_type& xref:#unordered_flat_map_at[at](const key_type& k);
     const mapped_type& xref:#unordered_flat_map_at[at](const key_type& k) const;
+    template<class K> mapped_type& xref:#unordered_flat_map_at[at](const K& k);
+    template<class K> const mapped_type& xref:#unordered_flat_map_at[at](const K& k) const;
 
     // bucket interface
     size_type xref:#unordered_flat_map_bucket_count[bucket_count]() const noexcept;
@@ -606,11 +615,10 @@ Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInse
 ==== Move Assignment
 ```c++
 unordered_flat_map& operator=(unordered_flat_map&& other)
-  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
-           boost::is_nothrow_move_assignable_v<Hash> &&
-           boost::is_nothrow_move_assignable_v<Pred>);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
+           boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
 ```
-The move assignment operator. Destroys previously existing elements, move-assigns the hash function and predicate from `other`,
+The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`,
 and move-assigns the allocator from `other` if `Alloc::propagate_on_container_move_assignment` exists and `Alloc::propagate_on_container_move_assignment::value` is `true`.
 If at this point the allocator is equal to `other.get_allocator()`, the internal bucket array of `other` is transferred directly to the new container;
 otherwise, inserts move-constructed copies of the elements of `other`.
@@ -863,6 +871,8 @@ template<class... Args>
   std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
   std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
+template<class K, class... Args>
+  std::pair<iterator, bool> try_emplace(K&& k, Args&&... args);
 ```
 
 Inserts a new node into the container if there is no existing element with key `k` contained within it.
@@ -879,15 +889,23 @@ if there is an element with an equivalent key; otherwise, the construction is of
 +
 --
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<Args>(args)...))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<Args>(args)...))
 ```
 
 unlike xref:#unordered_flat_map_emplace[emplace], which simply forwards all arguments to ``value_type``'s constructor.
 
 Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load.
 
+The `template <class K, class... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
 --
 
 ---
@@ -898,6 +916,8 @@ template<class... Args>
   iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 template<class... Args>
   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
+template<class K, class... Args>
+  iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
 ```
 
 Inserts a new node into the container if there is no existing element with key `k` contained within it.
@@ -914,15 +934,23 @@ if there is an element with an equivalent key; otherwise, the construction is of
 +
 --
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<Args>(args)...))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<Args>(args)...))
 ```
 
 unlike xref:#unordered_flat_map_emplace_hint[emplace_hint], which simply forwards all arguments to ``value_type``'s constructor.
 
 Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load.
 
+The `template <class K, class... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
 --
 
 ---
@@ -933,6 +961,8 @@ template<class M>
   std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
 template<class M>
   std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+template<class K, class M>
+  std::pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
 ```
 
 Inserts a new element into the container or updates an existing one by assigning to the contained value.
@@ -941,9 +971,15 @@ If there is an element with key `k`, then it is updated by assigning `boost::for
 
 If there is no such element, it is added to the container as:
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<M>(obj)))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<M>(obj)))
 ```
 
 [horizontal]
@@ -951,7 +987,9 @@ Returns:;; The `bool` component of the return type is `true` if an insert took p
 +
 If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
 Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
-Notes:;; Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load. +
+Notes:;; Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load.  +
++
+The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -961,6 +999,8 @@ template<class M>
   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 template<class M>
   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
+template<class K, class M>
+  iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
 ```
 
 Inserts a new element into the container or updates an existing one by assigning to the contained value.
@@ -969,9 +1009,15 @@ If there is an element with key `k`, then it is updated by assigning `boost::for
 
 If there is no such element, it is added to the container as:
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<M>(obj)))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<M>(obj)))
 ```
 
 `hint` is a suggestion to where the element should be inserted. This implementation ignores it.
@@ -979,7 +1025,9 @@ value_type(std::piecewise_construct,
 [horizontal]
 Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
 Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
-Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. +
++
+The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1001,28 +1049,15 @@ Throws:;; Nothing.
 ==== Erase by Key
 ```c++
 size_type erase(const key_type& k);
-```
-
-Erase all elements with key equivalent to `k`.
-
-[horizontal]
-Returns:;; The number of elements erased.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-
----
-
-==== Transparent Erase by Key
-```c++
 template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; The number of elements erased.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1043,9 +1078,8 @@ Throws:;; Nothing in this implementation (neither the `hasher` nor the `key_equa
 ==== swap
 ```c++
 void swap(unordered_flat_map& other)
-  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
-           boost::is_nothrow_swappable_v<Hash> &&
-           boost::is_nothrow_swappable_v<Pred>);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
+           boost::allocator_traits<Allocator>::propagate_on_container_swap::value);
 ```
 
 Swaps the contents of the container with the parameter.
@@ -1176,13 +1210,16 @@ Notes:;; The `template <typename K>` overloads only participate in overload reso
 ```c++
 mapped_type& operator[](const key_type& k);
 mapped_type& operator[](key_type&& k);
+template<class K> mapped_type& operator[](K&& k);
 ```
 
 [horizontal]
 Effects:;; If the container does not already contain an element with a key equivalent to `k`, inserts the value `std::pair<key_type const, mapped_type>(k, mapped_type())`.
 Returns:;; A reference to `x.second` where `x` is the element already in the container, or the newly inserted element with a key equivalent to `k`.
 Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
-Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. +
++
+The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1190,11 +1227,14 @@ Notes:;; Can invalidate iterators, pointers and references, but only if the inse
 ```c++
 mapped_type& at(const key_type& k);
 const mapped_type& at(const key_type& k) const;
+template<class K> mapped_type& at(const K& k);
+template<class K> const mapped_type& at(const K& k) const;
 ```
 
 [horizontal]
 Returns:;; A reference to `x.second` where `x` is the (unique) element whose key is equivalent to `k`.
 Throws:;; An exception object of type `std::out_of_range` if no such element is present.
+Notes:;; The `template<class K>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 

doc/unordered/unordered_flat_set.adoc

@@ -93,9 +93,8 @@ namespace boost {
     xref:#unordered_flat_set_destructor[~unordered_flat_set]();
     unordered_flat_set& xref:#unordered_flat_set_copy_assignment[operator++=++](const unordered_flat_set& other);
     unordered_flat_set& xref:#unordered_flat_set_move_assignment[operator++=++](unordered_flat_set&& other)
-      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
-               boost::is_nothrow_move_assignable_v<Hash> &&
-               boost::is_nothrow_move_assignable_v<Pred>);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
+               boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
     unordered_flat_set& xref:#unordered_flat_set_initializer_list_assignment[operator++=++](std::initializer_list<value_type>);
     allocator_type xref:#unordered_flat_set_get_allocator[get_allocator]() const noexcept;
 
@@ -117,20 +116,21 @@ namespace boost {
     template<class... Args> iterator xref:#unordered_flat_set_emplace_hint[emplace_hint](const_iterator position, Args&&... args);
     std::pair<iterator, bool> xref:#unordered_flat_set_copy_insert[insert](const value_type& obj);
     std::pair<iterator, bool> xref:#unordered_flat_set_move_insert[insert](value_type&& obj);
-    iterator       xref:#unordered_flat_set_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
-    iterator       xref:#unordered_flat_set_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
+    template<class K> std::pair<iterator, bool> xref:#unordered_flat_set_transparent_insert[insert](K&& k);
+    iterator xref:#unordered_flat_set_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
+    iterator xref:#unordered_flat_set_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
+    template<class K> iterator xref:#unordered_flat_set_transparent_insert_with_hint[insert](const_iterator hint, K&& k);
     template<class InputIterator> void xref:#unordered_flat_set_insert_iterator_range[insert](InputIterator first, InputIterator last);
     void xref:#unordered_flat_set_insert_initializer_list[insert](std::initializer_list<value_type>);
 
     void      xref:#unordered_flat_set_erase_by_position[erase](iterator position);
     void      xref:#unordered_flat_set_erase_by_position[erase](const_iterator position);
     size_type xref:#unordered_flat_set_erase_by_key[erase](const key_type& k);
-    template<class K> size_type xref:#unordered_flat_set_transparent_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_flat_set_erase_by_key[erase](K&& k);
     iterator  xref:#unordered_flat_set_erase_range[erase](const_iterator first, const_iterator last);
     void      xref:#unordered_flat_set_swap[swap](unordered_flat_set& other)
-      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
-               boost::is_nothrow_swappable_v<Hash> &&
-               boost::is_nothrow_swappable_v<Pred>);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
+               boost::allocator_traits<Allocator>::propagate_on_container_swap::value);
     void      xref:#unordered_flat_set_clear[clear]() noexcept;
 
     template<class H2, class P2>
@@ -565,11 +565,10 @@ Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/CopyInse
 ==== Move Assignment
 ```c++
 unordered_flat_set& operator=(unordered_flat_set&& other)
-  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
-           boost::is_nothrow_move_assignable_v<Hash> &&
-           boost::is_nothrow_move_assignable_v<Pred>);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
+           boost::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
 ```
-The move assignment operator. Destroys previously existing elements, move-assigns the hash function and predicate from `other`,
+The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`,
 and move-assigns the allocator from `other` if `Alloc::propagate_on_container_move_assignment` exists and `Alloc::propagate_on_container_move_assignment::value` is `true`.
 If at this point the allocator is equal to `other.get_allocator()`, the internal bucket array of `other` is transferred directly to the new container;
 otherwise, inserts move-constructed copies of the elements of `other`.
@@ -739,6 +738,25 @@ Notes:;; Can invalidate iterators, pointers and references, but only if the inse
 
 ---
 
+==== Transparent Insert
+```c++
+template<class K> std::pair<iterator, bool> insert(K&& k);
+```
+
+Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container with an equivalent key.
+
+[horizontal]
+Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`.
+Returns:;; The bool component of the return type is true if an insert took place. +
++
+If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
+Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. +
++
+This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
+---
+
 ==== Copy Insert with Hint
 ```c++
 iterator insert(const_iterator hint, const value_type& obj);
@@ -776,6 +794,27 @@ Notes:;; Can invalidate iterators, pointers and references, but only if the inse
 
 ---
 
+==== Transparent Insert with Hint
+```c++
+template<class K> std::pair<iterator, bool> insert(const_iterator hint, K&& k);
+```
+
+Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container with an equivalent key.
+
+`hint` is a suggestion to where the element should be inserted. This implementation ignores it.
+
+[horizontal]
+Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`.
+Returns:;; The bool component of the return type is true if an insert took place. +
++
+If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
+Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. +
++
+This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
+---
+
 ==== Insert Iterator Range
 ```c++
 template<class InputIterator> void insert(InputIterator first, InputIterator last);
@@ -821,28 +860,15 @@ Throws:;; Nothing.
 ==== Erase by Key
 ```c++
 size_type erase(const key_type& k);
-```
-
-Erase all elements with key equivalent to `k`.
-
-[horizontal]
-Returns:;; The number of elements erased.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-
----
-
-==== Transparent Erase by Key
-```c++
 template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; The number of elements erased.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -863,9 +889,8 @@ Throws:;; Nothing in this implementation (neither the `hasher` nor the `key_equa
 ==== swap
 ```c++
 void swap(unordered_flat_set& other)
-  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
-           boost::is_nothrow_swappable_v<Hash> &&
-           boost::is_nothrow_swappable_v<Pred>);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
+           boost::allocator_traits<Allocator>::propagate_on_container_swap::value);
 ```
 
 Swaps the contents of the container with the parameter.

doc/unordered/unordered_map.adoc

@@ -113,29 +113,37 @@ namespace boost {
       std::pair<iterator, bool> xref:#unordered_map_try_emplace[try_emplace](const key_type& k, Args&&... args);
     template<class... Args>
       std::pair<iterator, bool> xref:#unordered_map_try_emplace[try_emplace](key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      std::pair<iterator, bool> xref:#unordered_map_try_emplace[try_emplace](K&& k, Args&&... args);
     template<class... Args>
       iterator xref:#unordered_map_try_emplace_with_hint[try_emplace](const_iterator hint, const key_type& k, Args&&... args);
     template<class... Args>
       iterator xref:#unordered_map_try_emplace_with_hint[try_emplace](const_iterator hint, key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      iterator xref:#unordered_map_try_emplace_with_hint[try_emplace](const_iterator hint, K&& k, Args&&... args);
     template<class M>
       std::pair<iterator, bool> xref:#unordered_map_insert_or_assign[insert_or_assign](const key_type& k, M&& obj);
     template<class M>
       std::pair<iterator, bool> xref:#unordered_map_insert_or_assign[insert_or_assign](key_type&& k, M&& obj);
+    template<class K, class M>
+      std::pair<iterator, bool> xref:#unordered_map_insert_or_assign[insert_or_assign](K&& k, M&& obj);
     template<class M>
       iterator xref:#unordered_map_insert_or_assign_with_hint[insert_or_assign](const_iterator hint, const key_type& k, M&& obj);
     template<class M>
       iterator xref:#unordered_map_insert_or_assign_with_hint[insert_or_assign](const_iterator hint, key_type&& k, M&& obj);
+    template<class K, class M>
+      iterator xref:#unordered_map_insert_or_assign_with_hint[insert_or_assign](const_iterator hint, K&& k, M&& obj);
 
     node_type xref:#unordered_map_extract_by_iterator[extract](const_iterator position);
     node_type xref:#unordered_map_extract_by_key[extract](const key_type& k);
-    template<class K> node_type xref:#unordered_map_transparent_extract_by_key[extract](K&& k);
+    template<class K> node_type xref:#unordered_map_extract_by_key[extract](K&& k);
     insert_return_type xref:#unordered_map_insert_with_node_handle[insert](node_type&& nh);
     iterator           xref:#unordered_map_insert_with_hint_and_node_handle[insert](const_iterator hint, node_type&& nh);
 
     iterator  xref:#unordered_map_erase_by_position[erase](iterator position);
     iterator  xref:#unordered_map_erase_by_position[erase](const_iterator position);
     size_type xref:#unordered_map_erase_by_key[erase](const key_type& k);
-    template<class K> size_type xref:#unordered_map_transparent_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_map_erase_by_key[erase](K&& k);
     iterator  xref:#unordered_map_erase_range[erase](const_iterator first, const_iterator last);
     void      xref:#unordered_map_quick_erase[quick_erase](const_iterator position);
     void      xref:#unordered_map_erase_return_void[erase_return_void](const_iterator position);
@@ -187,14 +195,18 @@ namespace boost {
     // element access
     mapped_type& xref:#unordered_map_operator[operator[+]+](const key_type& k);
     mapped_type& xref:#unordered_map_operator[operator[+]+](key_type&& k);
+    template<class K> mapped_type& xref:#unordered_map_operator[operator[+]+](K&& k);
     mapped_type& xref:#unordered_map_at[at](const key_type& k);
     const mapped_type& xref:#unordered_map_at[at](const key_type& k) const;
+    template<class K> mapped_type& xref:#unordered_map_at[at](const K& k);
+    template<class K> const mapped_type& xref:#unordered_map_at[at](const K& k) const;
 
     // bucket interface
     size_type xref:#unordered_map_bucket_count[bucket_count]() const noexcept;
     size_type xref:#unordered_map_max_bucket_count[max_bucket_count]() const noexcept;
     size_type xref:#unordered_map_bucket_size[bucket_size](size_type n) const;
     size_type xref:#unordered_map_bucket[bucket](const key_type& k) const;
+    template<class K> size_type xref:#unordered_map_bucket[bucket](const K& k) const;
     local_iterator xref:#unordered_map_begin_2[begin](size_type n);
     const_local_iterator xref:#unordered_map_begin_2[begin](size_type n) const;
     local_iterator xref:#unordered_map_end_2[end](size_type n);
@@ -997,6 +1009,8 @@ template<class... Args>
   std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
   std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
+template <class K, class... Args>
+  std::pair<iterator, bool> try_emplace(K&& k, Args&&... args)
 ```
 
 Inserts a new node into the container if there is no existing element with key `k` contained within it.
@@ -1012,9 +1026,15 @@ Notes:;; This function is similiar to xref:#unordered_map_emplace[emplace] excep
 +
 --
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<Args>(args)...))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<Args>(args)...))
 ```
 
 instead of xref:#unordered_map_emplace[emplace] which simply forwards all arguments to ``value_type``'s constructor.
@@ -1023,6 +1043,8 @@ Can invalidate iterators, but only if the insert causes the load factor to be gr
 
 Pointers and references to elements are never invalidated.
 
+The `template <class K, class... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
 If the compiler doesn't support variadic template arguments or rvalue references, this is emulated for up to `10` arguments, with no support for rvalue references or move semantics.
 
 Since existing `std::pair` implementations don't support `std::piecewise_construct` this emulates it, but using `boost::unordered::piecewise_construct`.
@@ -1036,6 +1058,8 @@ template<class... Args>
   iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 template<class... Args>
   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
+template<class K, class... Args>
+  iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
 ```
 
 Inserts a new node into the container if there is no existing element with key `k` contained within it.
@@ -1051,9 +1075,15 @@ Notes:;; This function is similiar to xref:#unordered_map_emplace_hint[emplace_h
 +
 --
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<Args>(args)...))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<Args>(args)...))
 ```
 
 instead of xref:#unordered_map_emplace_hint[emplace_hint] which simply forwards all arguments to ``value_type``'s constructor.
@@ -1064,6 +1094,8 @@ Can invalidate iterators, but only if the insert causes the load factor to be gr
 
 Pointers and references to elements are never invalidated.
 
+The `template <class K, class... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
 If the compiler doesn't support variadic template arguments or rvalue references, this is emulated for up to `10` arguments, with no support for rvalue references or move semantics.
 
 Since existing `std::pair` implementations don't support `std::piecewise_construct` this emulates it, but using `boost::unordered::piecewise_construct`.
@@ -1077,6 +1109,8 @@ template<class M>
   std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
 template<class M>
   std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+template<class K, class M>
+  std::pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
 ```
 
 Inserts a new element into the container or updates an existing one by assigning to the contained value.
@@ -1085,9 +1119,15 @@ If there is an element with key `k`, then it is updated by assigning `boost::for
 
 If there is no such element, it is added to the container as:
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<M>(obj)))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<M>(obj)))
 ```
 
 [horizontal]
@@ -1097,7 +1137,9 @@ If an insert took place, then the iterator points to the newly inserted element.
 Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
 Notes:;; Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. +
 +
-Pointers and references to elements are never invalidated.
+Pointers and references to elements are never invalidated. +
++
+The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1107,6 +1149,8 @@ template<class M>
   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 template<class M>
   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
+template<class K, class M>
+  iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
 ```
 
 Inserts a new element into the container or updates an existing one by assigning to the contained value.
@@ -1115,9 +1159,15 @@ If there is an element with key `k`, then it is updated by assigning `boost::for
 
 If there is no such element, it is added to the container as:
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<M>(obj)))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<M>(obj)))
 ```
 
 `hint` is a suggestion to where the element should be inserted.
@@ -1129,7 +1179,9 @@ Notes:;; The standard is fairly vague on the meaning of the hint. But the only p
 +
 Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. +
 +
-Pointers and references to elements are never invalidated.
+Pointers and references to elements are never invalidated. +
++
+The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1149,30 +1201,17 @@ Notes:;; A node extracted using this method can be inserted into a compatible `u
 ==== Extract by Key
 ```c++
 node_type extract(const key_type& k);
-```
-
-Removes an element with key equivalent to `k`.
-
-[horizontal]
-Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-Notes:;; A node extracted using this method can be inserted into a compatible `unordered_multimap`.
-
----
-
-==== Transparent Extract by Key
-```c++
 template<class K> node_type extract(K&& k);
 ```
 
 Removes an element with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-Notes:;; A node extracted using this method can be inserted into a compatible `unordered_multimap`.
+Notes:;; A node extracted using this method can be inserted into a compatible `unordered_multimap`. +
++
+The `template<class K>`  overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1251,28 +1290,15 @@ Notes:;; In older versions this could be inefficient because it had to search th
 ==== Erase by Key
 ```c++
 size_type erase(const key_type& k);
-```
-
-Erase all elements with key equivalent to `k`.
-
-[horizontal]
-Returns:;; The number of elements erased.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-
----
-
-==== Transparent Erase by Key
-```c++
 template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; The number of elements erased.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1490,6 +1516,7 @@ Notes:;; The `template <typename K>` overloads only participate in overload reso
 ```c++
 mapped_type& operator[](const key_type& k);
 mapped_type& operator[](key_type&& k);
+template<class K> mapped_type& operator[](K&& k);
 ```
 
 [horizontal]
@@ -1498,7 +1525,9 @@ Returns:;; A reference to `x.second` where `x` is the element already in the con
 Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
 Notes:;; Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. +
 +
-Pointers and references to elements are never invalidated.
+Pointers and references to elements are never invalidated. +
++
+The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1506,11 +1535,14 @@ Pointers and references to elements are never invalidated.
 ```c++
 mapped_type& at(const key_type& k);
 const mapped_type& at(const key_type& k) const;
+template<class K> mapped_type& at(const K& k);
+template<class K> const mapped_type& at(const K& k) const;
 ```
 
 [horizontal]
 Returns:;; A reference to `x.second` where `x` is the (unique) element whose key is equivalent to `k`.
 Throws:;; An exception object of type `std::out_of_range` if no such element is present.
+Notes:;; The `template<class K>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1550,11 +1582,13 @@ Returns:;; The number of elements in bucket `n`.
 ==== bucket
 ```c++
 size_type bucket(const key_type& k) const;
+template<class K> size_type bucket(const K& k) const;
 ```
 
 [horizontal]
 Returns:;; The index of the bucket which would contain an element with key `k`.
 Postconditions:;; The return value is less than `bucket_count()`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 

doc/unordered/unordered_multimap.adoc

@@ -111,14 +111,14 @@ namespace boost {
 
     node_type xref:#unordered_multimap_extract_by_iterator[extract](const_iterator position);
     node_type xref:#unordered_multimap_extract_by_key[extract](const key_type& k);
-    template<class K> node_type xref:#unordered_multimap_transparent_extract_by_key[extract](K&& k);
+    template<class K> node_type xref:#unordered_multimap_extract_by_key[extract](K&& k);
     iterator xref:#unordered_multimap_insert_with_node_handle[insert](node_type&& nh);
     iterator xref:#unordered_multimap_insert_with_hint_and_node_handle[insert](const_iterator hint, node_type&& nh);
 
     iterator  xref:#unordered_multimap_erase_by_position[erase](iterator position);
     iterator  xref:#unordered_multimap_erase_by_position[erase](const_iterator position);
     size_type xref:#unordered_multimap_erase_by_key[erase](const key_type& k);
-    template<class K> size_type xref:#unordered_multimap_transparent_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_multimap_erase_by_key[erase](K&& k);
     iterator  xref:#unordered_multimap_erase_range[erase](const_iterator first, const_iterator last);
     void      xref:#unordered_multimap_quick_erase[quick_erase](const_iterator position);
     void      xref:#unordered_multimap_erase_return_void[erase_return_void](const_iterator position);
@@ -172,6 +172,7 @@ namespace boost {
     size_type xref:#unordered_multimap_max_bucket_count[max_bucket_count]() const noexcept;
     size_type xref:#unordered_multimap_bucket_size[bucket_size](size_type n) const;
     size_type xref:#unordered_multimap_bucket[bucket](const key_type& k) const;
+    template<class K> size_type xref:#unordered_multimap_bucket[bucket](const K& k) const;
     local_iterator xref:#unordered_multimap_begin_2[begin](size_type n);
     const_local_iterator xref:#unordered_multimap_begin_2[begin](size_type n) const;
     local_iterator xref:#unordered_multimap_end_2[end](size_type n);
@@ -964,30 +965,17 @@ Notes:;; A node extracted using this method can be inserted into a compatible `u
 ==== Extract by Key
 ```c++
 node_type extract(const key_type& k);
-```
-
-Removes an element with key equivalent to `k`.
-
-[horizontal]
-Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-Notes:;; A node extracted using this method can be inserted into a compatible `unordered_map`.
-
----
-
-==== Transparent Extract by Key
-```c++
 template<class K> node_type extract(K&& k);
 ```
 
 Removes an element with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-Notes:;; A node extracted using this method can be inserted into a compatible `unordered_map`.
+Notes:;; A node extracted using this method can be inserted into a compatible `unordered_map`. +
++
+The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1060,28 +1048,15 @@ Notes:;; In older versions this could be inefficient because it had to search th
 ==== Erase by Key
 ```c++
 size_type erase(const key_type& k);
-```
-
-Erase all elements with key equivalent to `k`.
-
-[horizontal]
-Returns:;; The number of elements erased.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-
----
-
-==== Transparent Erase by Key
-```c++
 template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; The number of elements erased.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1330,11 +1305,13 @@ Returns:;; The number of elements in bucket `n`.
 ==== bucket
 ```c++
 size_type bucket(const key_type& k) const;
+template<class K> size_type bucket(const K& k) const;
 ```
 
 [horizontal]
 Returns:;; The index of the bucket which would contain an element with key `k`.
 Postconditions:;; The return value is less than `bucket_count()`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 

doc/unordered/unordered_multiset.adoc

@@ -107,14 +107,14 @@ namespace boost {
 
     node_type xref:#unordered_multiset_extract_by_iterator[extract](const_iterator position);
     node_type xref:#unordered_multiset_extract_by_value[extract](const key_type& k);
-    template<class K> node_type xref:#unordered_multiset_transparent_extract_by_value[extract](K&& k);
+    template<class K> node_type xref:#unordered_multiset_extract_by_value[extract](K&& k);
     iterator xref:#unordered_multiset_insert_with_node_handle[insert](node_type&& nh);
     iterator xref:#unordered_multiset_insert_with_hint_and_node_handle[insert](const_iterator hint, node_type&& nh);
 
     iterator  xref:#unordered_multiset_erase_by_position[erase](iterator position);
     iterator  xref:#unordered_multiset_erase_by_position[erase](const_iterator position);
     size_type xref:#unordered_multiset_erase_by_value[erase](const key_type& k);
-    template<class K> size_type xref:#unordered_multiset_transparent_erase_by_value[erase](K&& x);
+    template<class K> size_type xref:#unordered_multiset_erase_by_value[erase](K&& x);
     iterator  xref:#unordered_multiset_erase_range[erase](const_iterator first, const_iterator last);
     void      xref:#unordered_multiset_quick_erase[quick_erase](const_iterator position);
     void      xref:#unordered_multiset_erase_return_void[erase_return_void](const_iterator position);
@@ -168,6 +168,7 @@ namespace boost {
     size_type xref:#unordered_multiset_max_bucket_count[max_bucket_count]() const noexcept;
     size_type xref:#unordered_multiset_bucket_size[bucket_size](size_type n) const;
     size_type xref:#unordered_multiset_bucket[bucket](const key_type& k) const;
+    template<class K> size_type xref:#unordered_multiset_bucket[bucket](const K& k) const;
     local_iterator xref:#unordered_multiset_begin_2[begin](size_type n);
     const_local_iterator xref:#unordered_multiset_begin_2[begin](size_type n) const;
     local_iterator xref:#unordered_multiset_end_2[end](size_type n);
@@ -922,6 +923,7 @@ Notes:;; A node extracted using this method can be inserted into a compatible `u
 ==== Extract by Value
 ```c++
 node_type extract(const key_type& k);
+template<class K> node_type extract(K&& k);
 ```
 
 Removes an element with key equivalent to `k`.
@@ -929,23 +931,9 @@ Removes an element with key equivalent to `k`.
 [horizontal]
 Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-Notes:;; A node extracted using this method can be inserted into a compatible `unordered_set`.
-
----
-
-==== Transparent Extract by Value
-```c++
-template<class K> node_type extract(K&& k);
-```
-
-Removes an element with key equivalent to `k`.
-
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
-[horizontal]
-Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.[horizontal]
-Notes:;; A node extracted using this method can be inserted into a compatible `unordered_set`.
+Notes:;; A node extracted using this method can be inserted into a compatible `unordered_set`. +
++
+The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1018,28 +1006,15 @@ Notes:;; In older versions this could be inefficient because it had to search th
 ==== Erase by Value
 ```c++
 size_type erase(const key_type& k);
-```
-
-Erase all elements with key equivalent to `k`.
-
-[horizontal]
-Returns:;; The number of elements erased.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-
----
-
-==== Transparent Erase by Value
-```c++
 template<class K> size_type erase(K&& x);
 ```
 
 Erase all elements with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; The number of elements erased.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1288,11 +1263,13 @@ Returns:;; The number of elements in bucket `n`.
 ==== bucket
 ```c++
 size_type bucket(const key_type& k) const;
+template<class K> size_type bucket(const K& k) const;
 ```
 
 [horizontal]
 Returns:;; The index of the bucket which would contain an element with key `k`.
 Postconditions:;; The return value is less than `bucket_count()`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 

doc/unordered/unordered_set.adoc

@@ -100,21 +100,23 @@ namespace boost {
     template<class... Args> iterator xref:#unordered_set_emplace_hint[emplace_hint](const_iterator position, Args&&... args);
     std::pair<iterator, bool> xref:#unordered_set_copy_insert[insert](const value_type& obj);
     std::pair<iterator, bool> xref:#unordered_set_move_insert[insert](value_type&& obj);
+    template<class K> std::pair<iterator, bool> xref:#unordered_set_transparent_insert[insert](K&& k);
     iterator xref:#unordered_set_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
     iterator xref:#unordered_set_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
+    template<class K> iterator xref:#unordered_set_transparent_insert_with_hint[insert](const_iterator hint, K&& k);
     template<class InputIterator> void xref:#unordered_set_insert_iterator_range[insert](InputIterator first, InputIterator last);
     void xref:#unordered_set_insert_initializer_list[insert](std::initializer_list<value_type>);
 
     node_type xref:#unordered_set_extract_by_iterator[extract](const_iterator position);
     node_type xref:#unordered_set_extract_by_value[extract](const key_type& k);
-    template<class K> node_type xref:#unordered_set_transparent_extract_by_value[extract](K&& k);
+    template<class K> node_type xref:#unordered_set_extract_by_value[extract](K&& k);
     insert_return_type xref:#unordered_set_insert_with_node_handle[insert](node_type&& nh);
     iterator           xref:#unordered_set_insert_with_hint_and_node_handle[insert](const_iterator hint, node_type&& nh);
 
     iterator  xref:#unordered_set_erase_by_position[erase](iterator position);
     iterator  xref:#unordered_set_erase_by_position[erase](const_iterator position);
     size_type xref:#unordered_set_erase_by_value[erase](const key_type& k);
-    template<class K> size_type xref:#unordered_set_transparent_erase_by_value[erase](K&& k);
+    template<class K> size_type xref:#unordered_set_erase_by_value[erase](K&& k);
     iterator  xref:#unordered_set_erase_range[erase](const_iterator first, const_iterator last);
     void      xref:#unordered_set_quick_erase[quick_erase](const_iterator position);
     void      xref:#unordered_set_erase_return_void[erase_return_void](const_iterator position);
@@ -168,6 +170,7 @@ namespace boost {
     size_type xref:#unordered_set_max_bucket_count[max_bucket_count]() const noexcept;
     size_type xref:#unordered_set_bucket_size[bucket_size](size_type n) const;
     size_type xref:#unordered_set_bucket[bucket](const key_type& k) const;
+    template<class K> size_type xref:#unordered_set_bucket[bucket](const K& k) const;
     local_iterator xref:#unordered_set_begin_2[begin](size_type n);
     const_local_iterator xref:#unordered_set_begin_2[begin](size_type n) const;
     local_iterator xref:#unordered_set_end_2[end](size_type n);
@@ -847,6 +850,27 @@ Pointers and references to elements are never invalidated.
 
 ---
 
+==== Transparent Insert
+```c++
+template<class K> std::pair<iterator, bool> insert(K&& k);
+```
+
+Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container with an equivalent key.
+
+[horizontal]
+Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`.
+Returns:;; The bool component of the return type is true if an insert took place. +
++
+If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
+Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
+Notes:;; Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. +
++
+Pointers and references to elements are never invalidated. +
++
+This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
+---
+
 ==== Copy Insert with Hint
 ```c++
 iterator insert(const_iterator hint, const value_type& obj);
@@ -888,6 +912,29 @@ Pointers and references to elements are never invalidated.
 
 ---
 
+==== Transparent Insert with Hint
+```c++
+template<class K> iterator insert(const_iterator hint, K&& k);
+```
+
+Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container with an equivalent key.
+
+`hint` is a suggestion to where the element should be inserted.
+
+[horizontal]
+Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`.
+Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
+Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
+Notes:;; The standard is fairly vague on the meaning of the hint. But the only practical way to use it, and the only way that Boost.Unordered supports is to point to an existing element with the same key. +
++
+Can invalidate iterators, but only if the insert causes the load factor to be greater to or equal to the maximum load factor. +
++
+Pointers and references to elements are never invalidated. +
++
+This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
+---
+
 ==== Insert Iterator Range
 ```c++
 template<class InputIterator> void insert(InputIterator first, InputIterator last);
@@ -936,30 +983,17 @@ Notes:;; In C++17 a node extracted using this method can be inserted into a comp
 ==== Extract by Value
 ```c++
 node_type extract(const key_type& k);
-```
-
-Removes an element with key equivalent to `k`.
-
-[horizontal]
-Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-Notes:;; In C++17 a node extracted using this method can be inserted into a compatible `unordered_multiset`, but that is not supported yet.
-
----
-
-==== Transparent Extract by Value
-```c++
 template<class K> node_type extract(K&& k);
 ```
 
 Removes an element with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; A `node_type` owning the element if found, otherwise an empty `node_type`.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-Notes:;; In C++17 a node extracted using this method can be inserted into a compatible `unordered_multiset`, but that is not supported yet.
+Notes:;; In C++17 a node extracted using this method can be inserted into a compatible `unordered_multiset`, but that is not supported yet. +
++
+The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1038,28 +1072,15 @@ Notes:;; In older versions this could be inefficient because it had to search th
 ==== Erase by Value
 ```c++
 size_type erase(const key_type& k);
-```
-
-Erase all elements with key equivalent to `k`.
-
-[horizontal]
-Returns:;; The number of elements erased.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-
----
-
-==== Transparent Erase by Value
-```c++
 template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; The number of elements erased.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1309,11 +1330,13 @@ Returns:;; The number of elements in bucket `n`.
 ==== bucket
 ```c++
 size_type bucket(const key_type& k) const;
+template<class K> size_type bucket(const K& k) const;
 ```
 
 [horizontal]
 Returns:;; The index of the bucket which would contain an element with key `k`.
 Postconditions:;; The return value is less than `bucket_count()`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 

include/boost/unordered/concurrent_flat_map.hpp

@@ -0,0 +1,685 @@
+/* Fast open-addressing concurrent hash table.
+ *
+ * Copyright 2023 Christian Mazakas.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+/* Reference:
+ * https://github.com/joaquintides/concurrent_hashmap_api#proposed-synopsis
+ */
+
+#ifndef BOOST_UNORDERED_CONCURRENT_FLAT_MAP_HPP
+#define BOOST_UNORDERED_CONCURRENT_FLAT_MAP_HPP
+
+#include <boost/unordered/detail/foa/concurrent_table.hpp>
+#include <boost/unordered/detail/type_traits.hpp>
+
+#include <boost/container_hash/hash.hpp>
+#include <boost/core/allocator_access.hpp>
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/list.hpp>
+#include <boost/type_traits/type_identity.hpp>
+
+#include <functional>
+#include <type_traits>
+#include <utility>
+
+#define BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)                             \
+  static_assert(boost::unordered::detail::is_invocable<F, value_type&>::value, \
+    "The provided Callable must be invocable with `value_type&`");
+
+#define BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)                       \
+  static_assert(                                                               \
+    boost::unordered::detail::is_invocable<F, value_type const&>::value,       \
+    "The provided Callable must be invocable with `value_type const&`");
+
+#define BOOST_UNORDERED_COMMA ,
+
+#define BOOST_UNORDERED_LAST_ARG(Arg, Args)                                    \
+  mp11::mp_back<mp11::mp_list<Arg BOOST_UNORDERED_COMMA Args> >
+
+#define BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_INVOCABLE(Arg, Args)            \
+  BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(BOOST_UNORDERED_LAST_ARG(Arg, Args))
+
+#define BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_CONST_INVOCABLE(Arg, Args)      \
+  BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(                               \
+    BOOST_UNORDERED_LAST_ARG(Arg, Args))
+
+namespace boost {
+  namespace unordered {
+    namespace detail {
+
+      template <class F, class... Args>
+      struct is_invocable
+          : std::is_constructible<std::function<void(Args...)>,
+              std::reference_wrapper<typename std::remove_reference<F>::type> >
+      {
+      };
+
+      template <class Key, class T> struct concurrent_map_types
+      {
+        using key_type = Key;
+        using raw_key_type = typename std::remove_const<Key>::type;
+        using raw_mapped_type = typename std::remove_const<T>::type;
+
+        using init_type = std::pair<raw_key_type, raw_mapped_type>;
+        using moved_type = std::pair<raw_key_type&&, raw_mapped_type&&>;
+        using value_type = std::pair<Key const, T>;
+
+        using element_type = value_type;
+
+        static value_type& value_from(element_type& x) { return x; }
+
+        template <class K, class V>
+        static raw_key_type const& extract(std::pair<K, V> const& kv)
+        {
+          return kv.first;
+        }
+
+        static moved_type move(init_type& x)
+        {
+          return {std::move(x.first), std::move(x.second)};
+        }
+
+        static moved_type move(element_type& x)
+        {
+          // TODO: we probably need to launder here
+          return {std::move(const_cast<raw_key_type&>(x.first)),
+            std::move(const_cast<raw_mapped_type&>(x.second))};
+        }
+
+        template <class A, class... Args>
+        static void construct(A& al, init_type* p, Args&&... args)
+        {
+          boost::allocator_construct(al, p, std::forward<Args>(args)...);
+        }
+
+        template <class A, class... Args>
+        static void construct(A& al, value_type* p, Args&&... args)
+        {
+          boost::allocator_construct(al, p, std::forward<Args>(args)...);
+        }
+
+        template <class A> static void destroy(A& al, init_type* p) noexcept
+        {
+          boost::allocator_destroy(al, p);
+        }
+
+        template <class A> static void destroy(A& al, value_type* p) noexcept
+        {
+          boost::allocator_destroy(al, p);
+        }
+      };
+    } // namespace detail
+
+    template <class Key, class T, class Hash = boost::hash<Key>,
+      class Pred = std::equal_to<Key>,
+      class Allocator = std::allocator<std::pair<Key const, T> > >
+    class concurrent_flat_map
+    {
+    private:
+      using type_policy = detail::concurrent_map_types<Key, T>;
+
+      detail::foa::concurrent_table<type_policy, Hash, Pred, Allocator> table_;
+
+    public:
+      using key_type = Key;
+      using mapped_type = T;
+      using value_type = typename type_policy::value_type;
+      using init_type = typename type_policy::init_type;
+      using size_type = std::size_t;
+      using difference_type = std::ptrdiff_t;
+      using hasher = typename boost::type_identity<Hash>::type;
+      using key_equal = typename boost::type_identity<Pred>::type;
+      using allocator_type = typename boost::type_identity<Allocator>::type;
+      using reference = value_type&;
+      using const_reference = value_type const&;
+      using pointer = typename boost::allocator_pointer<allocator_type>::type;
+      using const_pointer =
+        typename boost::allocator_const_pointer<allocator_type>::type;
+
+      concurrent_flat_map()
+          : concurrent_flat_map(detail::foa::default_bucket_count)
+      {
+      }
+
+      explicit concurrent_flat_map(size_type n, const hasher& hf = hasher(),
+        const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type())
+          : table_(n, hf, eql, a)
+      {
+      }
+
+      template <class InputIterator>
+      concurrent_flat_map(InputIterator f, InputIterator l,
+        size_type n = detail::foa::default_bucket_count,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type())
+          : table_(n, hf, eql, a)
+      {
+        this->insert(f, l);
+      }
+
+      concurrent_flat_map(concurrent_flat_map const& rhs)
+          : table_(rhs.table_,
+              boost::allocator_select_on_container_copy_construction(
+                rhs.get_allocator()))
+      {
+      }
+
+      concurrent_flat_map(concurrent_flat_map&& rhs)
+          : table_(std::move(rhs.table_))
+      {
+      }
+
+      template <class InputIterator>
+      concurrent_flat_map(InputIterator f, InputIterator l, allocator_type a)
+          : concurrent_flat_map(f, l, 0, hasher(), key_equal(), a)
+      {
+      }
+
+      explicit concurrent_flat_map(allocator_type a)
+          : table_(detail::foa::default_bucket_count, hasher(), key_equal(), a)
+      {
+      }
+
+      concurrent_flat_map(concurrent_flat_map const& rhs, allocator_type a)
+          : table_(rhs.table_, a)
+      {
+      }
+
+      concurrent_flat_map(concurrent_flat_map&& rhs, allocator_type a)
+          : table_(std::move(rhs.table_), a)
+      {
+      }
+
+      concurrent_flat_map(std::initializer_list<value_type> il,
+        size_type n = detail::foa::default_bucket_count,
+        const hasher& hf = hasher(), const key_equal& eql = key_equal(),
+        const allocator_type& a = allocator_type())
+          : concurrent_flat_map(n, hf, eql, a)
+      {
+        this->insert(il.begin(), il.end());
+      }
+
+      concurrent_flat_map(size_type n, const allocator_type& a)
+          : concurrent_flat_map(n, hasher(), key_equal(), a)
+      {
+      }
+
+      concurrent_flat_map(
+        size_type n, const hasher& hf, const allocator_type& a)
+          : concurrent_flat_map(n, hf, key_equal(), a)
+      {
+      }
+
+      template <typename InputIterator>
+      concurrent_flat_map(
+        InputIterator f, InputIterator l, size_type n, const allocator_type& a)
+          : concurrent_flat_map(f, l, n, hasher(), key_equal(), a)
+      {
+      }
+
+      template <typename InputIterator>
+      concurrent_flat_map(InputIterator f, InputIterator l, size_type n,
+        const hasher& hf, const allocator_type& a)
+          : concurrent_flat_map(f, l, n, hf, key_equal(), a)
+      {
+      }
+
+      concurrent_flat_map(
+        std::initializer_list<value_type> il, const allocator_type& a)
+          : concurrent_flat_map(
+              il, detail::foa::default_bucket_count, hasher(), key_equal(), a)
+      {
+      }
+
+      concurrent_flat_map(std::initializer_list<value_type> il, size_type n,
+        const allocator_type& a)
+          : concurrent_flat_map(il, n, hasher(), key_equal(), a)
+      {
+      }
+
+      concurrent_flat_map(std::initializer_list<value_type> il, size_type n,
+        const hasher& hf, const allocator_type& a)
+          : concurrent_flat_map(il, n, hf, key_equal(), a)
+      {
+      }
+
+      ~concurrent_flat_map() = default;
+
+      concurrent_flat_map& operator=(concurrent_flat_map const& rhs)
+      {
+        table_ = rhs.table_;
+        return *this;
+      }
+
+      /// Capacity
+      ///
+
+      size_type size() const noexcept { return table_.size(); }
+
+      BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
+      {
+        return size() == 0;
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE std::size_t visit(key_type const& k, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        return table_.visit(k, f);
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE std::size_t visit(key_type const& k, F f) const
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.visit(k, f);
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE std::size_t cvisit(key_type const& k, F f) const
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.visit(k, f);
+      }
+
+      template <class K, class F>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value, std::size_t>::type
+      visit(K&& k, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        return table_.visit(std::forward<K>(k), f);
+      }
+
+      template <class K, class F>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value, std::size_t>::type
+      visit(K&& k, F f) const
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.visit(std::forward<K>(k), f);
+      }
+
+      template <class K, class F>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value, std::size_t>::type
+      cvisit(K&& k, F f) const
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.visit(std::forward<K>(k), f);
+      }
+
+      template <class F> BOOST_FORCEINLINE std::size_t visit_all(F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        return table_.visit_all(f);
+      }
+
+      template <class F> BOOST_FORCEINLINE std::size_t visit_all(F f) const
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.visit_all(f);
+      }
+
+      template <class F> BOOST_FORCEINLINE std::size_t cvisit_all(F f) const
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.cvisit_all(f);
+      }
+
+#if defined(BOOST_UNORDERED_PARALLEL_ALGORITHMS)
+      template <class ExecPolicy, class F>
+      BOOST_FORCEINLINE
+        typename std::enable_if<detail::is_execution_policy<ExecPolicy>::value,
+          void>::type
+        visit_all(ExecPolicy p, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        table_.visit_all(p, f);
+      }
+
+      template <class ExecPolicy, class F>
+      BOOST_FORCEINLINE
+        typename std::enable_if<detail::is_execution_policy<ExecPolicy>::value,
+          void>::type
+        visit_all(ExecPolicy p, F f) const
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        table_.visit_all(p, f);
+      }
+
+      template <class ExecPolicy, class F>
+      BOOST_FORCEINLINE
+        typename std::enable_if<detail::is_execution_policy<ExecPolicy>::value,
+          void>::type
+        cvisit_all(ExecPolicy p, F f) const
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        table_.cvisit_all(p, f);
+      }
+#endif
+
+      /// Modifiers
+      ///
+
+      BOOST_FORCEINLINE bool insert(value_type const& obj)
+      {
+        return table_.insert(obj);
+      }
+      BOOST_FORCEINLINE bool insert(value_type&& obj)
+      {
+        return table_.insert(std::move(obj));
+      }
+
+      BOOST_FORCEINLINE bool insert(init_type const& obj)
+      {
+        return table_.insert(obj);
+      }
+      BOOST_FORCEINLINE bool insert(init_type&& obj)
+      {
+        return table_.insert(std::move(obj));
+      }
+
+      template <class InputIterator>
+      BOOST_FORCEINLINE void insert(InputIterator begin, InputIterator end)
+      {
+        for (auto pos = begin; pos != end; ++pos) {
+          table_.insert(*pos);
+        }
+      }
+
+      BOOST_FORCEINLINE void insert(std::initializer_list<value_type> ilist)
+      {
+        this->insert(ilist.begin(), ilist.end());
+      }
+
+      template <class M>
+      BOOST_FORCEINLINE bool insert_or_assign(key_type const& k, M&& obj)
+      {
+        return table_.try_emplace_or_visit(k, std::forward<M>(obj),
+          [&](value_type& m) { m.second = std::forward<M>(obj); });
+      }
+
+      template <class M>
+      BOOST_FORCEINLINE bool insert_or_assign(key_type&& k, M&& obj)
+      {
+        return table_.try_emplace_or_visit(std::move(k), std::forward<M>(obj),
+          [&](value_type& m) { m.second = std::forward<M>(obj); });
+      }
+
+      template <class K, class M>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value, bool>::type
+      insert_or_assign(K&& k, M&& obj)
+      {
+        return table_.try_emplace_or_visit(std::forward<K>(k),
+          std::forward<M>(obj),
+          [&](value_type& m) { m.second = std::forward<M>(obj); });
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE bool insert_or_visit(value_type const& obj, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        return table_.insert_or_visit(obj, f);
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE bool insert_or_visit(value_type&& obj, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        return table_.insert_or_visit(std::move(obj), f);
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE bool insert_or_visit(init_type const& obj, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        return table_.insert_or_visit(obj, f);
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE bool insert_or_visit(init_type&& obj, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        return table_.insert_or_visit(std::move(obj), f);
+      }
+
+      template <class InputIterator, class F>
+      BOOST_FORCEINLINE void insert_or_visit(
+        InputIterator first, InputIterator last, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        for (; first != last; ++first) {
+          table_.insert_or_visit(*first, f);
+        }
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE void insert_or_visit(
+        std::initializer_list<value_type> ilist, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE(F)
+        this->insert_or_visit(ilist.begin(), ilist.end(), f);
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE bool insert_or_cvisit(value_type const& obj, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.insert_or_cvisit(obj, f);
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE bool insert_or_cvisit(value_type&& obj, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.insert_or_cvisit(std::move(obj), f);
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE bool insert_or_cvisit(init_type const& obj, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.insert_or_cvisit(obj, f);
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE bool insert_or_cvisit(init_type&& obj, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        return table_.insert_or_cvisit(std::move(obj), f);
+      }
+
+      template <class InputIterator, class F>
+      BOOST_FORCEINLINE void insert_or_cvisit(
+        InputIterator first, InputIterator last, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        for (; first != last; ++first) {
+          table_.insert_or_cvisit(*first, f);
+        }
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE void insert_or_cvisit(
+        std::initializer_list<value_type> ilist, F f)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE(F)
+        this->insert_or_visit(ilist.begin(), ilist.end(), f);
+      }
+
+      template <class... Args> BOOST_FORCEINLINE bool emplace(Args&&... args)
+      {
+        return table_.emplace(std::forward<Args>(args)...);
+      }
+
+      template <class Arg, class... Args>
+      BOOST_FORCEINLINE bool emplace_or_visit(Arg&& arg, Args&&... args)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_INVOCABLE(Arg, Args...)
+        return table_.emplace_or_visit(
+          std::forward<Arg>(arg), std::forward<Args>(args)...);
+      }
+
+      template <class Arg, class... Args>
+      BOOST_FORCEINLINE bool emplace_or_cvisit(Arg&& arg, Args&&... args)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_CONST_INVOCABLE(Arg, Args...)
+        return table_.emplace_or_cvisit(
+          std::forward<Arg>(arg), std::forward<Args>(args)...);
+      }
+
+      template <class... Args>
+      BOOST_FORCEINLINE bool try_emplace(key_type const& k, Args&&... args)
+      {
+        return table_.try_emplace(k, std::forward<Args>(args)...);
+      }
+
+      template <class... Args>
+      BOOST_FORCEINLINE bool try_emplace(key_type&& k, Args&&... args)
+      {
+        return table_.try_emplace(std::move(k), std::forward<Args>(args)...);
+      }
+
+      template <class K, class... Args>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value, bool>::type
+      try_emplace(K&& k, Args&&... args)
+      {
+        return table_.try_emplace(
+          std::forward<K>(k), std::forward<Args>(args)...);
+      }
+
+      template <class Arg, class... Args>
+      BOOST_FORCEINLINE bool try_emplace_or_visit(
+        key_type const& k, Arg&& arg, Args&&... args)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_INVOCABLE(Arg, Args...)
+        return table_.try_emplace_or_visit(
+          k, std::forward<Arg>(arg), std::forward<Args>(args)...);
+      }
+
+      template <class Arg, class... Args>
+      BOOST_FORCEINLINE bool try_emplace_or_cvisit(
+        key_type const& k, Arg&& arg, Args&&... args)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_CONST_INVOCABLE(Arg, Args...)
+        return table_.try_emplace_or_cvisit(
+          k, std::forward<Arg>(arg), std::forward<Args>(args)...);
+      }
+
+      template <class Arg, class... Args>
+      BOOST_FORCEINLINE bool try_emplace_or_visit(
+        key_type&& k, Arg&& arg, Args&&... args)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_INVOCABLE(Arg, Args...)
+        return table_.try_emplace_or_visit(
+          std::move(k), std::forward<Arg>(arg), std::forward<Args>(args)...);
+      }
+
+      template <class Arg, class... Args>
+      BOOST_FORCEINLINE bool try_emplace_or_cvisit(
+        key_type&& k, Arg&& arg, Args&&... args)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_CONST_INVOCABLE(Arg, Args...)
+        return table_.try_emplace_or_cvisit(
+          std::move(k), std::forward<Arg>(arg), std::forward<Args>(args)...);
+      }
+
+      template <class K, class Arg, class... Args>
+      BOOST_FORCEINLINE bool try_emplace_or_visit(
+        K&& k, Arg&& arg, Args&&... args)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_INVOCABLE(Arg, Args...)
+        return table_.try_emplace_or_visit(std::forward<K>(k),
+          std::forward<Arg>(arg), std::forward<Args>(args)...);
+      }
+
+      template <class K, class Arg, class... Args>
+      BOOST_FORCEINLINE bool try_emplace_or_cvisit(
+        K&& k, Arg&& arg, Args&&... args)
+      {
+        BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_CONST_INVOCABLE(Arg, Args...)
+        return table_.try_emplace_or_cvisit(std::forward<K>(k),
+          std::forward<Arg>(arg), std::forward<Args>(args)...);
+      }
+
+      BOOST_FORCEINLINE size_type erase(key_type const& k)
+      {
+        return table_.erase(k);
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
+      erase(K&& k)
+      {
+        return table_.erase(std::forward<K>(k));
+      }
+
+      template <class F>
+      BOOST_FORCEINLINE size_type erase_if(key_type const& k, F f)
+      {
+        return table_.erase_if(k, f);
+      }
+
+      template <class K, class F>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value &&
+          !detail::is_execution_policy<K>::value,
+        size_type>::type
+      erase_if(K&& k, F f)
+      {
+        return table_.erase_if(std::forward<K>(k), f);
+      }
+
+#if defined(BOOST_UNORDERED_PARALLEL_ALGORITHMS)
+      template <class ExecPolicy, class F>
+      BOOST_FORCEINLINE
+        typename std::enable_if<detail::is_execution_policy<ExecPolicy>::value,
+          void>::type
+        erase_if(ExecPolicy p, F f)
+      {
+        table_.erase_if(p, f);
+      }
+#endif
+
+      template <class F> BOOST_FORCEINLINE size_type erase_if(F f)
+      {
+        return table_.erase_if(f);
+      }
+
+      /// Hash Policy
+      ///
+      void rehash(size_type n) { table_.rehash(n); }
+      void reserve(size_type n) { table_.reserve(n); }
+
+      /// Observers
+      ///
+      allocator_type get_allocator() const noexcept
+      {
+        return table_.get_allocator();
+      }
+
+      hasher hash_function() const { return table_.hash_function(); }
+      key_equal key_eq() const { return table_.key_eq(); }
+    };
+  } // namespace unordered
+} // namespace boost
+
+#undef BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE
+#undef BOOST_UNORDERED_STATIC_ASSERT_CONST_INVOCABLE
+#undef BOOST_UNORDERED_COMMA
+#undef BOOST_UNORDERED_LAST_ARG
+#undef BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_INVOCABLE
+#undef BOOST_UNORDERED_STATIC_ASSERT_LAST_ARG_CONST_INVOCABLE
+
+#endif // BOOST_UNORDERED_CONCURRENT_FLAT_MAP_HPP

include/boost/unordered/detail/foa/element_type.hpp

@@ -0,0 +1,60 @@
+/* Copyright 2023 Christian Mazakas.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_FOA_ELEMENT_TYPE_HPP
+#define BOOST_UNORDERED_DETAIL_FOA_ELEMENT_TYPE_HPP
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+template<class T>
+struct element_type
+{
+  using value_type=T;
+  value_type* p;
+
+  /*
+   * we use a deleted copy constructor here so the type is no longer
+   * trivially copy-constructible which inhibits our memcpy
+   * optimizations when copying the tables
+   */
+  element_type() = default;
+  element_type(value_type* p_):p(p_){}
+  element_type(element_type const&) = delete;
+  element_type(element_type&& rhs) noexcept
+  {
+    p = rhs.p;
+    rhs.p = nullptr;
+  }
+
+  element_type& operator=(element_type const&)=delete;
+  element_type& operator=(element_type&& rhs)noexcept
+  {
+    if (this!=&rhs){
+      p=rhs.p;
+      rhs.p=nullptr;
+    }
+    return *this;
+  }
+
+  void swap(element_type& rhs)noexcept
+  {
+    auto tmp=p;
+    p=rhs.p;
+    rhs.p=tmp;
+  }
+};
+
+}
+}
+}
+}
+
+#endif // BOOST_UNORDERED_DETAIL_FOA_ELEMENT_TYPE_HPP

include/boost/unordered/detail/foa/ignore_wshadow.hpp

@@ -0,0 +1,35 @@
+/* Copyright 2023 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#include <boost/config.hpp>
+
+#if defined(BOOST_GCC)
+#if !defined(BOOST_UNORDERED_DETAIL_RESTORE_WSHADOW)
+ /* GCC's -Wshadow triggers at scenarios like this: 
+ *
+ *   struct foo{};
+ *   template<typename Base>
+ *   struct derived:Base
+ *   {
+ *     void f(){int foo;}
+ *   };
+ * 
+ *   derived<foo>x;
+ *   x.f(); // declaration of "foo" in derived::f shadows base type "foo"
+ *
+ * This makes shadowing warnings unavoidable in general when a class template
+ * derives from user-provided classes, as is the case with foa::table_core
+ * deriving from empty_value.
+ */
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wshadow"
+#else
+#pragma GCC diagnostic pop
+#endif
+#endif

include/boost/unordered/detail/foa/node_handle.hpp

@@ -0,0 +1,210 @@
+/* Copyright 2023 Christian Mazakas.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_FOA_NODE_HANDLE_HPP
+#define BOOST_UNORDERED_DETAIL_FOA_NODE_HANDLE_HPP
+
+#include <boost/config.hpp>
+#include <boost/core/allocator_access.hpp>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+template <class Iterator,class NodeType>
+struct insert_return_type
+{
+  Iterator position;
+  bool     inserted;
+  NodeType node;
+};
+
+template <class T>
+union opt_storage {
+  BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS T t_;
+
+  opt_storage(){}
+  ~opt_storage(){}
+};
+
+template <class TypePolicy,class Allocator>
+struct node_handle_base
+{
+  protected:
+    using type_policy=TypePolicy;
+    using element_type=typename type_policy::element_type;
+
+  public:
+    using allocator_type = Allocator;
+
+  private:
+    using node_value_type=typename type_policy::value_type;
+    element_type p_;
+    BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS opt_storage<Allocator> a_;
+
+  protected:
+    node_value_type& data()noexcept
+    {
+      return *(p_.p);
+    }
+
+    node_value_type const& data()const noexcept
+    {
+      return *(p_.p);
+    }
+
+    element_type& element()noexcept
+    {
+      BOOST_ASSERT(!empty());
+      return p_;
+    }
+
+    element_type const& element()const noexcept
+    {
+      BOOST_ASSERT(!empty());
+      return p_;
+    }
+
+    Allocator& al()noexcept
+    {
+      BOOST_ASSERT(!empty());
+      return a_.t_;
+    }
+
+    Allocator const& al()const noexcept
+    {
+      BOOST_ASSERT(!empty());
+      return a_.t_;
+    }
+
+    void emplace(element_type&& x,Allocator a)
+    {
+      BOOST_ASSERT(empty());
+      auto* p=x.p;
+      p_.p=p;
+      new(&a_.t_)Allocator(a);
+      x.p=nullptr;
+    }
+
+    void reset()
+    {
+      a_.t_.~Allocator();
+      p_.p=nullptr;
+    }
+
+  public:
+    constexpr node_handle_base()noexcept:p_{nullptr}{}
+
+    node_handle_base(node_handle_base&& nh) noexcept
+    {
+      p_.p = nullptr;
+      if (!nh.empty()){
+        emplace(std::move(nh.p_),nh.al());
+        nh.reset();
+      }
+    }
+
+    node_handle_base& operator=(node_handle_base&& nh)noexcept
+    {
+      if(this!=&nh){
+        if(empty()){
+          if(nh.empty()){                      /* empty(),  nh.empty() */
+            /* nothing to do */
+          }else{                               /* empty(), !nh.empty() */
+            emplace(std::move(nh.p_),std::move(nh.al()));
+            nh.reset();
+          }
+        }else{
+          if(nh.empty()){                      /* !empty(),  nh.empty() */
+            type_policy::destroy(al(),&p_);
+            reset();
+          }else{                               /* !empty(), !nh.empty() */
+            bool const pocma=
+              boost::allocator_propagate_on_container_move_assignment<
+                Allocator>::type::value;
+
+            BOOST_ASSERT(pocma||al()==nh.al());
+
+            type_policy::destroy(al(),&p_);
+            if(pocma){
+              al()=std::move(nh.al());
+            }
+
+            p_=std::move(nh.p_);
+            nh.reset();
+          }
+        }
+      }else{
+        if(empty()){                           /* empty(),  nh.empty() */
+          /* nothing to do */
+        }else{                                 /* !empty(), !nh.empty() */
+          type_policy::destroy(al(),&p_);
+          reset();
+        }
+      }
+      return *this;
+    }
+
+    ~node_handle_base()
+    {
+      if(!empty()){
+        type_policy::destroy(al(),&p_);
+        reset();
+      }
+    }
+
+    allocator_type get_allocator()const noexcept{return al();}
+    explicit operator bool()const noexcept{ return !empty();}
+    BOOST_ATTRIBUTE_NODISCARD bool empty()const noexcept{return p_.p==nullptr;}
+
+    void swap(node_handle_base& nh) noexcept(
+      boost::allocator_is_always_equal<Allocator>::type::value||
+      boost::allocator_propagate_on_container_swap<Allocator>::type::value)
+    {
+      if(this!=&nh){
+        if(empty()){
+          if(nh.empty()) {
+            /* nothing to do here */
+          } else {
+            emplace(std::move(nh.p_), nh.al());
+            nh.reset();
+          }
+        }else{
+          if(nh.empty()){
+            nh.emplace(std::move(p_),al());
+            reset();
+          }else{
+            bool const pocs=
+              boost::allocator_propagate_on_container_swap<
+                Allocator>::type::value;
+
+            BOOST_ASSERT(pocs || al()==nh.al());
+
+            using std::swap;
+            p_.swap(nh.p_);
+            if(pocs)swap(al(),nh.al());
+          }
+        }
+      }
+    }
+
+    friend
+    void swap(node_handle_base& lhs,node_handle_base& rhs)
+      noexcept(noexcept(lhs.swap(rhs)))
+    {
+      return lhs.swap(rhs);
+    }
+};
+
+}
+}
+}
+}
+
+#endif // BOOST_UNORDERED_DETAIL_FOA_NODE_HANDLE_HPP

include/boost/unordered/detail/foa/restore_wshadow.hpp

@@ -0,0 +1,11 @@
+/* Copyright 2023 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#define BOOST_UNORDERED_DETAIL_RESTORE_WSHADOW
+#include <boost/unordered/detail/foa/ignore_wshadow.hpp>
+#undef BOOST_UNORDERED_DETAIL_RESTORE_WSHADOW

include/boost/unordered/detail/foa/rw_spinlock.hpp

@@ -0,0 +1,188 @@
+#ifndef BOOST_UNORDERED_DETAIL_FOA_RW_SPINLOCK_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_FOA_RW_SPINLOCK_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/smart_ptr/detail/sp_thread_pause.hpp>
+#include <boost/smart_ptr/detail/sp_thread_sleep.hpp>
+#include <atomic>
+#include <cstdint>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+class rw_spinlock
+{
+private:
+
+    // bit 31: locked exclusive
+    // bit 30: writer pending
+    // bit 29..0: reader lock count
+
+    static constexpr std::uint32_t locked_exclusive_mask = 1u << 31; // 0x8000'0000
+    static constexpr std::uint32_t writer_pending_mask = 1u << 30; // 0x4000'0000
+    static constexpr std::uint32_t reader_lock_count_mask = writer_pending_mask - 1; // 0x3FFF'FFFF
+
+    std::atomic<std::uint32_t> state_ = {};
+
+private:
+
+    // number of times to spin before sleeping
+    static constexpr int spin_count = 24576;
+
+public:
+
+    bool try_lock_shared() noexcept
+    {
+        std::uint32_t st = state_.load( std::memory_order_relaxed );
+
+        if( st >= reader_lock_count_mask )
+        {
+            // either bit 31 set, bit 30 set, or reader count is max
+            return false;
+        }
+
+        std::uint32_t newst = st + 1;
+        return state_.compare_exchange_strong( st, newst, std::memory_order_acquire, std::memory_order_relaxed );
+    }
+
+    void lock_shared() noexcept
+    {
+        for( ;; )
+        {
+            for( int k = 0; k < spin_count; ++k )
+            {
+                std::uint32_t st = state_.load( std::memory_order_relaxed );
+
+                if( st < reader_lock_count_mask )
+                {
+                    std::uint32_t newst = st + 1;
+                    if( state_.compare_exchange_weak( st, newst, std::memory_order_acquire, std::memory_order_relaxed ) ) return;
+                }
+
+                boost::detail::sp_thread_pause();
+            }
+
+            boost::detail::sp_thread_sleep();
+        }
+    }
+
+    void unlock_shared() noexcept
+    {
+        // pre: locked shared, not locked exclusive
+
+        state_.fetch_sub( 1, std::memory_order_release );
+
+        // if the writer pending bit is set, there's a writer waiting
+        // let it acquire the lock; it will clear the bit on unlock
+    }
+
+    bool try_lock() noexcept
+    {
+        std::uint32_t st = state_.load( std::memory_order_relaxed );
+
+        if( st & locked_exclusive_mask )
+        {
+            // locked exclusive
+            return false;
+        }
+
+        if( st & reader_lock_count_mask )
+        {
+            // locked shared
+            return false;
+        }
+
+        std::uint32_t newst = locked_exclusive_mask;
+        return state_.compare_exchange_strong( st, newst, std::memory_order_acquire, std::memory_order_relaxed );
+    }
+
+    void lock() noexcept
+    {
+        for( ;; )
+        {
+            for( int k = 0; k < spin_count; ++k )
+            {
+                std::uint32_t st = state_.load( std::memory_order_relaxed );
+
+                if( st & locked_exclusive_mask )
+                {
+                    // locked exclusive, spin
+                }
+                else if( ( st & reader_lock_count_mask ) == 0 )
+                {
+                    // not locked exclusive, not locked shared, try to lock
+
+                    std::uint32_t newst = locked_exclusive_mask;
+                    if( state_.compare_exchange_weak( st, newst, std::memory_order_acquire, std::memory_order_relaxed ) ) return;
+                }
+                else if( st & writer_pending_mask )
+                {
+                    // writer pending bit already set, nothing to do
+                }
+                else
+                {
+                    // locked shared, set writer pending bit
+
+                    std::uint32_t newst = st | writer_pending_mask;
+                    state_.compare_exchange_weak( st, newst, std::memory_order_relaxed, std::memory_order_relaxed );
+                }
+
+                boost::detail::sp_thread_pause();
+            }
+
+            // clear writer pending bit before going to sleep
+
+            {
+                std::uint32_t st = state_.load( std::memory_order_relaxed );
+
+                for( ;; )
+                {
+                    if( st & locked_exclusive_mask )
+                    {
+                        // locked exclusive, nothing to do
+                        break;
+                    }
+                    else if( ( st & reader_lock_count_mask ) == 0 )
+                    {
+                        // lock free, try to take it
+
+                        std::uint32_t newst = locked_exclusive_mask;
+                        if( state_.compare_exchange_weak( st, newst, std::memory_order_acquire, std::memory_order_relaxed ) ) return;
+                    }
+                    else if( ( st & writer_pending_mask ) == 0 )
+                    {
+                        // writer pending bit already clear, nothing to do
+                        break;
+                    }
+                    else
+                    {
+                        // clear writer pending bit
+
+                        std::uint32_t newst = st & ~writer_pending_mask;
+                        if( state_.compare_exchange_weak( st, newst, std::memory_order_relaxed, std::memory_order_relaxed ) ) break;
+                    }
+                }
+            }
+
+            boost::detail::sp_thread_sleep();
+        }
+    }
+
+    void unlock() noexcept
+    {
+        // pre: locked exclusive, not locked shared
+        state_.store( 0, std::memory_order_release );
+    }
+};
+
+} /* namespace foa */
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif // BOOST_UNORDERED_DETAIL_FOA_RW_SPINLOCK_HPP_INCLUDED

include/boost/unordered/detail/foa/table.hpp

@@ -0,0 +1,540 @@
+/* Fast open-addressing hash table.
+ *
+ * Copyright 2022-2023 Joaquin M Lopez Munoz.
+ * Copyright 2023 Christian Mazakas.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_FOA_TABLE_HPP
+#define BOOST_UNORDERED_DETAIL_FOA_TABLE_HPP
+
+#include <boost/assert.hpp>
+#include <boost/config.hpp>
+#include <boost/config/workaround.hpp>
+#include <boost/unordered/detail/foa/core.hpp>
+#include <cstddef>
+#include <iterator>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+/* use plain integrals for group metadata storage */
+
+template<typename Integral>
+struct plain_integral
+{
+  operator Integral()const{return n;}
+  void operator=(Integral m){n=m;}
+
+#if BOOST_WORKAROUND(BOOST_GCC,>=50000 && BOOST_GCC<60000)
+  void operator|=(Integral m){n=static_cast<Integral>(n|m);}
+  void operator&=(Integral m){n=static_cast<Integral>(n&m);}
+#else
+  void operator|=(Integral m){n|=m;}
+  void operator&=(Integral m){n&=m;}
+#endif
+
+  Integral n;
+};
+
+template<typename,typename,typename,typename>
+class table;
+
+/* table_iterator keeps two pointers:
+ * 
+ *   - A pointer p to the element slot.
+ *   - A pointer pc to the n-th byte of the associated group metadata, where n
+ *     is the position of the element in the group.
+ *
+ * A simpler solution would have been to keep a pointer p to the element, a
+ * pointer pg to the group, and the position n, but that would increase
+ * sizeof(table_iterator) by 4/8 bytes. In order to make this compact
+ * representation feasible, it is required that group objects are aligned
+ * to their size, so that we can recover pg and n as
+ * 
+ *   - n = pc%sizeof(group)
+ *   - pg = pc-n
+ * 
+ * (for explanatory purposes pg and pc are treated above as if they were memory
+ * addresses rather than pointers).
+ * 
+ * p = nullptr is conventionally used to mark end() iterators.
+ */
+
+/* internal conversion from const_iterator to iterator */
+struct const_iterator_cast_tag{}; 
+
+template<typename TypePolicy,typename Group,bool Const>
+class table_iterator
+{
+  using type_policy=TypePolicy;
+  using table_element_type=typename type_policy::element_type;
+  using group_type=Group;
+  static constexpr auto N=group_type::N;
+  static constexpr auto regular_layout=group_type::regular_layout;
+
+public:
+  using difference_type=std::ptrdiff_t;
+  using value_type=typename type_policy::value_type;
+  using pointer=
+    typename std::conditional<Const,value_type const*,value_type*>::type;
+  using reference=
+    typename std::conditional<Const,value_type const&,value_type&>::type;
+  using iterator_category=std::forward_iterator_tag;
+  using element_type=
+    typename std::conditional<Const,value_type const,value_type>::type;
+
+  table_iterator()=default;
+  template<bool Const2,typename std::enable_if<!Const2>::type* =nullptr>
+  table_iterator(const table_iterator<TypePolicy,Group,Const2>& x):
+    pc{x.pc},p{x.p}{}
+  table_iterator(
+    const_iterator_cast_tag, const table_iterator<TypePolicy,Group,true>& x):
+    pc{x.pc},p{x.p}{}
+
+  inline reference operator*()const noexcept
+    {return type_policy::value_from(*p);}
+  inline pointer operator->()const noexcept
+    {return std::addressof(type_policy::value_from(*p));}
+  inline table_iterator& operator++()noexcept{increment();return *this;}
+  inline table_iterator operator++(int)noexcept
+    {auto x=*this;increment();return x;}
+  friend inline bool operator==(
+    const table_iterator& x,const table_iterator& y)
+    {return x.p==y.p;}
+  friend inline bool operator!=(
+    const table_iterator& x,const table_iterator& y)
+    {return !(x==y);}
+
+private:
+  template<typename,typename,bool> friend class table_iterator;
+  template<typename,typename,typename,typename> friend class table;
+
+  table_iterator(Group* pg,std::size_t n,const table_element_type* p_):
+    pc{reinterpret_cast<unsigned char*>(const_cast<group_type*>(pg))+n},
+    p{const_cast<table_element_type*>(p_)}
+    {}
+
+  inline void increment()noexcept
+  {
+    BOOST_ASSERT(p!=nullptr);
+    increment(std::integral_constant<bool,regular_layout>{});
+  }
+
+  inline void increment(std::true_type /* regular layout */)noexcept
+  {
+    for(;;){
+      ++p;
+      if(reinterpret_cast<uintptr_t>(pc)%sizeof(group_type)==N-1){
+        pc+=sizeof(group_type)-(N-1);
+        break;
+      }
+      ++pc;
+      if(!group_type::is_occupied(pc))continue;
+      if(BOOST_UNLIKELY(group_type::is_sentinel(pc)))p=nullptr;
+      return;
+    }
+
+    for(;;){
+      int mask=reinterpret_cast<group_type*>(pc)->match_occupied();
+      if(mask!=0){
+        auto n=unchecked_countr_zero(mask);
+        if(BOOST_UNLIKELY(reinterpret_cast<group_type*>(pc)->is_sentinel(n))){
+          p=nullptr;
+        }
+        else{
+          pc+=n;
+          p+=n;
+        }
+        return;
+      }
+      pc+=sizeof(group_type);
+      p+=N;
+    }
+  }
+
+  inline void increment(std::false_type /* interleaved */)noexcept
+  {
+    std::size_t n0=reinterpret_cast<uintptr_t>(pc)%sizeof(group_type);
+    pc-=n0;
+
+    int mask=(
+      reinterpret_cast<group_type*>(pc)->match_occupied()>>(n0+1))<<(n0+1);
+    if(!mask){
+      do{
+        pc+=sizeof(group_type);
+        p+=N;
+      }
+      while((mask=reinterpret_cast<group_type*>(pc)->match_occupied())==0);
+    }
+
+    auto n=unchecked_countr_zero(mask);
+    if(BOOST_UNLIKELY(reinterpret_cast<group_type*>(pc)->is_sentinel(n))){
+      p=nullptr;
+    }
+    else{
+      pc+=n;
+      p-=n0;
+      p+=n;
+    }
+  }
+
+  unsigned char      *pc=nullptr;
+  table_element_type *p=nullptr;
+};
+
+/* foa::table interface departs in a number of ways from that of C++ unordered
+ * associative containers because it's not for end-user consumption
+ * (boost::unordered_[flat|node]_[map|set] wrappers complete it as
+ * appropriate).
+ *
+ * The table supports two main modes of operation: flat and node-based. In the
+ * flat case, buckets directly store elements. For node-based, buckets store
+ * pointers to individually heap-allocated elements.
+ *
+ * For both flat and node-based:
+ *
+ *   - begin() is not O(1).
+ *   - No bucket API.
+ *   - Load factor is fixed and can't be set by the user.
+ * 
+ * For flat only:
+ *
+ *   - value_type must be moveable.
+ *   - Pointer stability is not kept under rehashing.
+ *   - No extract API.
+ *
+ * try_emplace, erase and find support heterogeneous lookup by default,
+ * that is, without checking for any ::is_transparent typedefs --the
+ * checking is done by boost::unordered_[flat|node]_[map|set].
+ */
+
+template <typename TypePolicy,typename Hash,typename Pred,typename Allocator>
+using table_core_impl=
+  table_core<TypePolicy,group15<plain_integral>,table_arrays,
+  std::size_t,Hash,Pred,Allocator>;
+
+#include <boost/unordered/detail/foa/ignore_wshadow.hpp>
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable:4714) /* marked as __forceinline not inlined */
+#endif
+
+template<typename TypePolicy,typename Hash,typename Pred,typename Allocator>
+class table:table_core_impl<TypePolicy,Hash,Pred,Allocator>
+{
+  using super=table_core_impl<TypePolicy,Hash,Pred,Allocator>;
+  using type_policy=typename super::type_policy;
+  using group_type=typename super::group_type;
+  using super::N;
+  using prober=typename super::prober;
+  using locator=typename super::locator;
+
+public:
+  using key_type=typename super::key_type;
+  using init_type=typename super::init_type;
+  using value_type=typename super::value_type;
+  using element_type=typename super::element_type;
+
+private:
+  static constexpr bool has_mutable_iterator=
+    !std::is_same<key_type,value_type>::value;
+
+public:
+  using hasher=typename super::hasher;
+  using key_equal=typename super::key_equal;
+  using allocator_type=typename super::allocator_type;
+  using pointer=typename super::pointer;
+  using const_pointer=typename super::const_pointer;
+  using reference=typename super::reference;
+  using const_reference=typename super::const_reference;
+  using size_type=typename super::size_type;
+  using difference_type=typename super::difference_type;
+  using const_iterator=table_iterator<type_policy,group_type,true>;
+  using iterator=typename std::conditional<
+    has_mutable_iterator,
+    table_iterator<type_policy,group_type,false>,
+    const_iterator>::type;
+
+  table(
+    std::size_t n=default_bucket_count,const Hash& h_=Hash(),
+    const Pred& pred_=Pred(),const Allocator& al_=Allocator()):
+    super{n,h_,pred_,al_}
+    {}
+
+  table(const table& x)=default;
+  table(table&& x)=default;
+  table(const table& x,const Allocator& al_):super{x,al_}{}
+  table(table&& x,const Allocator& al_):super{std::move(x),al_}{}
+  ~table()=default;
+
+  table& operator=(const table& x)=default;
+  table& operator=(table&& x)=default;
+
+  using super::get_allocator;
+
+  iterator begin()noexcept
+  {
+    iterator it{this->arrays.groups,0,this->arrays.elements};
+    if(this->arrays.elements&&
+       !(this->arrays.groups[0].match_occupied()&0x1))++it;
+    return it;
+  }
+
+  const_iterator begin()const noexcept
+                   {return const_cast<table*>(this)->begin();}
+  iterator       end()noexcept{return {};}
+  const_iterator end()const noexcept{return const_cast<table*>(this)->end();}
+  const_iterator cbegin()const noexcept{return begin();}
+  const_iterator cend()const noexcept{return end();}
+
+  using super::empty;
+  using super::size;
+  using super::max_size;
+
+  template<typename... Args>
+  BOOST_FORCEINLINE std::pair<iterator,bool> emplace(Args&&... args)
+  {
+    auto x=alloc_make_insert_type<type_policy>(
+      this->al(),std::forward<Args>(args)...);
+    return emplace_impl(type_policy::move(x.value()));
+  }
+
+  template<typename Key,typename... Args>
+  BOOST_FORCEINLINE std::pair<iterator,bool> try_emplace(
+    Key&& x,Args&&... args)
+  {
+    return emplace_impl(
+      try_emplace_args_t{},std::forward<Key>(x),std::forward<Args>(args)...);
+  }
+
+  BOOST_FORCEINLINE std::pair<iterator,bool>
+  insert(const init_type& x){return emplace_impl(x);}
+
+  BOOST_FORCEINLINE std::pair<iterator,bool>
+  insert(init_type&& x){return emplace_impl(std::move(x));}
+
+  /* template<typename=void> tilts call ambiguities in favor of init_type */
+
+  template<typename=void>
+  BOOST_FORCEINLINE std::pair<iterator,bool>
+  insert(const value_type& x){return emplace_impl(x);}
+
+  template<typename=void>
+  BOOST_FORCEINLINE std::pair<iterator,bool>
+  insert(value_type&& x){return emplace_impl(std::move(x));}
+
+  template<typename T=element_type>
+  BOOST_FORCEINLINE
+  typename std::enable_if<
+    !std::is_same<T,value_type>::value,
+    std::pair<iterator,bool>
+  >::type
+  insert(element_type&& x){return emplace_impl(std::move(x));}
+
+  template<
+    bool dependent_value=false,
+    typename std::enable_if<
+      has_mutable_iterator||dependent_value>::type* =nullptr
+  >
+  void erase(iterator pos)noexcept{return erase(const_iterator(pos));}
+
+  BOOST_FORCEINLINE
+  void erase(const_iterator pos)noexcept
+  {
+    super::erase(pos.pc,pos.p);
+  }
+
+  template<typename Key>
+  BOOST_FORCEINLINE
+  auto erase(Key&& x) -> typename std::enable_if<
+    !std::is_convertible<Key,iterator>::value&&
+    !std::is_convertible<Key,const_iterator>::value, std::size_t>::type
+  {
+    auto it=find(x);
+    if(it!=end()){
+      erase(it);
+      return 1;
+    }
+    else return 0;
+  }
+
+  void swap(table& x)
+    noexcept(noexcept(std::declval<super&>().swap(std::declval<super&>())))
+  {
+    super::swap(x);
+  }
+
+  using super::clear;
+
+  element_type extract(const_iterator pos)
+  {
+    BOOST_ASSERT(pos!=end());
+    erase_on_exit e{*this,pos};
+    (void)e;
+    return std::move(*pos.p);
+  }
+
+  // TODO: should we accept different allocator too?
+  template<typename Hash2,typename Pred2>
+  void merge(table<TypePolicy,Hash2,Pred2,Allocator>& x)
+  {
+    x.for_all_elements([&,this](group_type* pg,unsigned int n,element_type* p){
+      erase_on_exit e{x,{pg,n,p}};
+      if(!emplace_impl(type_policy::move(*p)).second)e.rollback();
+    });
+  }
+
+  template<typename Hash2,typename Pred2>
+  void merge(table<TypePolicy,Hash2,Pred2,Allocator>&& x){merge(x);}
+
+  using super::hash_function;
+  using super::key_eq;
+
+  template<typename Key>
+  BOOST_FORCEINLINE iterator find(const Key& x)
+  {
+    auto hash=this->hash_for(x);
+    return find_impl(x,this->position_for(hash),hash);
+  }
+
+  template<typename Key>
+  BOOST_FORCEINLINE const_iterator find(const Key& x)const
+  {
+    return const_cast<table*>(this)->find(x);
+  }
+
+  using super::capacity;
+  using super::load_factor;
+  using super::max_load_factor;
+  using super::max_load;
+  using super::rehash;
+  using super::reserve;
+
+  template<typename Predicate>
+  friend std::size_t erase_if(table& x,Predicate& pr)
+  {
+    using value_reference=typename std::conditional<
+      std::is_same<key_type,value_type>::value,
+      const_reference,
+      reference
+    >::type;
+
+    std::size_t s=x.size();
+    x.for_all_elements(
+      [&](group_type* pg,unsigned int n,element_type* p){
+        if(pr(const_cast<value_reference>(type_policy::value_from(*p)))){
+          x.super::erase(pg,n,p);
+        }
+      });
+    return std::size_t(s-x.size());
+  }
+
+private:
+  struct erase_on_exit
+  {
+    erase_on_exit(table& x_,const_iterator it_):x{x_},it{it_}{}
+    ~erase_on_exit(){if(!rollback_)x.erase(it);}
+
+    void rollback(){rollback_=true;}
+
+    table&         x;
+    const_iterator it;
+    bool           rollback_=false;
+  };
+
+  static inline iterator make_iterator(const locator& l)noexcept
+  {
+    return {l.pg,l.n,l.p};
+  }
+
+#if defined(BOOST_MSVC)
+/* warning: forcing value to bool 'true' or 'false' in bool(pred()...) */
+#pragma warning(push)
+#pragma warning(disable:4800)
+#endif
+
+  template<typename Key>
+  BOOST_FORCEINLINE iterator find_impl(
+    const Key& x,std::size_t pos0,std::size_t hash)const
+  {    
+    prober pb(pos0);
+    do{
+      auto pos=pb.get();
+      auto pg=this->arrays.groups+pos;
+      auto mask=pg->match(hash);
+      if(mask){
+        BOOST_UNORDERED_ASSUME(this->arrays.elements!=nullptr);
+        auto p=this->arrays.elements+pos*N;
+        this->prefetch_elements(p);
+        do{
+          auto n=unchecked_countr_zero(mask);
+          if(BOOST_LIKELY(bool(this->pred()(x,this->key_from(p[n]))))){
+            return {pg,n,p+n};
+          }
+          mask&=mask-1;
+        }while(mask);
+      }
+      if(BOOST_LIKELY(pg->is_not_overflowed(hash))){
+        return {}; /* end() */
+      }
+    }
+    while(BOOST_LIKELY(pb.next(this->arrays.groups_size_mask)));
+    return {}; /* end() */
+  }
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop) /* C4800 */
+#endif
+
+  template<typename... Args>
+  BOOST_FORCEINLINE std::pair<iterator,bool> emplace_impl(Args&&... args)
+  {
+    const auto &k=this->key_from(std::forward<Args>(args)...);
+    auto        hash=this->hash_for(k);
+    auto        pos0=this->position_for(hash);
+    auto        it=find_impl(k,pos0,hash);
+
+    if(it!=end()){
+      return {it,false};
+    }
+    if(BOOST_LIKELY(this->size_<this->ml)){
+      return {
+        make_iterator(
+          this->unchecked_emplace_at(pos0,hash,std::forward<Args>(args)...)),
+        true
+      };  
+    }
+    else{
+      return {
+        make_iterator(
+          this->unchecked_emplace_with_rehash(
+            hash,std::forward<Args>(args)...)),
+        true
+      };  
+    }
+  }
+};
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop) /* C4714 */
+#endif
+
+#include <boost/unordered/detail/foa/restore_wshadow.hpp>
+
+} /* namespace foa */
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif

include/boost/unordered/detail/foa/tuple_rotate_right.hpp

@@ -0,0 +1,52 @@
+/* Copyright 2023 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_FOA_TUPLE_ROTATE_RIGHT_HPP
+#define BOOST_UNORDERED_DETAIL_FOA_TUPLE_ROTATE_RIGHT_HPP
+
+#include <boost/mp11/algorithm.hpp>
+#include <boost/mp11/integer_sequence.hpp>
+#include <tuple>
+#include <utility>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+namespace foa{
+
+template<typename Tuple>
+using tuple_rotate_right_return_type=mp11::mp_rotate_right_c<
+  typename std::remove_cv<typename std::remove_reference<Tuple>::type>::type,
+  1
+>;
+
+template<std::size_t... Is,typename Tuple>
+tuple_rotate_right_return_type<Tuple>
+tuple_rotate_right_aux(mp11::index_sequence<Is...>,Tuple&& x)
+{
+  return tuple_rotate_right_return_type<Tuple>{
+    std::get<(Is+sizeof...(Is)-1)%sizeof...(Is)>(std::forward<Tuple>(x))...};
+}
+
+template<typename Tuple>
+tuple_rotate_right_return_type<Tuple> tuple_rotate_right(Tuple&& x)
+{
+  using RawTuple=typename std::remove_cv<
+    typename std::remove_reference<Tuple>::type>::type;
+
+  return tuple_rotate_right_aux(
+    mp11::make_index_sequence<std::tuple_size<RawTuple>::value>{},
+    std::forward<Tuple>(x));
+}
+
+} /* namespace foa */
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif

include/boost/unordered/detail/fwd.hpp

@@ -61,4 +61,90 @@ namespace boost {
   }
 }
 
+// BOOST_UNORDERED_EMPLACE_LIMIT = The maximum number of parameters in
+// emplace (not including things like hints). Don't set it to a lower value, as
+// that might break something.
+
+#if !defined BOOST_UNORDERED_EMPLACE_LIMIT
+#define BOOST_UNORDERED_EMPLACE_LIMIT 10
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+// Configuration
+//
+// Unless documented elsewhere these configuration macros should be considered
+// an implementation detail, I'll try not to break them, but you never know.
+
+// Use Sun C++ workarounds
+// I'm not sure which versions of the compiler require these workarounds, so
+// I'm just using them of everything older than the current test compilers
+// (as of May 2017).
+
+#if !defined(BOOST_UNORDERED_SUN_WORKAROUNDS1)
+#if BOOST_COMP_SUNPRO && BOOST_COMP_SUNPRO < BOOST_VERSION_NUMBER(5, 20, 0)
+#define BOOST_UNORDERED_SUN_WORKAROUNDS1 1
+#else
+#define BOOST_UNORDERED_SUN_WORKAROUNDS1 0
+#endif
+#endif
+
+// BOOST_UNORDERED_TUPLE_ARGS
+//
+// Maximum number of std::tuple members to support, or 0 if std::tuple
+// isn't avaiable. More are supported when full C++11 is used.
+
+// Already defined, so do nothing
+#if defined(BOOST_UNORDERED_TUPLE_ARGS)
+
+// Assume if we have C++11 tuple it's properly variadic,
+// and just use a max number of 10 arguments.
+#elif !defined(BOOST_NO_CXX11_HDR_TUPLE)
+#define BOOST_UNORDERED_TUPLE_ARGS 10
+
+// Visual C++ has a decent enough tuple for piecewise construction,
+// so use that if available, using _VARIADIC_MAX for the maximum
+// number of parameters. Note that this comes after the check
+// for a full C++11 tuple.
+#elif defined(BOOST_MSVC)
+#if !BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
+#define BOOST_UNORDERED_TUPLE_ARGS 0
+#elif defined(_VARIADIC_MAX)
+#define BOOST_UNORDERED_TUPLE_ARGS _VARIADIC_MAX
+#else
+#define BOOST_UNORDERED_TUPLE_ARGS 5
+#endif
+
+// Assume that we don't have std::tuple
+#else
+#define BOOST_UNORDERED_TUPLE_ARGS 0
+#endif
+
+#if BOOST_UNORDERED_TUPLE_ARGS
+#include <tuple>
+#endif
+
+// BOOST_UNORDERED_CXX11_CONSTRUCTION
+//
+// Use C++11 construction, requires variadic arguments, good construct support
+// in allocator_traits and piecewise construction of std::pair
+// Otherwise allocators aren't used for construction/destruction
+
+#if BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT &&                                \
+  !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && BOOST_UNORDERED_TUPLE_ARGS
+#if BOOST_COMP_SUNPRO && BOOST_LIB_STD_GNU
+// Sun C++ std::pair piecewise construction doesn't seem to be exception safe.
+// (At least for Sun C++ 12.5 using libstdc++).
+#define BOOST_UNORDERED_CXX11_CONSTRUCTION 0
+#elif BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 7, 0)
+// Piecewise construction in GCC 4.6 doesn't work for uncopyable types.
+#define BOOST_UNORDERED_CXX11_CONSTRUCTION 0
+#elif !defined(BOOST_NO_CXX11_ALLOCATOR)
+#define BOOST_UNORDERED_CXX11_CONSTRUCTION 1
+#endif
+#endif
+
+#if !defined(BOOST_UNORDERED_CXX11_CONSTRUCTION)
+#define BOOST_UNORDERED_CXX11_CONSTRUCTION 0
+#endif
+
 #endif

include/boost/unordered/detail/implementation.hpp

@@ -60,92 +60,6 @@
 #include <type_traits>
 #endif
 
-////////////////////////////////////////////////////////////////////////////////
-// Configuration
-//
-// Unless documented elsewhere these configuration macros should be considered
-// an implementation detail, I'll try not to break them, but you never know.
-
-// Use Sun C++ workarounds
-// I'm not sure which versions of the compiler require these workarounds, so
-// I'm just using them of everything older than the current test compilers
-// (as of May 2017).
-
-#if !defined(BOOST_UNORDERED_SUN_WORKAROUNDS1)
-#if BOOST_COMP_SUNPRO && BOOST_COMP_SUNPRO < BOOST_VERSION_NUMBER(5, 20, 0)
-#define BOOST_UNORDERED_SUN_WORKAROUNDS1 1
-#else
-#define BOOST_UNORDERED_SUN_WORKAROUNDS1 0
-#endif
-#endif
-
-// BOOST_UNORDERED_EMPLACE_LIMIT = The maximum number of parameters in
-// emplace (not including things like hints). Don't set it to a lower value, as
-// that might break something.
-
-#if !defined BOOST_UNORDERED_EMPLACE_LIMIT
-#define BOOST_UNORDERED_EMPLACE_LIMIT 10
-#endif
-
-// BOOST_UNORDERED_TUPLE_ARGS
-//
-// Maximum number of std::tuple members to support, or 0 if std::tuple
-// isn't avaiable. More are supported when full C++11 is used.
-
-// Already defined, so do nothing
-#if defined(BOOST_UNORDERED_TUPLE_ARGS)
-
-// Assume if we have C++11 tuple it's properly variadic,
-// and just use a max number of 10 arguments.
-#elif !defined(BOOST_NO_CXX11_HDR_TUPLE)
-#define BOOST_UNORDERED_TUPLE_ARGS 10
-
-// Visual C++ has a decent enough tuple for piecewise construction,
-// so use that if available, using _VARIADIC_MAX for the maximum
-// number of parameters. Note that this comes after the check
-// for a full C++11 tuple.
-#elif defined(BOOST_MSVC)
-#if !BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
-#define BOOST_UNORDERED_TUPLE_ARGS 0
-#elif defined(_VARIADIC_MAX)
-#define BOOST_UNORDERED_TUPLE_ARGS _VARIADIC_MAX
-#else
-#define BOOST_UNORDERED_TUPLE_ARGS 5
-#endif
-
-// Assume that we don't have std::tuple
-#else
-#define BOOST_UNORDERED_TUPLE_ARGS 0
-#endif
-
-#if BOOST_UNORDERED_TUPLE_ARGS
-#include <tuple>
-#endif
-
-// BOOST_UNORDERED_CXX11_CONSTRUCTION
-//
-// Use C++11 construction, requires variadic arguments, good construct support
-// in allocator_traits and piecewise construction of std::pair
-// Otherwise allocators aren't used for construction/destruction
-
-#if BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT &&                                \
-  !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && BOOST_UNORDERED_TUPLE_ARGS
-#if BOOST_COMP_SUNPRO && BOOST_LIB_STD_GNU
-// Sun C++ std::pair piecewise construction doesn't seem to be exception safe.
-// (At least for Sun C++ 12.5 using libstdc++).
-#define BOOST_UNORDERED_CXX11_CONSTRUCTION 0
-#elif BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 7, 0)
-// Piecewise construction in GCC 4.6 doesn't work for uncopyable types.
-#define BOOST_UNORDERED_CXX11_CONSTRUCTION 0
-#elif !defined(BOOST_NO_CXX11_ALLOCATOR)
-#define BOOST_UNORDERED_CXX11_CONSTRUCTION 1
-#endif
-#endif
-
-#if !defined(BOOST_UNORDERED_CXX11_CONSTRUCTION)
-#define BOOST_UNORDERED_CXX11_CONSTRUCTION 0
-#endif
-
 #if BOOST_UNORDERED_CXX11_CONSTRUCTION
 #include <boost/mp11/list.hpp>
 #include <boost/mp11/algorithm.hpp>
@@ -1477,7 +1391,22 @@ namespace boost {
         }
 
 #endif
-      }
+
+        template <typename T, typename Alloc, typename Key>
+        inline typename boost::allocator_pointer<Alloc>::type
+        construct_node_from_key(T*, Alloc& alloc, BOOST_FWD_REF(Key) k)
+        {
+          return construct_node(alloc, boost::forward<Key>(k));
+        }
+
+        template <typename T, typename V, typename Alloc, typename Key>
+        inline typename boost::allocator_pointer<Alloc>::type
+        construct_node_from_key(
+          std::pair<T const, V>*, Alloc& alloc, BOOST_FWD_REF(Key) k)
+        {
+          return construct_node_pair(alloc, boost::forward<Key>(k));
+        }
+      } // namespace func
     }
   }
 }
@@ -2640,8 +2569,10 @@ namespace boost {
           } else {
             node_allocator_type alloc = node_alloc();
 
-            node_tmp tmp(
-              detail::func::construct_node_pair(alloc, boost::forward<Key>(k)),
+            value_type* dispatch = BOOST_NULLPTR;
+
+            node_tmp tmp(detail::func::construct_node_from_key(
+                           dispatch, alloc, boost::forward<Key>(k)),
               alloc);
 
             if (size_ + 1 > max_load_) {
@@ -2660,7 +2591,7 @@ namespace boost {
         template <typename Key>
         iterator try_emplace_hint_unique(c_iterator hint, BOOST_FWD_REF(Key) k)
         {
-          if (hint.p && this->key_eq()(hint->first, k)) {
+          if (hint.p && this->key_eq()(extractor::extract(*hint), k)) {
             return iterator(hint.p, hint.itb);
           } else {
             return try_emplace_unique(k).first;

include/boost/unordered/detail/mulx.hpp

@@ -0,0 +1,129 @@
+#ifndef BOOST_UNORDERED_DETAIL_MULX_HPP
+#define BOOST_UNORDERED_DETAIL_MULX_HPP
+
+// Copyright 2022 Peter Dimov.
+// Copyright 2022 Joaquin M Lopez Munoz.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/cstdint.hpp>
+#include <climits>
+#include <cstddef>
+
+#if defined(_MSC_VER) && !defined(__clang__)
+# include <intrin.h>
+#endif
+
+namespace boost {
+namespace unordered {
+namespace detail {
+
+// Bit mixer based on the mulx primitive
+
+#if defined(_MSC_VER) && defined(_M_X64) && !defined(__clang__)
+
+__forceinline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
+{
+    boost::uint64_t r2;
+    boost::uint64_t r = _umul128( x, y, &r2 );
+    return r ^ r2;
+}
+
+#elif defined(_MSC_VER) && defined(_M_ARM64) && !defined(__clang__)
+
+__forceinline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
+{
+    boost::uint64_t r = x * y;
+    boost::uint64_t r2 = __umulh( x, y );
+    return r ^ r2;
+}
+
+#elif defined(__SIZEOF_INT128__)
+
+inline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
+{
+    __uint128_t r = (__uint128_t)x * y;
+    return (boost::uint64_t)r ^ (boost::uint64_t)( r >> 64 );
+}
+
+#else
+
+inline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
+{
+    boost::uint64_t x1 = (boost::uint32_t)x;
+    boost::uint64_t x2 = x >> 32;
+
+    boost::uint64_t y1 = (boost::uint32_t)y;
+    boost::uint64_t y2 = y >> 32;
+
+    boost::uint64_t r3 = x2 * y2;
+
+    boost::uint64_t r2a = x1 * y2;
+
+    r3 += r2a >> 32;
+
+    boost::uint64_t r2b = x2 * y1;
+
+    r3 += r2b >> 32;
+
+    boost::uint64_t r1 = x1 * y1;
+
+    boost::uint64_t r2 = (r1 >> 32) + (boost::uint32_t)r2a + (boost::uint32_t)r2b;
+
+    r1 = (r2 << 32) + (boost::uint32_t)r1;
+    r3 += r2 >> 32;
+
+    return r1 ^ r3;
+}
+
+#endif
+
+inline boost::uint32_t mulx32( boost::uint32_t x, boost::uint32_t y )
+{
+    boost::uint64_t r = (boost::uint64_t)x * y;
+
+#if defined(__MSVC_RUNTIME_CHECKS)
+
+    return (boost::uint32_t)(r & UINT32_MAX) ^ (boost::uint32_t)(r >> 32);
+
+#else
+
+    return (boost::uint32_t)r ^ (boost::uint32_t)(r >> 32);
+
+#endif
+}
+
+#if defined(SIZE_MAX)
+#if ((((SIZE_MAX >> 16) >> 16) >> 16) >> 15) != 0
+#define BOOST_UNORDERED_64B_ARCHITECTURE /* >64 bits assumed as 64 bits */
+#endif
+#elif defined(UINTPTR_MAX) /* used as proxy for std::size_t */
+#if ((((UINTPTR_MAX >> 16) >> 16) >> 16) >> 15) != 0
+#define BOOST_UNORDERED_64B_ARCHITECTURE
+#endif
+#endif
+
+inline std::size_t mulx( std::size_t x ) noexcept
+{
+#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
+
+    // multiplier is phi
+    return (std::size_t)mulx64( (boost::uint64_t)x, 0x9E3779B97F4A7C15ull );
+
+#else /* 32 bits assumed */
+
+    // multiplier from https://arxiv.org/abs/2001.05304
+    return mulx32( x, 0xE817FB2Du );
+
+#endif
+}
+
+#ifdef BOOST_UNORDERED_64B_ARCHITECTURE
+#undef BOOST_UNORDERED_64B_ARCHITECTURE
+#endif
+
+} // namespace detail
+} // namespace unordered
+} // namespace boost
+
+#endif // #ifndef BOOST_UNORDERED_DETAIL_MULX_HPP

include/boost/unordered/detail/narrow_cast.hpp

@@ -0,0 +1,44 @@
+/* Copyright 2022 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_NARROW_CAST_HPP
+#define BOOST_UNORDERED_DETAIL_NARROW_CAST_HPP
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/make_unsigned.hpp>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+
+template<typename To,typename From>
+BOOST_CONSTEXPR To narrow_cast(From x) BOOST_NOEXCEPT
+{
+  BOOST_STATIC_ASSERT(boost::is_integral<From>::value);
+  BOOST_STATIC_ASSERT(boost::is_integral<To>::value);
+  BOOST_STATIC_ASSERT(sizeof(From)>=sizeof(To));
+
+  return static_cast<To>(
+    x
+
+#if defined(__MSVC_RUNTIME_CHECKS)
+    /* Avoids VS's "Run-Time Check Failure #1 - A cast to a smaller data type
+     * has caused a loss of data."
+     */
+    &static_cast<typename boost::make_unsigned<To>::type>(~static_cast<To>(0))
+#endif
+  );
+}
+
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif

include/boost/unordered/detail/prime_fmod.hpp

@@ -11,6 +11,7 @@
 #include <boost/preprocessor/seq/enum.hpp>
 #include <boost/preprocessor/seq/for_each.hpp>
 #include <boost/preprocessor/seq/size.hpp>
+#include <boost/unordered/detail/narrow_cast.hpp>
 
 #include <boost/config.hpp>
 
@@ -117,15 +118,9 @@ namespace boost {
 #if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
           std::size_t sizes_under_32bit = inv_sizes32_len;
           if (BOOST_LIKELY(size_index < sizes_under_32bit)) {
-#if defined(__MSVC_RUNTIME_CHECKS)
             return fast_modulo(
-              boost::uint32_t(hash & 0xffffffffu) + boost::uint32_t(hash >> 32),
+              narrow_cast<boost::uint32_t>(hash) + narrow_cast<boost::uint32_t>(hash >> 32),
               inv_sizes32[size_index], boost::uint32_t(sizes[size_index]));
-#else
-            return fast_modulo(
-              boost::uint32_t(hash) + boost::uint32_t(hash >> 32),
-              inv_sizes32[size_index], boost::uint32_t(sizes[size_index]));
-#endif
           } else {
             return positions[size_index - sizes_under_32bit](hash);
           }

include/boost/unordered/detail/requires_cxx11.hpp

@@ -0,0 +1,21 @@
+#ifndef BOOST_UNORDERED_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
+#define BOOST_UNORDERED_DETAIL_REQUIRES_CXX11_HPP_INCLUDED
+
+// Copyright 2023 Peter Dimov
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/config.hpp>
+#include <boost/config/pragma_message.hpp>
+
+#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || \
+    defined(BOOST_NO_CXX11_RVALUE_REFERENCES) || \
+    defined(BOOST_NO_CXX11_DECLTYPE) || \
+    defined(BOOST_NO_CXX11_CONSTEXPR) || \
+    defined(BOOST_NO_CXX11_NOEXCEPT)
+
+BOOST_PRAGMA_MESSAGE("C++03 support is deprecated in Boost.Unordered 1.82 and will be removed in Boost.Unordered 1.84.")
+
+#endif
+
+#endif // #ifndef BOOST_UNORDERED_DETAIL_REQUIRES_CXX11_HPP_INCLUDED

include/boost/unordered/detail/type_traits.hpp

@@ -53,10 +53,10 @@ namespace boost {
       {
       };
 
-      template <class, class A, class B> struct are_transparent
+      template <class, class Hash, class KeyEqual> struct are_transparent
       {
         static bool const value =
-          is_transparent<A>::value && is_transparent<B>::value;
+          is_transparent<Hash>::value && is_transparent<KeyEqual>::value;
       };
 
       template <class Key, class UnorderedMap> struct transparent_non_iterable

include/boost/unordered/unordered_flat_map.hpp

@@ -10,7 +10,7 @@
 #pragma once
 #endif
 
-#include <boost/unordered/detail/foa.hpp>
+#include <boost/unordered/detail/foa/table.hpp>
 #include <boost/unordered/detail/type_traits.hpp>
 #include <boost/unordered/unordered_flat_map_fwd.hpp>
 
@@ -32,10 +32,8 @@ namespace boost {
 #pragma warning(disable : 4714) /* marked as __forceinline not inlined */
 #endif
 
-    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
-    class unordered_flat_map
-    {
-      struct map_types
+    namespace detail {
+      template <class Key, class T> struct flat_map_types
       {
         using key_type = Key;
         using raw_key_type = typename std::remove_const<Key>::type;
@@ -45,19 +43,56 @@ namespace boost {
         using moved_type = std::pair<raw_key_type&&, raw_mapped_type&&>;
         using value_type = std::pair<Key const, T>;
 
+        using element_type = value_type;
+
+        static value_type& value_from(element_type& x) { return x; }
+
         template <class K, class V>
         static raw_key_type const& extract(std::pair<K, V> const& kv)
         {
           return kv.first;
         }
 
-        static moved_type move(value_type& x)
+        static moved_type move(init_type& x)
+        {
+          return {std::move(x.first), std::move(x.second)};
+        }
+
+        static moved_type move(element_type& x)
         {
           // TODO: we probably need to launder here
           return {std::move(const_cast<raw_key_type&>(x.first)),
             std::move(const_cast<raw_mapped_type&>(x.second))};
         }
+
+        template <class A, class... Args>
+        static void construct(A& al, init_type* p, Args&&... args)
+        {
+          boost::allocator_construct(al, p, std::forward<Args>(args)...);
+        }
+
+        template <class A, class... Args>
+        static void construct(A& al, value_type* p, Args&&... args)
+        {
+          boost::allocator_construct(al, p, std::forward<Args>(args)...);
+        }
+
+        template <class A> static void destroy(A& al, init_type* p) noexcept
+        {
+          boost::allocator_destroy(al, p);
+        }
+
+        template <class A> static void destroy(A& al, value_type* p) noexcept
+        {
+          boost::allocator_destroy(al, p);
+        }
       };
+    } // namespace detail
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    class unordered_flat_map
+    {
+      using map_types = detail::flat_map_types<Key, T>;
 
       using table_type = detail::foa::table<map_types, Hash, KeyEqual,
         typename boost::allocator_rebind<Allocator,
@@ -278,24 +313,37 @@ namespace boost {
       template <class M>
       std::pair<iterator, bool> insert_or_assign(key_type const& key, M&& obj)
       {
-        auto iter_bool_pair = table_.try_emplace(key, std::forward<M>(obj));
-        if (iter_bool_pair.second) {
-          return iter_bool_pair;
+        auto ibp = table_.try_emplace(key, std::forward<M>(obj));
+        if (ibp.second) {
+          return ibp;
         }
-        iter_bool_pair.first->second = std::forward<M>(obj);
-        return iter_bool_pair;
+        ibp.first->second = std::forward<M>(obj);
+        return ibp;
       }
 
       template <class M>
       std::pair<iterator, bool> insert_or_assign(key_type&& key, M&& obj)
       {
-        auto iter_bool_pair =
-          table_.try_emplace(std::move(key), std::forward<M>(obj));
-        if (iter_bool_pair.second) {
-          return iter_bool_pair;
+        auto ibp = table_.try_emplace(std::move(key), std::forward<M>(obj));
+        if (ibp.second) {
+          return ibp;
         }
-        iter_bool_pair.first->second = std::forward<M>(obj);
-        return iter_bool_pair;
+        ibp.first->second = std::forward<M>(obj);
+        return ibp;
+      }
+
+      template <class K, class M>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        std::pair<iterator, bool> >::type
+      insert_or_assign(K&& k, M&& obj)
+      {
+        auto ibp = table_.try_emplace(std::forward<K>(k), std::forward<M>(obj));
+        if (ibp.second) {
+          return ibp;
+        }
+        ibp.first->second = std::forward<M>(obj);
+        return ibp;
       }
 
       template <class M>
@@ -311,6 +359,16 @@ namespace boost {
           .first;
       }
 
+      template <class K, class M>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        iterator>::type
+      insert_or_assign(const_iterator, K&& k, M&& obj)
+      {
+        return this->insert_or_assign(std::forward<K>(k), std::forward<M>(obj))
+          .first;
+      }
+
       template <class... Args>
       BOOST_FORCEINLINE std::pair<iterator, bool> emplace(Args&&... args)
       {
@@ -337,6 +395,17 @@ namespace boost {
         return table_.try_emplace(std::move(key), std::forward<Args>(args)...);
       }
 
+      template <class K, class... Args>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::transparent_non_iterable<K,
+          unordered_flat_map>::value,
+        std::pair<iterator, bool> >::type
+      try_emplace(K&& key, Args&&... args)
+      {
+        return table_.try_emplace(
+          std::forward<K>(key), std::forward<Args>(args)...);
+      }
+
       template <class... Args>
       BOOST_FORCEINLINE iterator try_emplace(
         const_iterator, key_type const& key, Args&&... args)
@@ -352,6 +421,18 @@ namespace boost {
           .first;
       }
 
+      template <class K, class... Args>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::transparent_non_iterable<K,
+          unordered_flat_map>::value,
+        iterator>::type
+      try_emplace(const_iterator, K&& key, Args&&... args)
+      {
+        return table_
+          .try_emplace(std::forward<K>(key), std::forward<Args>(args)...)
+          .first;
+      }
+
       BOOST_FORCEINLINE void erase(iterator pos) { table_.erase(pos); }
       BOOST_FORCEINLINE void erase(const_iterator pos)
       {
@@ -427,6 +508,34 @@ namespace boost {
           std::out_of_range("key was not found in unordered_flat_map"));
       }
 
+      template <class K>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        mapped_type&>::type
+      at(K&& key)
+      {
+        auto pos = table_.find(std::forward<K>(key));
+        if (pos != table_.end()) {
+          return pos->second;
+        }
+        boost::throw_exception(
+          std::out_of_range("key was not found in unordered_flat_map"));
+      }
+
+      template <class K>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        mapped_type const&>::type
+      at(K&& key) const
+      {
+        auto pos = table_.find(std::forward<K>(key));
+        if (pos != table_.end()) {
+          return pos->second;
+        }
+        boost::throw_exception(
+          std::out_of_range("key was not found in unordered_flat_map"));
+      }
+
       BOOST_FORCEINLINE mapped_type& operator[](key_type const& key)
       {
         return table_.try_emplace(key).first->second;
@@ -437,6 +546,15 @@ namespace boost {
         return table_.try_emplace(std::move(key)).first->second;
       }
 
+      template <class K>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        mapped_type&>::type
+      operator[](K&& key)
+      {
+        return table_.try_emplace(std::forward<K>(key)).first->second;
+      }
+
       BOOST_FORCEINLINE size_type count(key_type const& key) const
       {
         auto pos = table_.find(key);

include/boost/unordered/unordered_flat_set.hpp

@@ -10,7 +10,7 @@
 #pragma once
 #endif
 
-#include <boost/unordered/detail/foa.hpp>
+#include <boost/unordered/detail/foa/table.hpp>
 #include <boost/unordered/detail/type_traits.hpp>
 #include <boost/unordered/unordered_flat_set_fwd.hpp>
 
@@ -30,17 +30,38 @@ namespace boost {
 #pragma warning(disable : 4714) /* marked as __forceinline not inlined */
 #endif
 
-    template <class Key, class Hash, class KeyEqual, class Allocator>
-    class unordered_flat_set
-    {
-      struct set_types
+    namespace detail {
+      template <class Key> struct flat_set_types
       {
         using key_type = Key;
         using init_type = Key;
         using value_type = Key;
+
         static Key const& extract(value_type const& key) { return key; }
-        static Key&& move(value_type& x) { return std::move(x); }
+
+        using element_type = value_type;
+
+        static Key& value_from(element_type& x) { return x; }
+
+        static element_type&& move(element_type& x) { return std::move(x); }
+
+        template <class A, class... Args>
+        static void construct(A& al, value_type* p, Args&&... args)
+        {
+          boost::allocator_construct(al, p, std::forward<Args>(args)...);
+        }
+
+        template <class A> static void destroy(A& al, value_type* p) noexcept
+        {
+          boost::allocator_destroy(al, p);
+        }
       };
+    } // namespace detail
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    class unordered_flat_set
+    {
+      using set_types = detail::flat_set_types<Key>;
 
       using table_type = detail::foa::table<set_types, Hash, KeyEqual,
         typename boost::allocator_rebind<Allocator,
@@ -231,6 +252,15 @@ namespace boost {
         return table_.insert(std::move(value));
       }
 
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::transparent_non_iterable<K, unordered_flat_set>::value,
+        std::pair<iterator, bool> >::type
+      insert(K&& k)
+      {
+        return table_.try_emplace(std::forward<K>(k));
+      }
+
       BOOST_FORCEINLINE iterator insert(const_iterator, value_type const& value)
       {
         return table_.insert(value).first;
@@ -241,6 +271,15 @@ namespace boost {
         return table_.insert(std::move(value)).first;
       }
 
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::transparent_non_iterable<K, unordered_flat_set>::value,
+        iterator>::type
+      insert(const_iterator, K&& k)
+      {
+        return table_.try_emplace(std::forward<K>(k)).first;
+      }
+
       template <class InputIterator>
       void insert(InputIterator first, InputIterator last)
       {

include/boost/unordered/unordered_map.hpp

@@ -15,6 +15,7 @@
 #pragma once
 #endif
 
+#include <boost/unordered/detail/requires_cxx11.hpp>
 #include <boost/core/explicit_operator_bool.hpp>
 #include <boost/functional/hash.hpp>
 #include <boost/move/move.hpp>
@@ -486,6 +487,16 @@ namespace boost {
           boost::move(k), boost::forward<Args>(args)...);
       }
 
+      template <class Key, class... Args>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_map>::value,
+        std::pair<iterator, bool> >::type
+      try_emplace(Key&& k, Args&&... args)
+      {
+        return table_.try_emplace_unique(
+          boost::forward<Key>(k), boost::forward<Args>(args)...);
+      }
+
       template <class... Args>
       iterator try_emplace(
         const_iterator hint, key_type const& k, BOOST_FWD_REF(Args)... args)
@@ -502,6 +513,16 @@ namespace boost {
           hint, boost::move(k), boost::forward<Args>(args)...);
       }
 
+      template <class Key, class... Args>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_map>::value,
+        iterator>::type
+      try_emplace(const_iterator hint, Key&& k, Args&&... args)
+      {
+        return table_.try_emplace_hint_unique(
+          hint, boost::forward<Key>(k), boost::forward<Args>(args)...);
+      }
+
 #else
 
       // In order to make this a template, this handles both:
@@ -582,6 +603,43 @@ namespace boost {
             boost::forward<A1>(a1), boost::forward<A2>(a2)));
       }
 
+      // try_emplace(Key&&, Args&&...)
+
+      template <typename Key, typename A0>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_map>::value,
+        std::pair<iterator, bool> >::type
+      try_emplace(BOOST_FWD_REF(Key) k, BOOST_FWD_REF(A0) a0)
+      {
+        return table_.try_emplace_unique(
+          boost::forward<Key>(k), boost::unordered::detail::create_emplace_args(
+                                    boost::forward<A0>(a0)));
+      }
+
+      template <typename Key, typename A0, typename A1>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_map>::value,
+        std::pair<iterator, bool> >::type
+      try_emplace(
+        BOOST_FWD_REF(Key) k, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+      {
+        return table_.try_emplace_unique(boost::forward<Key>(k),
+          boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)));
+      }
+
+      template <typename Key, typename A0, typename A1, typename A2>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_map>::value,
+        std::pair<iterator, bool> >::type
+      try_emplace(BOOST_FWD_REF(Key) k, BOOST_FWD_REF(A0) a0,
+        BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+      {
+        return table_.try_emplace_unique(boost::forward<Key>(k),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
+
       // try_emplace(const_iterator hint, key const&, Args&&...)
 
       template <typename A0>
@@ -640,6 +698,44 @@ namespace boost {
             boost::forward<A1>(a1), boost::forward<A2>(a2)));
       }
 
+      // try_emplace(const_iterator hint, Key&&, Args&&...)
+
+      template <typename Key, typename A0>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_map>::value,
+        iterator>::type
+      try_emplace(
+        const_iterator hint, BOOST_FWD_REF(Key) k, BOOST_FWD_REF(A0) a0)
+      {
+        return table_.try_emplace_hint_unique(hint, boost::forward<Key>(k),
+          boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0)));
+      }
+
+      template <typename Key, typename A0, typename A1>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_map>::value,
+        iterator>::type
+      try_emplace(const_iterator hint, BOOST_FWD_REF(Key) k,
+        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+      {
+        return table_.try_emplace_hint_unique(hint, boost::forward<Key>(k),
+          boost::unordered::detail::create_emplace_args(
+            boost::forward<A0>(a0), boost::forward<A1>(a1)));
+      }
+
+      template <typename Key, typename A0, typename A1, typename A2>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_map>::value,
+        iterator>::type
+      try_emplace(const_iterator hint, BOOST_FWD_REF(Key) k,
+        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+      {
+        return table_.try_emplace_hint_unique(hint, boost::forward<Key>(k),
+          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
+            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+      }
+
 #define BOOST_UNORDERED_TRY_EMPLACE(z, n, _)                                   \
                                                                                \
   template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                          \
@@ -706,6 +802,15 @@ namespace boost {
           boost::move(k), boost::forward<M>(obj));
       }
 
+      template <class Key, class M>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        std::pair<iterator, bool> >::type
+      insert_or_assign(BOOST_FWD_REF(Key) k, BOOST_FWD_REF(M) obj)
+      {
+        return table_.insert_or_assign_unique(
+          boost::forward<Key>(k), boost::forward<M>(obj));
+      }
+
       template <class M>
       iterator insert_or_assign(
         const_iterator, key_type const& k, BOOST_FWD_REF(M) obj)
@@ -722,6 +827,18 @@ namespace boost {
           .first;
       }
 
+      template <class Key, class M>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        iterator>::type
+      insert_or_assign(
+        const_iterator, BOOST_FWD_REF(Key) k, BOOST_FWD_REF(M) obj)
+      {
+        return table_
+          .insert_or_assign_unique(
+            boost::forward<Key>(k), boost::forward<M>(obj))
+          .first;
+      }
+
       iterator erase(iterator);
       iterator erase(const_iterator);
       size_type erase(const key_type&);
@@ -856,9 +973,23 @@ namespace boost {
 
       mapped_type& operator[](const key_type&);
       mapped_type& operator[](BOOST_RV_REF(key_type));
+
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        mapped_type&>::type
+      operator[](BOOST_FWD_REF(Key) k);
+
       mapped_type& at(const key_type&);
       mapped_type const& at(const key_type&) const;
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        mapped_type&>::type at(BOOST_FWD_REF(Key) k);
+
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        mapped_type const&>::type at(BOOST_FWD_REF(Key) k) const;
+
       // bucket interface
 
       size_type bucket_count() const BOOST_NOEXCEPT
@@ -878,6 +1009,14 @@ namespace boost {
         return table_.hash_to_bucket(table_.hash(k));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        size_type>::type
+      bucket(BOOST_FWD_REF(Key) k) const
+      {
+        return table_.hash_to_bucket(table_.hash(boost::forward<Key>(k)));
+      }
+
       local_iterator begin(size_type n)
       {
         return table_.begin(n);
@@ -1584,6 +1723,14 @@ namespace boost {
         return table_.hash_to_bucket(table_.hash(k));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        size_type>::type
+      bucket(BOOST_FWD_REF(Key) k) const
+      {
+        return table_.hash_to_bucket(table_.hash(boost::forward<Key>(k)));
+      }
+
       local_iterator begin(size_type n)
       {
         return local_iterator(table_.begin(n));
@@ -2098,6 +2245,15 @@ namespace boost {
       return table_.try_emplace_unique(boost::move(k)).first->second;
     }
 
+    template <class K, class T, class H, class P, class A>
+    template <class Key>
+    typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+      typename unordered_map<K, T, H, P, A>::mapped_type&>::type
+    unordered_map<K, T, H, P, A>::operator[](BOOST_FWD_REF(Key) k)
+    {
+      return table_.try_emplace_unique(boost::forward<Key>(k)).first->second;
+    }
+
     template <class K, class T, class H, class P, class A>
     typename unordered_map<K, T, H, P, A>::mapped_type&
     unordered_map<K, T, H, P, A>::at(const key_type& k)
@@ -2130,6 +2286,42 @@ namespace boost {
         std::out_of_range("Unable to find key in unordered_map."));
     }
 
+    template <class K, class T, class H, class P, class A>
+    template <class Key>
+    typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+      typename unordered_map<K, T, H, P, A>::mapped_type&>::type
+    unordered_map<K, T, H, P, A>::at(BOOST_FWD_REF(Key) k)
+    {
+      typedef typename table::node_pointer node_pointer;
+
+      if (table_.size_) {
+        node_pointer p = table_.find_node(boost::forward<Key>(k));
+        if (p)
+          return p->value().second;
+      }
+
+      boost::throw_exception(
+        std::out_of_range("Unable to find key in unordered_map."));
+    }
+
+    template <class K, class T, class H, class P, class A>
+    template <class Key>
+    typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+      typename unordered_map<K, T, H, P, A>::mapped_type const&>::type
+    unordered_map<K, T, H, P, A>::at(BOOST_FWD_REF(Key) k) const
+    {
+      typedef typename table::node_pointer node_pointer;
+
+      if (table_.size_) {
+        node_pointer p = table_.find_node(boost::forward<Key>(k));
+        if (p)
+          return p->value().second;
+      }
+
+      boost::throw_exception(
+        std::out_of_range("Unable to find key in unordered_map."));
+    }
+
     template <class K, class T, class H, class P, class A>
     typename unordered_map<K, T, H, P, A>::size_type
     unordered_map<K, T, H, P, A>::bucket_size(size_type n) const

include/boost/unordered/unordered_node_map_fwd.hpp

@@ -0,0 +1,49 @@
+
+// Copyright (C) 2022 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_UNORDERED_NODE_MAP_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_NODE_MAP_FWD_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/functional/hash_fwd.hpp>
+#include <boost/unordered/detail/fwd.hpp>
+#include <functional>
+#include <memory>
+
+namespace boost {
+  namespace unordered {
+    template <class Key, class T, class Hash = boost::hash<Key>,
+      class KeyEqual = std::equal_to<Key>,
+      class Allocator = std::allocator<std::pair<const Key, T> > >
+    class unordered_node_map;
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    bool operator==(
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    bool operator!=(
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    void swap(unordered_node_map<Key, T, Hash, KeyEqual, Allocator>& lhs,
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator>& rhs)
+      noexcept(noexcept(lhs.swap(rhs)));
+  } // namespace unordered
+
+  using boost::unordered::unordered_node_map;
+
+  using boost::unordered::swap;
+  using boost::unordered::operator==;
+  using boost::unordered::operator!=;
+} // namespace boost
+
+#endif

include/boost/unordered/unordered_node_set.hpp

@@ -0,0 +1,764 @@
+// Copyright (C) 2022 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_UNORDERED_UNORDERED_NODE_SET_HPP_INCLUDED
+#define BOOST_UNORDERED_UNORDERED_NODE_SET_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/unordered/detail/foa/element_type.hpp>
+#include <boost/unordered/detail/foa/node_handle.hpp>
+#include <boost/unordered/detail/foa/table.hpp>
+#include <boost/unordered/detail/type_traits.hpp>
+#include <boost/unordered/unordered_node_set_fwd.hpp>
+
+#include <boost/core/allocator_access.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <initializer_list>
+#include <iterator>
+#include <type_traits>
+#include <utility>
+
+namespace boost {
+  namespace unordered {
+
+#if defined(BOOST_MSVC)
+#pragma warning(push)
+#pragma warning(disable : 4714) /* marked as __forceinline not inlined */
+#endif
+
+    namespace detail {
+      template <class Key> struct node_set_types
+      {
+        using key_type = Key;
+        using init_type = Key;
+        using value_type = Key;
+
+        static Key const& extract(value_type const& key) { return key; }
+
+        using element_type=foa::element_type<value_type>;
+
+        static value_type& value_from(element_type const& x) { return *x.p; }
+        static Key const& extract(element_type const& k) { return *k.p; }
+        static element_type&& move(element_type& x) { return std::move(x); }
+        static value_type&& move(value_type& x) { return std::move(x); }
+
+        template <class A>
+        static void construct(A& al, element_type* p, element_type const& copy)
+        {
+          construct(al, p, *copy.p);
+        }
+
+        template <typename Allocator>
+        static void construct(
+          Allocator&, element_type* p, element_type&& x) noexcept
+        {
+          p->p = x.p;
+          x.p = nullptr;
+        }
+
+        template <class A, class... Args>
+        static void construct(A& al, value_type* p, Args&&... args)
+        {
+          boost::allocator_construct(al, p, std::forward<Args>(args)...);
+        }
+
+        template <class A, class... Args>
+        static void construct(A& al, element_type* p, Args&&... args)
+        {
+          p->p = boost::to_address(boost::allocator_allocate(al, 1));
+          BOOST_TRY
+          {
+            boost::allocator_construct(al, p->p, std::forward<Args>(args)...);
+          }
+          BOOST_CATCH(...)
+          {
+            boost::allocator_deallocate(al,
+              boost::pointer_traits<
+                typename boost::allocator_pointer<A>::type>::pointer_to(*p->p),
+              1);
+            BOOST_RETHROW
+          }
+          BOOST_CATCH_END
+        }
+
+        template <class A> static void destroy(A& al, value_type* p) noexcept
+        {
+          boost::allocator_destroy(al, p);
+        }
+
+        template <class A> static void destroy(A& al, element_type* p) noexcept
+        {
+          if (p->p) {
+            destroy(al, p->p);
+            boost::allocator_deallocate(al,
+              boost::pointer_traits<typename boost::allocator_pointer<
+                A>::type>::pointer_to(*(p->p)),
+              1);
+          }
+        }
+      };
+
+      template <class TypePolicy, class Allocator>
+      struct node_set_handle
+          : public detail::foa::node_handle_base<TypePolicy, Allocator>
+      {
+      private:
+        using base_type = detail::foa::node_handle_base<TypePolicy, Allocator>;
+
+        using typename base_type::type_policy;
+
+        template <class Key, class Hash, class Pred, class Alloc>
+        friend class boost::unordered::unordered_node_set;
+
+      public:
+        using value_type = typename TypePolicy::value_type;
+
+        constexpr node_set_handle() noexcept = default;
+        node_set_handle(node_set_handle&& nh) noexcept = default;
+        node_set_handle& operator=(node_set_handle&&) noexcept = default;
+
+        value_type& value() const
+        {
+          BOOST_ASSERT(!this->empty());
+          return const_cast<value_type&>(this->data());
+        }
+      };
+    } // namespace detail
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    class unordered_node_set
+    {
+      using set_types = detail::node_set_types<Key>;
+
+      using table_type = detail::foa::table<set_types, Hash, KeyEqual,
+        typename boost::allocator_rebind<Allocator,
+          typename set_types::value_type>::type>;
+
+      table_type table_;
+
+      template <class K, class H, class KE, class A, class Pred>
+      typename unordered_node_set<K, H, KE, A>::size_type friend erase_if(
+        unordered_node_set<K, H, KE, A>& set, Pred pred);
+
+    public:
+      using key_type = Key;
+      using value_type = typename set_types::value_type;
+      using init_type = typename set_types::init_type;
+      using size_type = std::size_t;
+      using difference_type = std::ptrdiff_t;
+      using hasher = Hash;
+      using key_equal = KeyEqual;
+      using allocator_type = Allocator;
+      using reference = value_type&;
+      using const_reference = value_type const&;
+      using pointer = typename boost::allocator_pointer<allocator_type>::type;
+      using const_pointer =
+        typename boost::allocator_const_pointer<allocator_type>::type;
+      using iterator = typename table_type::iterator;
+      using const_iterator = typename table_type::const_iterator;
+      using node_type = detail::node_set_handle<set_types,
+        typename boost::allocator_rebind<Allocator,
+          typename set_types::value_type>::type>;
+      using insert_return_type =
+        detail::foa::insert_return_type<iterator, node_type>;
+
+      unordered_node_set() : unordered_node_set(0) {}
+
+      explicit unordered_node_set(size_type n, hasher const& h = hasher(),
+        key_equal const& pred = key_equal(),
+        allocator_type const& a = allocator_type())
+          : table_(n, h, pred, a)
+      {
+      }
+
+      unordered_node_set(size_type n, allocator_type const& a)
+          : unordered_node_set(n, hasher(), key_equal(), a)
+      {
+      }
+
+      unordered_node_set(size_type n, hasher const& h, allocator_type const& a)
+          : unordered_node_set(n, h, key_equal(), a)
+      {
+      }
+
+      template <class InputIterator>
+      unordered_node_set(
+        InputIterator f, InputIterator l, allocator_type const& a)
+          : unordered_node_set(f, l, size_type(0), hasher(), key_equal(), a)
+      {
+      }
+
+      explicit unordered_node_set(allocator_type const& a)
+          : unordered_node_set(0, a)
+      {
+      }
+
+      template <class Iterator>
+      unordered_node_set(Iterator first, Iterator last, size_type n = 0,
+        hasher const& h = hasher(), key_equal const& pred = key_equal(),
+        allocator_type const& a = allocator_type())
+          : unordered_node_set(n, h, pred, a)
+      {
+        this->insert(first, last);
+      }
+
+      template <class InputIt>
+      unordered_node_set(
+        InputIt first, InputIt last, size_type n, allocator_type const& a)
+          : unordered_node_set(first, last, n, hasher(), key_equal(), a)
+      {
+      }
+
+      template <class Iterator>
+      unordered_node_set(Iterator first, Iterator last, size_type n,
+        hasher const& h, allocator_type const& a)
+          : unordered_node_set(first, last, n, h, key_equal(), a)
+      {
+      }
+
+      unordered_node_set(unordered_node_set const& other) : table_(other.table_)
+      {
+      }
+
+      unordered_node_set(
+        unordered_node_set const& other, allocator_type const& a)
+          : table_(other.table_, a)
+      {
+      }
+
+      unordered_node_set(unordered_node_set&& other)
+        noexcept(std::is_nothrow_move_constructible<hasher>::value&&
+            std::is_nothrow_move_constructible<key_equal>::value&&
+              std::is_nothrow_move_constructible<allocator_type>::value)
+          : table_(std::move(other.table_))
+      {
+      }
+
+      unordered_node_set(unordered_node_set&& other, allocator_type const& al)
+          : table_(std::move(other.table_), al)
+      {
+      }
+
+      unordered_node_set(std::initializer_list<value_type> ilist,
+        size_type n = 0, hasher const& h = hasher(),
+        key_equal const& pred = key_equal(),
+        allocator_type const& a = allocator_type())
+          : unordered_node_set(ilist.begin(), ilist.end(), n, h, pred, a)
+      {
+      }
+
+      unordered_node_set(
+        std::initializer_list<value_type> il, allocator_type const& a)
+          : unordered_node_set(il, size_type(0), hasher(), key_equal(), a)
+      {
+      }
+
+      unordered_node_set(std::initializer_list<value_type> init, size_type n,
+        allocator_type const& a)
+          : unordered_node_set(init, n, hasher(), key_equal(), a)
+      {
+      }
+
+      unordered_node_set(std::initializer_list<value_type> init, size_type n,
+        hasher const& h, allocator_type const& a)
+          : unordered_node_set(init, n, h, key_equal(), a)
+      {
+      }
+
+      ~unordered_node_set() = default;
+
+      unordered_node_set& operator=(unordered_node_set const& other)
+      {
+        table_ = other.table_;
+        return *this;
+      }
+
+      unordered_node_set& operator=(unordered_node_set&& other) noexcept(
+        noexcept(std::declval<table_type&>() = std::declval<table_type&&>()))
+      {
+        table_ = std::move(other.table_);
+        return *this;
+      }
+
+      allocator_type get_allocator() const noexcept
+      {
+        return table_.get_allocator();
+      }
+
+      /// Iterators
+      ///
+
+      iterator begin() noexcept { return table_.begin(); }
+      const_iterator begin() const noexcept { return table_.begin(); }
+      const_iterator cbegin() const noexcept { return table_.cbegin(); }
+
+      iterator end() noexcept { return table_.end(); }
+      const_iterator end() const noexcept { return table_.end(); }
+      const_iterator cend() const noexcept { return table_.cend(); }
+
+      /// Capacity
+      ///
+
+      BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
+      {
+        return table_.empty();
+      }
+
+      size_type size() const noexcept { return table_.size(); }
+
+      size_type max_size() const noexcept { return table_.max_size(); }
+
+      /// Modifiers
+      ///
+
+      void clear() noexcept { table_.clear(); }
+
+      BOOST_FORCEINLINE std::pair<iterator, bool> insert(
+        value_type const& value)
+      {
+        return table_.insert(value);
+      }
+
+      BOOST_FORCEINLINE std::pair<iterator, bool> insert(value_type&& value)
+      {
+        return table_.insert(std::move(value));
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::transparent_non_iterable<K, unordered_node_set>::value,
+        std::pair<iterator, bool> >::type
+      insert(K&& k)
+      {
+        return table_.try_emplace(std::forward<K>(k));
+      }
+
+      BOOST_FORCEINLINE iterator insert(const_iterator, value_type const& value)
+      {
+        return table_.insert(value).first;
+      }
+
+      BOOST_FORCEINLINE iterator insert(const_iterator, value_type&& value)
+      {
+        return table_.insert(std::move(value)).first;
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::transparent_non_iterable<K, unordered_node_set>::value,
+        iterator>::type
+      insert(const_iterator, K&& k)
+      {
+        return table_.try_emplace(std::forward<K>(k)).first;
+      }
+
+      template <class InputIterator>
+      void insert(InputIterator first, InputIterator last)
+      {
+        for (auto pos = first; pos != last; ++pos) {
+          table_.emplace(*pos);
+        }
+      }
+
+      void insert(std::initializer_list<value_type> ilist)
+      {
+        this->insert(ilist.begin(), ilist.end());
+      }
+
+      insert_return_type insert(node_type&& nh)
+      {
+        if (nh.empty()) {
+          return {end(), false, node_type{}};
+        }
+
+        BOOST_ASSERT(get_allocator() == nh.get_allocator());
+
+        auto itp = table_.insert(std::move(nh.element()));
+        if (itp.second) {
+          nh.reset();
+          return {itp.first, true, node_type{}};
+        } else {
+          return {itp.first, false, std::move(nh)};
+        }
+      }
+
+      iterator insert(const_iterator, node_type&& nh)
+      {
+        if (nh.empty()) {
+          return end();
+        }
+
+        BOOST_ASSERT(get_allocator() == nh.get_allocator());
+
+        auto itp = table_.insert(std::move(nh.element()));
+        if (itp.second) {
+          nh.reset();
+          return itp.first;
+        } else {
+          return itp.first;
+        }
+      }
+
+      template <class... Args>
+      BOOST_FORCEINLINE std::pair<iterator, bool> emplace(Args&&... args)
+      {
+        return table_.emplace(std::forward<Args>(args)...);
+      }
+
+      template <class... Args>
+      BOOST_FORCEINLINE iterator emplace_hint(const_iterator, Args&&... args)
+      {
+        return table_.emplace(std::forward<Args>(args)...).first;
+      }
+
+      BOOST_FORCEINLINE void erase(const_iterator pos)
+      {
+        return table_.erase(pos);
+      }
+      iterator erase(const_iterator first, const_iterator last)
+      {
+        while (first != last) {
+          this->erase(first++);
+        }
+        return iterator{detail::foa::const_iterator_cast_tag{}, last};
+      }
+
+      BOOST_FORCEINLINE size_type erase(key_type const& key)
+      {
+        return table_.erase(key);
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::transparent_non_iterable<K, unordered_node_set>::value,
+        size_type>::type
+      erase(K const& key)
+      {
+        return table_.erase(key);
+      }
+
+      void swap(unordered_node_set& rhs) noexcept(
+        noexcept(std::declval<table_type&>().swap(std::declval<table_type&>())))
+      {
+        table_.swap(rhs.table_);
+      }
+
+      node_type extract(const_iterator pos)
+      {
+        BOOST_ASSERT(pos != end());
+        node_type nh;
+        auto elem = table_.extract(pos);
+        nh.emplace(std::move(elem), get_allocator());
+        return nh;
+      }
+
+      node_type extract(key_type const& key)
+      {
+        auto pos = find(key);
+        return pos != end() ? extract(pos) : node_type();
+      }
+
+      template <class K>
+      typename std::enable_if<
+        boost::unordered::detail::transparent_non_iterable<K,
+          unordered_node_set>::value,
+        node_type>::type
+      extract(K const& key)
+      {
+        auto pos = find(key);
+        return pos != end() ? extract(pos) : node_type();
+      }
+
+      template <class H2, class P2>
+      void merge(unordered_node_set<key_type, H2, P2, allocator_type>& source)
+      {
+        table_.merge(source.table_);
+      }
+
+      template <class H2, class P2>
+      void merge(unordered_node_set<key_type, H2, P2, allocator_type>&& source)
+      {
+        table_.merge(std::move(source.table_));
+      }
+
+      /// Lookup
+      ///
+
+      BOOST_FORCEINLINE size_type count(key_type const& key) const
+      {
+        auto pos = table_.find(key);
+        return pos != table_.end() ? 1 : 0;
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
+      count(K const& key) const
+      {
+        auto pos = table_.find(key);
+        return pos != table_.end() ? 1 : 0;
+      }
+
+      BOOST_FORCEINLINE iterator find(key_type const& key)
+      {
+        return table_.find(key);
+      }
+
+      BOOST_FORCEINLINE const_iterator find(key_type const& key) const
+      {
+        return table_.find(key);
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        iterator>::type
+      find(K const& key)
+      {
+        return table_.find(key);
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        const_iterator>::type
+      find(K const& key) const
+      {
+        return table_.find(key);
+      }
+
+      BOOST_FORCEINLINE bool contains(key_type const& key) const
+      {
+        return this->find(key) != this->end();
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        bool>::type
+      contains(K const& key) const
+      {
+        return this->find(key) != this->end();
+      }
+
+      std::pair<iterator, iterator> equal_range(key_type const& key)
+      {
+        auto pos = table_.find(key);
+        if (pos == table_.end()) {
+          return {pos, pos};
+        }
+
+        auto next = pos;
+        ++next;
+        return {pos, next};
+      }
+
+      std::pair<const_iterator, const_iterator> equal_range(
+        key_type const& key) const
+      {
+        auto pos = table_.find(key);
+        if (pos == table_.end()) {
+          return {pos, pos};
+        }
+
+        auto next = pos;
+        ++next;
+        return {pos, next};
+      }
+
+      template <class K>
+      typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value,
+        std::pair<iterator, iterator> >::type
+      equal_range(K const& key)
+      {
+        auto pos = table_.find(key);
+        if (pos == table_.end()) {
+          return {pos, pos};
+        }
+
+        auto next = pos;
+        ++next;
+        return {pos, next};
+      }
+
+      template <class K>
+      typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value,
+        std::pair<const_iterator, const_iterator> >::type
+      equal_range(K const& key) const
+      {
+        auto pos = table_.find(key);
+        if (pos == table_.end()) {
+          return {pos, pos};
+        }
+
+        auto next = pos;
+        ++next;
+        return {pos, next};
+      }
+
+      /// Hash Policy
+      ///
+
+      size_type bucket_count() const noexcept { return table_.capacity(); }
+
+      float load_factor() const noexcept { return table_.load_factor(); }
+
+      float max_load_factor() const noexcept
+      {
+        return table_.max_load_factor();
+      }
+
+      void max_load_factor(float) {}
+
+      size_type max_load() const noexcept { return table_.max_load(); }
+
+      void rehash(size_type n) { table_.rehash(n); }
+
+      void reserve(size_type n) { table_.reserve(n); }
+
+      /// Observers
+      ///
+
+      hasher hash_function() const { return table_.hash_function(); }
+
+      key_equal key_eq() const { return table_.key_eq(); }
+    };
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator==(
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      if (&lhs == &rhs) {
+        return true;
+      }
+
+      return (lhs.size() == rhs.size()) && ([&] {
+        for (auto const& key : lhs) {
+          auto pos = rhs.find(key);
+          if ((pos == rhs.end()) || (key != *pos)) {
+            return false;
+          }
+        }
+        return true;
+      })();
+    }
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator!=(
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return !(lhs == rhs);
+    }
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    void swap(unordered_node_set<Key, Hash, KeyEqual, Allocator>& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator>& rhs)
+      noexcept(noexcept(lhs.swap(rhs)))
+    {
+      lhs.swap(rhs);
+    }
+
+    template <class Key, class Hash, class KeyEqual, class Allocator,
+      class Pred>
+    typename unordered_node_set<Key, Hash, KeyEqual, Allocator>::size_type
+    erase_if(unordered_node_set<Key, Hash, KeyEqual, Allocator>& set, Pred pred)
+    {
+      return erase_if(set.table_, pred);
+    }
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop) /* C4714 */
+#endif
+
+#if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
+    template <class InputIterator,
+      class Hash =
+        boost::hash<typename std::iterator_traits<InputIterator>::value_type>,
+      class Pred =
+        std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
+      class Allocator = std::allocator<
+        typename std::iterator_traits<InputIterator>::value_type>,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_pred_v<Pred> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(InputIterator, InputIterator,
+      std::size_t = boost::unordered::detail::foa::default_bucket_count,
+      Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+      -> unordered_node_set<
+        typename std::iterator_traits<InputIterator>::value_type, Hash, Pred,
+        Allocator>;
+
+    template <class T, class Hash = boost::hash<T>,
+      class Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_pred_v<Pred> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(std::initializer_list<T>,
+      std::size_t = boost::unordered::detail::foa::default_bucket_count,
+      Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+      -> unordered_node_set<T, Hash, Pred, Allocator>;
+
+    template <class InputIterator, class Allocator,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(InputIterator, InputIterator, std::size_t, Allocator)
+      -> unordered_node_set<
+        typename std::iterator_traits<InputIterator>::value_type,
+        boost::hash<typename std::iterator_traits<InputIterator>::value_type>,
+        std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
+        Allocator>;
+
+    template <class InputIterator, class Hash, class Allocator,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(
+      InputIterator, InputIterator, std::size_t, Hash, Allocator)
+      -> unordered_node_set<
+        typename std::iterator_traits<InputIterator>::value_type, Hash,
+        std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
+        Allocator>;
+
+    template <class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(std::initializer_list<T>, std::size_t, Allocator)
+      -> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
+
+    template <class T, class Hash, class Allocator,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(std::initializer_list<T>, std::size_t, Hash, Allocator)
+      -> unordered_node_set<T, Hash, std::equal_to<T>, Allocator>;
+
+    template <class InputIterator, class Allocator,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(InputIterator, InputIterator, Allocator)
+      -> unordered_node_set<
+        typename std::iterator_traits<InputIterator>::value_type,
+        boost::hash<typename std::iterator_traits<InputIterator>::value_type>,
+        std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
+        Allocator>;
+
+    template <class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(std::initializer_list<T>, Allocator)
+      -> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
+#endif
+
+  } // namespace unordered
+} // namespace boost
+
+#endif

include/boost/unordered/unordered_node_set_fwd.hpp

@@ -0,0 +1,49 @@
+
+// Copyright (C) 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_UNORDERED_NODE_SET_FWD_HPP_INCLUDED
+#define BOOST_UNORDERED_NODE_SET_FWD_HPP_INCLUDED
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/functional/hash_fwd.hpp>
+#include <boost/unordered/detail/fwd.hpp>
+#include <functional>
+#include <memory>
+
+namespace boost {
+  namespace unordered {
+    template <class Key, class Hash = boost::hash<Key>,
+      class KeyEqual = std::equal_to<Key>,
+      class Allocator = std::allocator<Key> >
+    class unordered_node_set;
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator==(
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs);
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator!=(
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs);
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    void swap(unordered_node_set<Key, Hash, KeyEqual, Allocator>& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator>& rhs)
+      noexcept(noexcept(lhs.swap(rhs)));
+  } // namespace unordered
+
+  using boost::unordered::unordered_node_set;
+
+  using boost::unordered::swap;
+  using boost::unordered::operator==;
+  using boost::unordered::operator!=;
+} // namespace boost
+
+#endif

include/boost/unordered/unordered_set.hpp

@@ -15,6 +15,7 @@
 #pragma once
 #endif
 
+#include <boost/unordered/detail/requires_cxx11.hpp>
 #include <boost/core/explicit_operator_bool.hpp>
 #include <boost/functional/hash.hpp>
 #include <boost/move/move.hpp>
@@ -390,6 +391,15 @@ namespace boost {
         return this->emplace(boost::move(x));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_set>::value,
+        std::pair<iterator, bool> >::type
+      insert(BOOST_FWD_REF(Key) k)
+      {
+        return table_.try_emplace_unique(boost::forward<Key>(k));
+      }
+
       iterator insert(const_iterator hint, value_type const& x)
       {
         return this->emplace_hint(hint, x);
@@ -400,6 +410,15 @@ namespace boost {
         return this->emplace_hint(hint, boost::move(x));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_set>::value,
+        iterator>::type
+      insert(const_iterator hint, BOOST_FWD_REF(Key) k)
+      {
+        return table_.try_emplace_hint_unique(hint, boost::forward<Key>(k));
+      }
+
       template <class InputIt> void insert(InputIt, InputIt);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -571,6 +590,14 @@ namespace boost {
         return table_.hash_to_bucket(table_.hash(k));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        size_type>::type
+      bucket(BOOST_FWD_REF(Key) k) const
+      {
+        return table_.hash_to_bucket(table_.hash(boost::forward<Key>(k)));
+      }
+
       local_iterator begin(size_type n)
       {
         return local_iterator(table_.begin(n));
@@ -1212,6 +1239,14 @@ namespace boost {
         return table_.hash_to_bucket(table_.hash(k));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        size_type>::type
+      bucket(BOOST_FWD_REF(Key) k) const
+      {
+        return table_.hash_to_bucket(table_.hash(boost::forward<Key>(k)));
+      }
+
       local_iterator begin(size_type n)
       {
         return local_iterator(table_.begin(n));

test/Jamfile.v2

@@ -1,6 +1,6 @@
 
 # Copyright 2006-2008 Daniel James.
-# Copyright 2022 Christian Mazakas
+# Copyright 2022-2023 Christian Mazakas
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -26,6 +26,7 @@ project
 
         <toolset>gcc-4.4:<cxxflags>-Wno-strict-aliasing
         <toolset>gcc-4.4:<cxxflags>-fno-deduce-init-list
+        <toolset>clang-14:<cxxflags>-Wunused-template
 
         <toolset>gcc:<warnings-as-errors>on
         <toolset>clang:<warnings-as-errors>on
@@ -94,54 +95,60 @@ run exception/erase_exception_tests.cpp ;
 run exception/rehash_exception_tests.cpp ;
 run exception/swap_exception_tests.cpp : : : <define>BOOST_UNORDERED_SWAP_METHOD=2 ;
 run exception/merge_exception_tests.cpp ;
+run exception/less_tests.cpp ;
 
+run unordered/narrow_cast_tests.cpp ;
 run quick.cpp ;
 
 import ../../config/checks/config : requires ;
 
 CPP11 = [ requires cxx11_constexpr cxx11_noexcept cxx11_decltype cxx11_alignas ] ;
 
-rule build_foa ( name )
+local FOA_TESTS =
+  fwd_set_test
+  fwd_map_test
+  compile_set
+  compile_map
+  noexcept_tests
+  incomplete_test
+  simple_tests
+  equivalent_keys_tests
+  constructor_tests
+  copy_tests
+  move_tests
+  post_move_tests
+  assign_tests
+  insert_tests
+  insert_hint_tests
+  emplace_tests
+  erase_tests
+  merge_tests
+  find_tests
+  at_tests
+  load_factor_tests
+  rehash_tests
+  equality_tests
+  swap_tests
+  transparent_tests
+  reserve_tests
+  contains_tests
+  erase_if
+  scary_tests
+  init_type_insert_tests
+  max_load_tests
+  extract_tests
+  node_handle_tests
+  uses_allocator
+;
+
+for local test in $(FOA_TESTS)
 {
-  run unordered/$(name).cpp : : : $(CPP11) <define>BOOST_UNORDERED_FOA_TESTS : foa_$(name) ;
+  run unordered/$(test).cpp : : : $(CPP11) <define>BOOST_UNORDERED_FOA_TESTS : foa_$(test) ;
 }
 
-build_foa fwd_set_test ;
-build_foa fwd_map_test ;
-build_foa compile_set ;
-build_foa compile_map ;
-build_foa noexcept_tests ;
 run unordered/link_test_1.cpp unordered/link_test_2.cpp : : : $(CPP11) <define>BOOST_UNORDERED_FOA_TESTS : foa_link_test ;
-build_foa incomplete_test ;
-build_foa simple_tests ;
-build_foa equivalent_keys_tests ;
-build_foa constructor_tests ;
-build_foa copy_tests ;
-build_foa move_tests ;
-build_foa post_move_tests ;
-build_foa assign_tests ;
-build_foa insert_tests ;
-build_foa insert_hint_tests ;
-build_foa emplace_tests ;
-build_foa erase_tests ;
-build_foa merge_tests ;
-build_foa find_tests ;
-build_foa at_tests ;
-build_foa load_factor_tests ;
-build_foa rehash_tests ;
-build_foa equality_tests ;
-build_foa swap_tests ;
 run unordered/scoped_allocator.cpp : : : $(CPP11) <toolset>msvc-14.0:<build>no <define>BOOST_UNORDERED_FOA_TESTS : foa_scoped_allocator ;
-build_foa transparent_tests ;
-build_foa reserve_tests ;
-build_foa contains_tests ;
-build_foa erase_if ;
-build_foa scary_tests ;
-build_foa init_type_insert_tests ;
-build_foa max_load_tests ;
-
 run unordered/hash_is_avalanching_test.cpp ;
-
 run exception/constructor_exception_tests.cpp : : : $(CPP11) <define>BOOST_UNORDERED_FOA_TESTS : foa_constructor_exception_tests ;
 run exception/copy_exception_tests.cpp        : : : $(CPP11) <define>BOOST_UNORDERED_FOA_TESTS : foa_copy_exception_tests ;
 run exception/assign_exception_tests.cpp      : : : $(CPP11) <define>BOOST_UNORDERED_FOA_TESTS : foa_assign_exception_tests ;
@@ -151,3 +158,39 @@ run exception/erase_exception_tests.cpp       : : : $(CPP11) <define>BOOST_UNORD
 run exception/rehash_exception_tests.cpp      : : : $(CPP11) <define>BOOST_UNORDERED_FOA_TESTS : foa_rehash_exception_tests ;
 run exception/swap_exception_tests.cpp        : : : $(CPP11) <define>BOOST_UNORDERED_FOA_TESTS : foa_swap_exception_tests ;
 run exception/merge_exception_tests.cpp       : : : $(CPP11) <define>BOOST_UNORDERED_FOA_TESTS : foa_merge_exception_tests ;
+
+alias foa_tests :
+  foa_$(FOA_TESTS)
+  foa_link_test
+  foa_scoped_allocator
+  hash_is_avalanching_test
+  foa_constructor_exception_tests
+  foa_copy_exception_tests
+  foa_assign_exception_tests
+  foa_move_assign_exception_tests
+  foa_insert_exception_tests
+  foa_erase_exception_tests
+  foa_rehash_exception_tests
+  foa_swap_exception_tests
+  foa_merge_exception_tests
+;
+
+local CFOA_TESTS =
+  insert_tests
+  erase_tests
+  try_emplace_tests
+  emplace_tests
+  visit_tests
+  constructor_tests
+  assign_tests
+;
+
+for local test in $(CFOA_TESTS)
+{
+  run cfoa/$(test).cpp
+  : requirements $(CPP11)
+  : target-name cfoa_$(test)
+  ;
+}
+
+alias cfoa_tests : cfoa_$(CFOA_TESTS) ;

test/cfoa/assign_tests.cpp

@@ -0,0 +1,147 @@
+// Copyright (C) 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "helpers.hpp"
+
+#include <boost/unordered/concurrent_flat_map.hpp>
+
+test::seed_t initialize_seed{2762556623};
+
+using test::default_generator;
+using test::limited_range;
+using test::sequential;
+
+using hasher = stateful_hash;
+using key_equal = stateful_key_equal;
+using allocator_type = stateful_allocator<std::pair<raii const, raii> >;
+
+using map_type = boost::unordered::concurrent_flat_map<raii, raii, hasher,
+  key_equal, allocator_type>;
+
+using map_value_type = typename map_type::value_type;
+
+namespace {
+  template <class G> void copy_assign(G gen, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+
+    // to test:
+    // self-assign
+    // propagation
+    //
+
+    // lhs empty, rhs empty
+    {
+      raii::reset_counts();
+
+      map_type x(0, hasher(1), key_equal(2), allocator_type(3));
+      map_type y;
+
+      BOOST_TEST(x.empty());
+      BOOST_TEST(y.empty());
+      y = x;
+
+      BOOST_TEST_EQ(raii::destructor, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+
+      BOOST_TEST_EQ(x.hash_function(), y.hash_function());
+      BOOST_TEST_EQ(x.key_eq(), y.key_eq());
+      BOOST_TEST(x.get_allocator() != y.get_allocator());
+    }
+
+    // lhs non-empty, rhs empty
+    {
+      raii::reset_counts();
+
+      map_type x(0, hasher(1), key_equal(2), allocator_type(3));
+
+      map_type y(values.begin(), values.end(), values.size());
+
+      auto const old_cc = +raii::copy_constructor;
+      auto const old_size = y.size();
+
+      BOOST_TEST(x.empty());
+      BOOST_TEST(!y.empty());
+      y = x;
+
+      BOOST_TEST_EQ(raii::destructor, 2 * old_size);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc);
+
+      BOOST_TEST_EQ(x.hash_function(), y.hash_function());
+      BOOST_TEST_EQ(x.key_eq(), y.key_eq());
+      BOOST_TEST(x.get_allocator() != y.get_allocator());
+    }
+    check_raii_counts();
+
+    // lhs empty, rhs non-empty
+    {
+      raii::reset_counts();
+
+      map_type x(values.begin(), values.end(), values.size(), hasher(1),
+        key_equal(2), allocator_type(3));
+
+      map_type y;
+      auto const old_cc = +raii::copy_constructor;
+
+      BOOST_TEST(!x.empty());
+      BOOST_TEST(y.empty());
+      y = x;
+
+      BOOST_TEST_EQ(raii::destructor, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc + (2 * x.size()));
+
+      BOOST_TEST_EQ(x.hash_function(), y.hash_function());
+      BOOST_TEST_EQ(x.key_eq(), y.key_eq());
+      BOOST_TEST(x.get_allocator() != y.get_allocator());
+
+      test_matches_reference(y, reference_map);
+    }
+    check_raii_counts();
+
+    // lhs non-empty, rhs non-empty
+    {
+      raii::reset_counts();
+
+      map_type x(values.begin(), values.end(), values.size(), hasher(1),
+        key_equal(2), allocator_type(3));
+
+      map_type y(values.begin(), values.end(), values.size());
+
+      auto const old_size = y.size();
+      auto const old_cc = +raii::copy_constructor;
+
+      BOOST_TEST(!x.empty());
+      BOOST_TEST(!y.empty());
+      y = x;
+
+      BOOST_TEST_EQ(raii::destructor, 2 * old_size);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc + (2 * x.size()));
+
+      BOOST_TEST_EQ(x.hash_function(), y.hash_function());
+      BOOST_TEST_EQ(x.key_eq(), y.key_eq());
+      BOOST_TEST(x.get_allocator() != y.get_allocator());
+    }
+    check_raii_counts();
+  }
+
+} // namespace
+
+// clang-format off
+UNORDERED_TEST(
+  copy_assign,
+  ((value_type_generator))
+  ((default_generator)(sequential)(limited_range)))
+// clang-format on
+
+RUN_TESTS()

test/cfoa/constructor_tests.cpp

@@ -0,0 +1,814 @@
+// Copyright (C) 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "helpers.hpp"
+
+#include <boost/unordered/concurrent_flat_map.hpp>
+
+test::seed_t initialize_seed(4122023);
+
+using test::default_generator;
+using test::limited_range;
+using test::sequential;
+
+template <class T> struct soccc_allocator
+{
+  int x_ = -1;
+
+  using value_type = T;
+
+  soccc_allocator() = default;
+  soccc_allocator(soccc_allocator const&) = default;
+  soccc_allocator(soccc_allocator&&) = default;
+
+  soccc_allocator(int const x) : x_{x} {}
+
+  template <class U> soccc_allocator(soccc_allocator<U> const& rhs) : x_{rhs.x_}
+  {
+  }
+
+  T* allocate(std::size_t n)
+  {
+    return static_cast<T*>(::operator new(n * sizeof(T)));
+  }
+
+  void deallocate(T* p, std::size_t) { ::operator delete(p); }
+
+  soccc_allocator select_on_container_copy_construction() const
+  {
+    return {x_ + 1};
+  }
+
+  bool operator==(soccc_allocator const& rhs) const { return x_ == rhs.x_; }
+  bool operator!=(soccc_allocator const& rhs) const { return x_ != rhs.x_; }
+};
+
+using hasher = stateful_hash;
+using key_equal = stateful_key_equal;
+using allocator_type = stateful_allocator<std::pair<raii const, raii> >;
+
+using map_type = boost::unordered::concurrent_flat_map<raii, raii, hasher,
+  key_equal, allocator_type>;
+
+using map_value_type = typename map_type::value_type;
+
+UNORDERED_AUTO_TEST (default_constructor) {
+  boost::unordered::concurrent_flat_map<raii, raii> x;
+  BOOST_TEST(x.empty());
+  BOOST_TEST_EQ(x.size(), 0u);
+}
+
+UNORDERED_AUTO_TEST (bucket_count_with_hasher_key_equal_and_allocator) {
+  raii::reset_counts();
+  {
+    map_type x(0);
+
+    BOOST_TEST(x.empty());
+    BOOST_TEST_EQ(x.size(), 0u);
+    BOOST_TEST_EQ(x.hash_function(), hasher());
+    BOOST_TEST_EQ(x.key_eq(), key_equal());
+  }
+
+  {
+    map_type x(0, hasher(1));
+
+    BOOST_TEST(x.empty());
+    BOOST_TEST_EQ(x.size(), 0u);
+    BOOST_TEST_EQ(x.hash_function(), hasher(1));
+    BOOST_TEST_EQ(x.key_eq(), key_equal());
+  }
+
+  {
+    map_type x(0, hasher(1), key_equal(2));
+
+    BOOST_TEST(x.empty());
+    BOOST_TEST_EQ(x.size(), 0u);
+    BOOST_TEST_EQ(x.hash_function(), hasher(1));
+    BOOST_TEST_EQ(x.key_eq(), key_equal(2));
+  }
+
+  {
+    map_type x(0, hasher(1), key_equal(2), allocator_type{});
+
+    BOOST_TEST(x.empty());
+    BOOST_TEST_EQ(x.size(), 0u);
+    BOOST_TEST_EQ(x.hash_function(), hasher(1));
+    BOOST_TEST_EQ(x.key_eq(), key_equal(2));
+    BOOST_TEST(x.get_allocator() == allocator_type{});
+  }
+}
+
+UNORDERED_AUTO_TEST (soccc) {
+  raii::reset_counts();
+
+  boost::unordered::concurrent_flat_map<raii, raii, hasher, key_equal,
+    soccc_allocator<std::pair<raii const, raii> > >
+    x;
+
+  boost::unordered::concurrent_flat_map<raii, raii, hasher, key_equal,
+    soccc_allocator<std::pair<raii const, raii> > >
+    y(x);
+
+  BOOST_TEST_EQ(y.hash_function(), x.hash_function());
+  BOOST_TEST_EQ(y.key_eq(), x.key_eq());
+  BOOST_TEST(y.get_allocator() != x.get_allocator());
+}
+
+namespace {
+  template <class G> void from_iterator_range(G gen, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+    raii::reset_counts();
+
+    {
+      map_type x(values.begin(), values.end());
+
+      test_matches_reference(x, reference_map);
+      BOOST_TEST_GT(x.size(), 0u);
+      BOOST_TEST_LE(x.size(), values.size());
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == allocator_type{});
+      if (rg == sequential) {
+        BOOST_TEST_EQ(x.size(), values.size());
+      }
+    }
+
+    {
+      map_type x(values.begin(), values.end(), 0);
+
+      test_matches_reference(x, reference_map);
+      BOOST_TEST_GT(x.size(), 0u);
+      BOOST_TEST_LE(x.size(), values.size());
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == allocator_type{});
+      if (rg == sequential) {
+        BOOST_TEST_EQ(x.size(), values.size());
+      }
+    }
+
+    {
+      map_type x(values.begin(), values.end(), 0, hasher(1));
+
+      test_matches_reference(x, reference_map);
+      BOOST_TEST_GT(x.size(), 0u);
+      BOOST_TEST_LE(x.size(), values.size());
+      BOOST_TEST_EQ(x.hash_function(), hasher(1));
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == allocator_type{});
+      if (rg == sequential) {
+        BOOST_TEST_EQ(x.size(), values.size());
+      }
+    }
+
+    {
+      map_type x(values.begin(), values.end(), 0, hasher(1), key_equal(2));
+
+      test_matches_reference(x, reference_map);
+      BOOST_TEST_GT(x.size(), 0u);
+      BOOST_TEST_LE(x.size(), values.size());
+      BOOST_TEST_EQ(x.hash_function(), hasher(1));
+      BOOST_TEST_EQ(x.key_eq(), key_equal(2));
+      BOOST_TEST(x.get_allocator() == allocator_type{});
+      if (rg == sequential) {
+        BOOST_TEST_EQ(x.size(), values.size());
+      }
+    }
+
+    {
+      map_type x(values.begin(), values.end(), 0, hasher(1), key_equal(2),
+        allocator_type{});
+
+      test_matches_reference(x, reference_map);
+      BOOST_TEST_GT(x.size(), 0u);
+      BOOST_TEST_LE(x.size(), values.size());
+      BOOST_TEST_EQ(x.hash_function(), hasher(1));
+      BOOST_TEST_EQ(x.key_eq(), key_equal(2));
+      BOOST_TEST(x.get_allocator() == allocator_type{});
+      if (rg == sequential) {
+        BOOST_TEST_EQ(x.size(), values.size());
+      }
+    }
+
+    check_raii_counts();
+  }
+
+  template <class G> void copy_constructor(G gen, test::random_generator rg)
+  {
+    {
+      map_type x(0, hasher(1), key_equal(2), allocator_type{});
+      map_type y(x);
+
+      BOOST_TEST_EQ(y.size(), x.size());
+      BOOST_TEST_EQ(y.hash_function(), x.hash_function());
+      BOOST_TEST_EQ(y.key_eq(), x.key_eq());
+      BOOST_TEST(y.get_allocator() == x.get_allocator());
+    }
+
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+
+    raii::reset_counts();
+
+    {
+      map_type x(values.begin(), values.end(), 0, hasher(1), key_equal(2),
+        allocator_type{});
+
+      thread_runner(
+        values, [&x, &reference_map](
+                  boost::span<span_value_type<decltype(values)> > s) {
+          (void)s;
+          map_type y(x);
+
+          test_matches_reference(x, reference_map);
+          test_matches_reference(y, reference_map);
+          BOOST_TEST_EQ(y.size(), x.size());
+          BOOST_TEST_EQ(y.hash_function(), x.hash_function());
+          BOOST_TEST_EQ(y.key_eq(), x.key_eq());
+          BOOST_TEST(y.get_allocator() == x.get_allocator());
+        });
+    }
+
+    check_raii_counts();
+
+    raii::reset_counts();
+
+    {
+      allocator_type a;
+
+      map_type x(values.begin(), values.end(), 0, hasher(1), key_equal(2), a);
+
+      thread_runner(
+        values, [&x, &reference_map, a](
+                  boost::span<span_value_type<decltype(values)> > s) {
+          (void)s;
+          map_type y(x, a);
+
+          test_matches_reference(x, reference_map);
+          test_matches_reference(y, reference_map);
+          BOOST_TEST_EQ(y.size(), x.size());
+          BOOST_TEST_EQ(y.hash_function(), x.hash_function());
+          BOOST_TEST_EQ(y.key_eq(), x.key_eq());
+          BOOST_TEST(y.get_allocator() == x.get_allocator());
+        });
+    }
+
+    check_raii_counts();
+  }
+
+  template <class G>
+  void copy_constructor_with_insertion(G gen, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+    raii::reset_counts();
+
+    std::mutex m;
+    std::condition_variable cv;
+    bool ready = false;
+
+    {
+      map_type x(0, hasher(1), key_equal(2), allocator_type{});
+
+      auto f = [&x, &values, &m, &cv, &ready] {
+        {
+          std::lock_guard<std::mutex> guard(m);
+          ready = true;
+        }
+        cv.notify_all();
+
+        for (auto const& val : values) {
+          x.insert(val);
+        }
+      };
+
+      std::thread t1(f);
+      std::thread t2(f);
+
+      thread_runner(
+        values, [&x, &reference_map, &values, rg, &m, &cv, &ready](
+                  boost::span<span_value_type<decltype(values)> > s) {
+          (void)s;
+
+          {
+            std::unique_lock<std::mutex> lk(m);
+            cv.wait(lk, [&] { return ready; });
+          }
+
+          map_type y(x);
+
+          BOOST_TEST_LE(y.size(), values.size());
+          BOOST_TEST_EQ(y.hash_function(), x.hash_function());
+          BOOST_TEST_EQ(y.key_eq(), x.key_eq());
+          BOOST_TEST(y.get_allocator() == x.get_allocator());
+
+          x.visit_all([&reference_map, rg](
+                        typename map_type::value_type const& val) {
+            BOOST_TEST(reference_map.contains(val.first));
+            if (rg == sequential) {
+              BOOST_TEST_EQ(val.second, reference_map.find(val.first)->second);
+            }
+          });
+        });
+
+      t1.join();
+      t2.join();
+    }
+
+    check_raii_counts();
+  }
+
+  template <class G> void move_constructor(G gen, test::random_generator rg)
+  {
+    {
+      map_type x(0, hasher(1), key_equal(2), allocator_type{});
+      auto const old_size = x.size();
+
+      map_type y(std::move(x));
+
+      BOOST_TEST_EQ(y.size(), old_size);
+      BOOST_TEST_EQ(y.hash_function(), hasher(1));
+      BOOST_TEST_EQ(y.key_eq(), key_equal(2));
+
+      BOOST_TEST_EQ(x.size(), 0u);
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+
+      BOOST_TEST(y.get_allocator() == x.get_allocator());
+    }
+
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+
+    raii::reset_counts();
+
+    {
+      map_type x(values.begin(), values.end(), 0, hasher(1), key_equal(2),
+        allocator_type{});
+
+      std::atomic_uint num_transfers{0};
+
+      auto const old_mc = +raii::move_constructor;
+
+      thread_runner(
+        values, [&x, &reference_map, &num_transfers](
+                  boost::span<span_value_type<decltype(values)> > s) {
+          (void)s;
+
+          auto const old_size = x.size();
+          map_type y(std::move(x));
+
+          if (!y.empty()) {
+            ++num_transfers;
+
+            test_matches_reference(y, reference_map);
+            BOOST_TEST_EQ(y.size(), old_size);
+            BOOST_TEST_EQ(y.hash_function(), hasher(1));
+            BOOST_TEST_EQ(y.key_eq(), key_equal(2));
+          } else {
+            BOOST_TEST_EQ(y.size(), 0u);
+            BOOST_TEST_EQ(y.hash_function(), hasher());
+            BOOST_TEST_EQ(y.key_eq(), key_equal());
+          }
+
+          BOOST_TEST_EQ(x.size(), 0u);
+          BOOST_TEST_EQ(x.hash_function(), hasher());
+          BOOST_TEST_EQ(x.key_eq(), key_equal());
+
+          BOOST_TEST(y.get_allocator() == x.get_allocator());
+        });
+
+      BOOST_TEST_EQ(num_transfers, 1u);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc);
+    }
+
+    check_raii_counts();
+
+    // allocator-aware move constructor, unequal allocators
+    raii::reset_counts();
+
+    {
+      map_type x(values.begin(), values.end(), 0, hasher(1), key_equal(2),
+        allocator_type{1});
+
+      std::atomic_uint num_transfers{0};
+
+      auto const old_mc = +raii::move_constructor;
+      auto const old_size = x.size();
+
+      thread_runner(
+        values, [&x, &reference_map, &num_transfers, old_size](
+                  boost::span<span_value_type<decltype(values)> > s) {
+          (void)s;
+
+          auto a = allocator_type{2};
+          BOOST_TEST(a != x.get_allocator());
+
+          map_type y(std::move(x), a);
+
+          if (!y.empty()) {
+            ++num_transfers;
+
+            test_matches_reference(y, reference_map);
+            BOOST_TEST_EQ(y.size(), old_size);
+            BOOST_TEST_EQ(y.hash_function(), hasher(1));
+            BOOST_TEST_EQ(y.key_eq(), key_equal(2));
+          } else {
+            BOOST_TEST_EQ(y.size(), 0u);
+            BOOST_TEST_EQ(y.hash_function(), hasher());
+            BOOST_TEST_EQ(y.key_eq(), key_equal());
+          }
+
+          BOOST_TEST_EQ(x.size(), 0u);
+          BOOST_TEST_EQ(x.hash_function(), hasher());
+          BOOST_TEST_EQ(x.key_eq(), key_equal());
+
+          BOOST_TEST(y.get_allocator() != x.get_allocator());
+          BOOST_TEST(y.get_allocator() == a);
+        });
+
+      BOOST_TEST_EQ(num_transfers, 1u);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc + (2 * old_size));
+    }
+
+    check_raii_counts();
+
+    // allocator-aware move constructor, equal allocators
+    raii::reset_counts();
+
+    {
+      map_type x(values.begin(), values.end(), 0, hasher(1), key_equal(2),
+        allocator_type{1});
+
+      std::atomic_uint num_transfers{0};
+
+      auto const old_mc = +raii::move_constructor;
+      auto const old_size = x.size();
+
+      thread_runner(
+        values, [&x, &reference_map, &num_transfers, old_size](
+                  boost::span<span_value_type<decltype(values)> > s) {
+          (void)s;
+
+          auto a = allocator_type{1};
+          BOOST_TEST(a == x.get_allocator());
+
+          map_type y(std::move(x), a);
+
+          if (!y.empty()) {
+            ++num_transfers;
+
+            test_matches_reference(y, reference_map);
+            BOOST_TEST_EQ(y.size(), old_size);
+            BOOST_TEST_EQ(y.hash_function(), hasher(1));
+            BOOST_TEST_EQ(y.key_eq(), key_equal(2));
+          } else {
+            BOOST_TEST_EQ(y.size(), 0u);
+            BOOST_TEST_EQ(y.hash_function(), hasher());
+            BOOST_TEST_EQ(y.key_eq(), key_equal());
+          }
+
+          BOOST_TEST_EQ(x.size(), 0u);
+          BOOST_TEST_EQ(x.hash_function(), hasher());
+          BOOST_TEST_EQ(x.key_eq(), key_equal());
+
+          BOOST_TEST(y.get_allocator() == x.get_allocator());
+          BOOST_TEST(y.get_allocator() == a);
+        });
+
+      BOOST_TEST_EQ(num_transfers, 1u);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc);
+    }
+
+    check_raii_counts();
+  }
+
+  template <class G>
+  void move_constructor_with_insertion(G gen, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+
+    raii::reset_counts();
+
+    std::mutex m;
+    std::condition_variable cv;
+    bool ready = false;
+
+    {
+      map_type x(0, hasher(1), key_equal(2), allocator_type{});
+
+      std::atomic_uint num_transfers{0};
+
+      std::thread t1([&x, &values] {
+        for (auto const& val : values) {
+          x.insert(val);
+        }
+      });
+
+      std::thread t2([&x, &m, &cv, &ready] {
+        while (x.empty()) {
+          std::this_thread::yield();
+        }
+
+        {
+          std::lock_guard<std::mutex> guard(m);
+          ready = true;
+        }
+        cv.notify_all();
+      });
+
+      thread_runner(
+        values, [&x, &reference_map, &num_transfers, rg, &m, &ready, &cv](
+                  boost::span<span_value_type<decltype(values)> > s) {
+          (void)s;
+
+          {
+            std::unique_lock<std::mutex> lk(m);
+            cv.wait(lk, [&] { return ready; });
+          }
+
+          map_type y(std::move(x));
+
+          if (!y.empty()) {
+            ++num_transfers;
+            y.cvisit_all([&reference_map, rg](map_value_type const& val) {
+              BOOST_TEST(reference_map.contains(val.first));
+              if (rg == sequential) {
+                BOOST_TEST_EQ(
+                  val.second, reference_map.find(val.first)->second);
+              }
+            });
+          }
+        });
+
+      t1.join();
+      t2.join();
+
+      BOOST_TEST_GE(num_transfers, 1u);
+    }
+
+    check_raii_counts();
+  }
+
+  template <class G>
+  void iterator_range_with_allocator(G gen, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+
+    raii::reset_counts();
+
+    {
+      allocator_type a;
+      map_type x(values.begin(), values.end(), a);
+
+      BOOST_TEST_GT(x.size(), 0u);
+      BOOST_TEST_LE(x.size(), values.size());
+      if (rg == sequential) {
+        BOOST_TEST_EQ(x.size(), values.size());
+      }
+
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+
+      BOOST_TEST(x.get_allocator() == a);
+
+      test_fuzzy_matches_reference(x, reference_map, rg);
+    }
+
+    check_raii_counts();
+  }
+
+  UNORDERED_AUTO_TEST (explicit_allocator) {
+    raii::reset_counts();
+
+    {
+      allocator_type a;
+      map_type x(a);
+
+      BOOST_TEST_EQ(x.size(), 0u);
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+
+      BOOST_TEST(x.get_allocator() == a);
+    }
+  }
+
+  UNORDERED_AUTO_TEST (initializer_list_with_all_params) {
+    std::initializer_list<map_value_type> ilist{
+      map_value_type{raii{0}, raii{0}},
+      map_value_type{raii{1}, raii{1}},
+      map_value_type{raii{2}, raii{2}},
+      map_value_type{raii{3}, raii{3}},
+      map_value_type{raii{4}, raii{4}},
+      map_value_type{raii{5}, raii{5}},
+      map_value_type{raii{6}, raii{6}},
+      map_value_type{raii{6}, raii{6}},
+      map_value_type{raii{7}, raii{7}},
+      map_value_type{raii{8}, raii{8}},
+      map_value_type{raii{9}, raii{9}},
+      map_value_type{raii{10}, raii{10}},
+      map_value_type{raii{9}, raii{9}},
+      map_value_type{raii{8}, raii{8}},
+      map_value_type{raii{7}, raii{7}},
+      map_value_type{raii{6}, raii{6}},
+      map_value_type{raii{5}, raii{5}},
+      map_value_type{raii{4}, raii{4}},
+      map_value_type{raii{3}, raii{3}},
+      map_value_type{raii{2}, raii{2}},
+      map_value_type{raii{1}, raii{1}},
+      map_value_type{raii{0}, raii{0}},
+    };
+
+    {
+      raii::reset_counts();
+
+      map_type x(ilist, 0, hasher(1), key_equal(2), allocator_type(3));
+
+      BOOST_TEST_EQ(x.size(), 11u);
+      BOOST_TEST_EQ(x.hash_function(), hasher(1));
+      BOOST_TEST_EQ(x.key_eq(), key_equal(2));
+      BOOST_TEST(x.get_allocator() == allocator_type(3));
+
+      BOOST_TEST_EQ(raii::move_constructor, 0u);
+    }
+    check_raii_counts();
+
+    {
+      raii::reset_counts();
+
+      map_type x(ilist, allocator_type(3));
+
+      BOOST_TEST_EQ(x.size(), 11u);
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == allocator_type(3));
+
+      BOOST_TEST_EQ(raii::move_constructor, 0u);
+    }
+    check_raii_counts();
+
+    {
+      raii::reset_counts();
+
+      map_type x(ilist, 0, allocator_type(3));
+
+      BOOST_TEST_EQ(x.size(), 11u);
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == allocator_type(3));
+
+      BOOST_TEST_EQ(raii::move_constructor, 0u);
+    }
+    check_raii_counts();
+
+    {
+      raii::reset_counts();
+
+      map_type x(ilist, 0, hasher(1), allocator_type(3));
+
+      BOOST_TEST_EQ(x.size(), 11u);
+      BOOST_TEST_EQ(x.hash_function(), hasher(1));
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == allocator_type(3));
+
+      BOOST_TEST_EQ(raii::move_constructor, 0u);
+    }
+    check_raii_counts();
+  }
+
+  UNORDERED_AUTO_TEST (bucket_count_and_allocator) {
+    raii::reset_counts();
+
+    {
+      map_type x(0, allocator_type(3));
+      BOOST_TEST_EQ(x.size(), 0u);
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == allocator_type(3));
+    }
+
+    {
+      map_type x(4096, allocator_type(3));
+      BOOST_TEST_EQ(x.size(), 0u);
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == allocator_type(3));
+    }
+  }
+
+  UNORDERED_AUTO_TEST (bucket_count_with_hasher_and_allocator) {
+    raii::reset_counts();
+
+    {
+      map_type x(0, hasher(1), allocator_type(3));
+      BOOST_TEST_EQ(x.size(), 0u);
+      BOOST_TEST_EQ(x.hash_function(), hasher(1));
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == allocator_type(3));
+    }
+  }
+
+  template <class G>
+  void iterator_range_with_bucket_count_and_allocator(
+    G gen, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+
+    raii::reset_counts();
+
+    {
+      allocator_type a(3);
+      map_type x(values.begin(), values.end(), 0, a);
+      test_fuzzy_matches_reference(x, reference_map, rg);
+
+      BOOST_TEST_EQ(x.hash_function(), hasher());
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == a);
+    }
+
+    check_raii_counts();
+  }
+
+  template <class G>
+  void iterator_range_with_bucket_count_hasher_and_allocator(
+    G gen, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+
+    raii::reset_counts();
+
+    {
+      allocator_type a(3);
+      hasher hf(1);
+      map_type x(values.begin(), values.end(), 0, hf, a);
+      test_fuzzy_matches_reference(x, reference_map, rg);
+
+      BOOST_TEST_EQ(x.hash_function(), hf);
+      BOOST_TEST_EQ(x.key_eq(), key_equal());
+      BOOST_TEST(x.get_allocator() == a);
+    }
+
+    check_raii_counts();
+  }
+
+} // namespace
+
+// clang-format off
+UNORDERED_TEST(
+  from_iterator_range,
+  ((value_type_generator))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  copy_constructor,
+  ((value_type_generator))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  copy_constructor_with_insertion,
+  ((value_type_generator))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  move_constructor,
+  ((value_type_generator))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  move_constructor_with_insertion,
+  ((value_type_generator))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  iterator_range_with_allocator,
+  ((value_type_generator))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  iterator_range_with_bucket_count_and_allocator,
+  ((value_type_generator))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  iterator_range_with_bucket_count_hasher_and_allocator,
+  ((value_type_generator))
+  ((default_generator)(sequential)(limited_range)))
+
+// clang-format on
+
+RUN_TESTS()

test/cfoa/emplace_tests.cpp

@@ -0,0 +1,167 @@
+// Copyright (C) 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "helpers.hpp"
+
+#include <boost/unordered/concurrent_flat_map.hpp>
+
+#include <boost/core/ignore_unused.hpp>
+
+namespace {
+  test::seed_t initialize_seed(335740237);
+
+  struct lvalue_emplacer_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      thread_runner(values, [&x, &num_inserts](boost::span<T> s) {
+        for (auto const& r : s) {
+          bool b = x.emplace(r.first.x_, r.second.x_);
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(raii::default_constructor, 2 * values.size());
+
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_GE(raii::move_constructor, 2 * x.size());
+
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } lvalue_emplacer;
+
+  struct norehash_lvalue_emplacer_type : public lvalue_emplacer_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      x.reserve(values.size());
+      lvalue_emplacer_type::operator()(values, x);
+      BOOST_TEST_EQ(raii::move_constructor, 2 * x.size());
+    }
+  } norehash_lvalue_emplacer;
+
+  struct lvalue_emplace_or_cvisit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.emplace_or_cvisit(
+            r.first.x_, r.second.x_,
+            [&num_invokes](typename X::value_type const& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, 2 * values.size());
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_GE(raii::move_constructor, 2 * x.size());
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+    }
+  } lvalue_emplace_or_cvisit;
+
+  struct lvalue_emplace_or_visit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.emplace_or_visit(
+            r.first.x_, r.second.x_,
+            [&num_invokes](typename X::value_type& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, 2 * values.size());
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_GE(raii::move_constructor, 2 * x.size());
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+    }
+  } lvalue_emplace_or_visit;
+
+  template <class X, class G, class F>
+  void emplace(X*, G gen, F emplacer, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+    raii::reset_counts();
+
+    {
+      X x;
+
+      emplacer(values, x);
+
+      BOOST_TEST_EQ(x.size(), reference_map.size());
+
+      using value_type = typename X::value_type;
+      BOOST_TEST_EQ(x.size(), x.visit_all([&](value_type const& kv) {
+        BOOST_TEST(reference_map.contains(kv.first));
+        if (rg == test::sequential) {
+          BOOST_TEST_EQ(kv.second, reference_map[kv.first]);
+        }
+      }));
+    }
+
+    BOOST_TEST_GE(raii::default_constructor, 0u);
+    BOOST_TEST_GE(raii::copy_constructor, 0u);
+    BOOST_TEST_GE(raii::move_constructor, 0u);
+    BOOST_TEST_GT(raii::destructor, 0u);
+
+    BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                    raii::move_constructor,
+      raii::destructor);
+  }
+
+  boost::unordered::concurrent_flat_map<raii, raii>* map;
+
+} // namespace
+
+using test::default_generator;
+using test::limited_range;
+using test::sequential;
+
+// clang-format off
+
+UNORDERED_TEST(
+  emplace,
+  ((map))
+  ((value_type_generator)(init_type_generator))
+  ((lvalue_emplacer)(norehash_lvalue_emplacer)
+   (lvalue_emplace_or_cvisit)(lvalue_emplace_or_visit))
+  ((default_generator)(sequential)(limited_range)))
+
+// clang-format on
+
+RUN_TESTS()

test/cfoa/erase_tests.cpp

@@ -0,0 +1,368 @@
+// Copyright (C) 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "helpers.hpp"
+
+#include <boost/unordered/concurrent_flat_map.hpp>
+
+#include <boost/core/ignore_unused.hpp>
+
+namespace {
+  test::seed_t initialize_seed(3292023);
+
+  struct lvalue_eraser_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_erased{0};
+      auto const old_size = x.size();
+
+      auto const old_dc = +raii::default_constructor;
+      auto const old_cc = +raii::copy_constructor;
+      auto const old_mc = +raii::move_constructor;
+
+      auto const old_d = +raii::destructor;
+
+      BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                      raii::move_constructor,
+        raii::destructor + 2 * x.size());
+
+      thread_runner(values, [&values, &num_erased, &x](boost::span<T>) {
+        for (auto const& k : values) {
+          auto count = x.erase(k.first);
+          num_erased += count;
+          BOOST_TEST_LE(count, 1u);
+          BOOST_TEST_GE(count, 0u);
+        }
+      });
+
+      BOOST_TEST_EQ(raii::default_constructor, old_dc);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc);
+
+      BOOST_TEST_EQ(raii::destructor, old_d + 2 * old_size);
+
+      BOOST_TEST_EQ(x.size(), 0u);
+      BOOST_TEST(x.empty());
+      BOOST_TEST_EQ(num_erased, old_size);
+    }
+  } lvalue_eraser;
+
+  struct transp_lvalue_eraser_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_erased{0};
+      auto const old_size = x.size();
+
+      auto const old_dc = +raii::default_constructor;
+      auto const old_cc = +raii::copy_constructor;
+      auto const old_mc = +raii::move_constructor;
+
+      auto const old_d = +raii::destructor;
+
+      BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                      raii::move_constructor,
+        raii::destructor + 2 * x.size());
+
+      thread_runner(values, [&num_erased, &x](boost::span<T> s) {
+        for (auto const& k : s) {
+          auto count = x.erase(k.first.x_);
+          num_erased += count;
+          BOOST_TEST_LE(count, 1u);
+          BOOST_TEST_GE(count, 0u);
+        }
+      });
+
+      BOOST_TEST_EQ(raii::default_constructor, old_dc);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc);
+
+      BOOST_TEST_EQ(raii::destructor, old_d + 2 * num_erased);
+
+      BOOST_TEST_EQ(x.size(), 0u);
+      BOOST_TEST(x.empty());
+      BOOST_TEST_EQ(num_erased, old_size);
+    }
+  } transp_lvalue_eraser;
+
+  struct lvalue_eraser_if_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      using value_type = typename X::value_type;
+
+      std::atomic<std::uint64_t> num_erased{0};
+
+      auto const old_size = x.size();
+
+      auto const old_dc = +raii::default_constructor;
+      auto const old_cc = +raii::copy_constructor;
+      auto const old_mc = +raii::move_constructor;
+
+      auto const old_d = +raii::destructor;
+
+      auto max = 0;
+      x.visit_all([&max](value_type const& v) {
+        if (v.second.x_ > max) {
+          max = v.second.x_;
+        }
+      });
+
+      auto threshold = max / 2;
+
+      auto expected_erasures = 0u;
+      x.visit_all([&expected_erasures, threshold](value_type const& v) {
+        if (v.second.x_ > threshold) {
+          ++expected_erasures;
+        }
+      });
+
+      thread_runner(values, [&num_erased, &x, threshold](boost::span<T> s) {
+        for (auto const& k : s) {
+          auto count = x.erase_if(k.first,
+            [threshold](value_type& v) { return v.second.x_ > threshold; });
+          num_erased += count;
+          BOOST_TEST_LE(count, 1u);
+          BOOST_TEST_GE(count, 0u);
+        }
+      });
+
+      BOOST_TEST_EQ(num_erased, expected_erasures);
+      BOOST_TEST_EQ(x.size(), old_size - num_erased);
+
+      BOOST_TEST_EQ(raii::default_constructor, old_dc);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc);
+
+      BOOST_TEST_EQ(raii::destructor, old_d + 2 * num_erased);
+    }
+  } lvalue_eraser_if;
+
+  struct transp_lvalue_eraser_if_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      using value_type = typename X::value_type;
+
+      std::atomic<std::uint64_t> num_erased{0};
+
+      auto const old_size = x.size();
+
+      auto const old_dc = +raii::default_constructor;
+      auto const old_cc = +raii::copy_constructor;
+      auto const old_mc = +raii::move_constructor;
+
+      auto const old_d = +raii::destructor;
+
+      auto max = 0;
+      x.visit_all([&max](value_type const& v) {
+        if (v.second.x_ > max) {
+          max = v.second.x_;
+        }
+      });
+
+      auto threshold = max / 2;
+
+      auto expected_erasures = 0u;
+      x.visit_all([&expected_erasures, threshold](value_type const& v) {
+        if (v.second.x_ > threshold) {
+          ++expected_erasures;
+        }
+      });
+
+      thread_runner(values, [&num_erased, &x, threshold](boost::span<T> s) {
+        for (auto const& k : s) {
+          auto count = x.erase_if(k.first.x_,
+            [threshold](value_type& v) { return v.second.x_ > threshold; });
+          num_erased += count;
+          BOOST_TEST_LE(count, 1u);
+          BOOST_TEST_GE(count, 0u);
+        }
+      });
+
+      BOOST_TEST_EQ(num_erased, expected_erasures);
+      BOOST_TEST_EQ(x.size(), old_size - num_erased);
+
+      BOOST_TEST_EQ(raii::default_constructor, old_dc);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc);
+
+      BOOST_TEST_EQ(raii::destructor, old_d + 2 * num_erased);
+    }
+  } transp_lvalue_eraser_if;
+
+  struct erase_if_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      using value_type = typename X::value_type;
+
+      std::atomic<std::uint64_t> num_erased{0};
+
+      auto const old_size = x.size();
+
+      auto const old_dc = +raii::default_constructor;
+      auto const old_cc = +raii::copy_constructor;
+      auto const old_mc = +raii::move_constructor;
+
+      auto const old_d = +raii::destructor;
+
+      auto max = 0;
+      x.visit_all([&max](value_type const& v) {
+        if (v.second.x_ > max) {
+          max = v.second.x_;
+        }
+      });
+
+      auto threshold = max / 2;
+
+      auto expected_erasures = 0u;
+      x.visit_all([&expected_erasures, threshold](value_type const& v) {
+        if (v.second.x_ > threshold) {
+          ++expected_erasures;
+        }
+      });
+
+      thread_runner(values, [&num_erased, &x, threshold](boost::span<T> s) {
+        for (auto const& k : s) {
+          (void)k;
+          auto count = x.erase_if(
+            [threshold](value_type& v) { return v.second.x_ > threshold; });
+          num_erased += count;
+        }
+      });
+
+      BOOST_TEST_EQ(num_erased, expected_erasures);
+      BOOST_TEST_EQ(x.size(), old_size - num_erased);
+
+      BOOST_TEST_EQ(raii::default_constructor, old_dc);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc);
+
+      BOOST_TEST_EQ(raii::destructor, old_d + 2 * num_erased);
+    }
+  } erase_if;
+
+  struct erase_if_exec_policy_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+#if defined(BOOST_UNORDERED_PARALLEL_ALGORITHMS)
+      using value_type = typename X::value_type;
+
+      std::atomic<std::uint64_t> num_invokes{0};
+
+      auto const old_size = x.size();
+
+      auto const old_dc = +raii::default_constructor;
+      auto const old_cc = +raii::copy_constructor;
+      auto const old_mc = +raii::move_constructor;
+
+      auto const old_d = +raii::destructor;
+
+      auto max = 0;
+      x.visit_all([&max](value_type const& v) {
+        if (v.second.x_ > max) {
+          max = v.second.x_;
+        }
+      });
+
+      auto threshold = max / 2;
+
+      auto expected_erasures = 0u;
+      x.visit_all([&expected_erasures, threshold](value_type const& v) {
+        if (v.second.x_ > threshold) {
+          ++expected_erasures;
+        }
+      });
+
+      thread_runner(values, [&num_invokes, &x, threshold](boost::span<T> s) {
+        (void)s;
+        x.erase_if(
+          std::execution::par_unseq, [&num_invokes, threshold](value_type& v) {
+            ++num_invokes;
+            return v.second.x_ > threshold;
+          });
+      });
+
+      BOOST_TEST_GE(+num_invokes, old_size);
+      BOOST_TEST_LE(+num_invokes, old_size * num_threads);
+
+      BOOST_TEST_EQ(raii::default_constructor, old_dc);
+      BOOST_TEST_EQ(raii::copy_constructor, old_cc);
+      BOOST_TEST_EQ(raii::move_constructor, old_mc);
+
+      BOOST_TEST_EQ(raii::destructor, old_d + 2 * expected_erasures);
+#else
+      (void)values;
+      (void)x;
+#endif
+    }
+  } erase_if_exec_policy;
+
+  template <class X, class G, class F>
+  void erase(X*, G gen, F eraser, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+    raii::reset_counts();
+
+    {
+      X x;
+
+      x.insert(values.begin(), values.end());
+
+      BOOST_TEST_EQ(x.size(), reference_map.size());
+
+      using value_type = typename X::value_type;
+      BOOST_TEST_EQ(x.size(), x.visit_all([&](value_type const& kv) {
+        BOOST_TEST(reference_map.contains(kv.first));
+        if (rg == test::sequential) {
+          BOOST_TEST_EQ(kv.second, reference_map[kv.first]);
+        }
+      }));
+
+      eraser(values, x);
+    }
+
+    BOOST_TEST_GE(raii::default_constructor, 0u);
+    BOOST_TEST_GE(raii::copy_constructor, 0u);
+    BOOST_TEST_GE(raii::move_constructor, 0u);
+    BOOST_TEST_GT(raii::destructor, 0u);
+
+    BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                    raii::move_constructor,
+      raii::destructor);
+  }
+
+  boost::unordered::concurrent_flat_map<raii, raii>* map;
+  boost::unordered::concurrent_flat_map<raii, raii, transp_hash,
+    transp_key_equal>* transparent_map;
+
+} // namespace
+
+using test::default_generator;
+using test::limited_range;
+using test::sequential;
+
+// clang-format off
+UNORDERED_TEST(
+  erase,
+  ((map))
+  ((value_type_generator)(init_type_generator))
+  ((lvalue_eraser)(lvalue_eraser_if)(erase_if)(erase_if_exec_policy))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  erase,
+  ((transparent_map))
+  ((value_type_generator)(init_type_generator))
+  ((transp_lvalue_eraser)(transp_lvalue_eraser_if)(erase_if_exec_policy))
+  ((default_generator)(sequential)(limited_range)))
+
+// clang-format on
+
+RUN_TESTS()

test/cfoa/helpers.hpp

@@ -0,0 +1,390 @@
+#ifndef BOOST_UNORDERED_TEST_CFOA_HELPERS_HPP
+#define BOOST_UNORDERED_TEST_CFOA_HELPERS_HPP
+
+#include "../helpers/generators.hpp"
+#include "../helpers/test.hpp"
+
+#include <boost/container_hash/hash.hpp>
+#include <boost/core/span.hpp>
+#include <boost/unordered/unordered_flat_map.hpp>
+
+#include <atomic>
+#include <condition_variable>
+#include <cstddef>
+#include <iostream>
+#include <mutex>
+#include <thread>
+#include <vector>
+
+constexpr std::size_t const num_threads = 16;
+
+struct transp_hash
+{
+  using is_transparent = void;
+
+  template <class T> std::size_t operator()(T const& t) const noexcept
+  {
+    std::this_thread::yield();
+    return boost::hash<T>()(t);
+  }
+};
+
+struct transp_key_equal
+{
+  using is_transparent = void;
+
+  template <class T, class U> bool operator()(T const& lhs, U const& rhs) const
+  {
+    std::this_thread::yield();
+    return lhs == rhs;
+  }
+};
+
+struct stateful_hash
+{
+  int x_ = -1;
+
+  stateful_hash() = default;
+  stateful_hash(stateful_hash const&) = default;
+  stateful_hash(stateful_hash&& rhs) noexcept
+  {
+    auto tmp = x_;
+    x_ = rhs.x_;
+    rhs.x_ = tmp;
+  }
+
+  stateful_hash(int const x) : x_{x} {}
+
+  template <class T> std::size_t operator()(T const& t) const noexcept
+  {
+    std::size_t h = static_cast<std::size_t>(x_);
+    boost::hash_combine(h, t);
+    std::this_thread::yield();
+    return h;
+  }
+
+  bool operator==(stateful_hash const& rhs) const { return x_ == rhs.x_; }
+
+  friend std::ostream& operator<<(std::ostream& os, stateful_hash const& rhs)
+  {
+    os << "{ x_: " << rhs.x_ << " }";
+    return os;
+  }
+
+  friend void swap(stateful_hash& lhs, stateful_hash& rhs) noexcept
+  {
+    if (&lhs != &rhs) {
+      std::swap(lhs.x_, rhs.x_);
+    }
+  }
+};
+
+struct stateful_key_equal
+{
+  int x_ = -1;
+
+  stateful_key_equal() = default;
+  stateful_key_equal(stateful_key_equal const&) = default;
+  stateful_key_equal(stateful_key_equal&& rhs) noexcept
+  {
+    auto tmp = x_;
+    x_ = rhs.x_;
+    rhs.x_ = tmp;
+  }
+
+  stateful_key_equal(int const x) : x_{x} {}
+
+  template <class T, class U> bool operator()(T const& t, U const& u) const
+  {
+    std::this_thread::yield();
+    return t == u;
+  }
+
+  bool operator==(stateful_key_equal const& rhs) const { return x_ == rhs.x_; }
+
+  friend std::ostream& operator<<(
+    std::ostream& os, stateful_key_equal const& rhs)
+  {
+    os << "{ x_: " << rhs.x_ << " }";
+    return os;
+  }
+
+  friend void swap(stateful_key_equal& lhs, stateful_key_equal& rhs) noexcept
+  {
+    if (&lhs != &rhs) {
+      std::swap(lhs.x_, rhs.x_);
+    }
+  }
+};
+
+template <class T> struct stateful_allocator
+{
+  int x_ = -1;
+
+  using value_type = T;
+
+  stateful_allocator() = default;
+  stateful_allocator(stateful_allocator const&) = default;
+  stateful_allocator(stateful_allocator&&) = default;
+
+  stateful_allocator(int const x) : x_{x} {}
+
+  template <class U>
+  stateful_allocator(stateful_allocator<U> const& rhs) : x_{rhs.x_}
+  {
+  }
+
+  T* allocate(std::size_t n)
+  {
+    return static_cast<T*>(::operator new(n * sizeof(T)));
+  }
+
+  void deallocate(T* p, std::size_t) { ::operator delete(p); }
+
+  bool operator==(stateful_allocator const& rhs) const { return x_ == rhs.x_; }
+  bool operator!=(stateful_allocator const& rhs) const { return x_ != rhs.x_; }
+};
+
+struct raii
+{
+  static std::atomic<std::uint32_t> default_constructor;
+  static std::atomic<std::uint32_t> copy_constructor;
+  static std::atomic<std::uint32_t> move_constructor;
+  static std::atomic<std::uint32_t> destructor;
+
+  static std::atomic<std::uint32_t> copy_assignment;
+  static std::atomic<std::uint32_t> move_assignment;
+
+  int x_ = -1;
+
+  raii() { ++default_constructor; }
+  raii(int const x) : x_{x} { ++default_constructor; }
+  raii(raii const& rhs) : x_{rhs.x_} { ++copy_constructor; }
+  raii(raii&& rhs) noexcept : x_{rhs.x_}
+  {
+    rhs.x_ = -1;
+    ++move_constructor;
+  }
+  ~raii() { ++destructor; }
+
+  raii& operator=(raii const& rhs)
+  {
+    ++copy_assignment;
+    if (this != &rhs) {
+      x_ = rhs.x_;
+    }
+    return *this;
+  }
+
+  raii& operator=(raii&& rhs) noexcept
+  {
+    ++move_assignment;
+    if (this != &rhs) {
+      x_ = rhs.x_;
+      rhs.x_ = -1;
+    }
+    return *this;
+  }
+
+  friend bool operator==(raii const& lhs, raii const& rhs)
+  {
+    return lhs.x_ == rhs.x_;
+  }
+
+  friend bool operator!=(raii const& lhs, raii const& rhs)
+  {
+    return !(lhs == rhs);
+  }
+
+  friend bool operator==(raii const& lhs, int const x) { return lhs.x_ == x; }
+  friend bool operator!=(raii const& lhs, int const x)
+  {
+    return !(lhs.x_ == x);
+  }
+
+  friend bool operator==(int const x, raii const& rhs) { return rhs.x_ == x; }
+
+  friend bool operator!=(int const x, raii const& rhs)
+  {
+    return !(rhs.x_ == x);
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, raii const& rhs)
+  {
+    os << "{ x_: " << rhs.x_ << " }";
+    return os;
+  }
+
+  friend std::ostream& operator<<(
+    std::ostream& os, std::pair<raii const, raii> const& rhs)
+  {
+    os << "pair<" << rhs.first << ", " << rhs.second << ">";
+    return os;
+  }
+
+  static void reset_counts()
+  {
+    default_constructor = 0;
+    copy_constructor = 0;
+    move_constructor = 0;
+    destructor = 0;
+    copy_assignment = 0;
+    move_assignment = 0;
+  }
+};
+
+std::atomic<std::uint32_t> raii::default_constructor{0};
+std::atomic<std::uint32_t> raii::copy_constructor{0};
+std::atomic<std::uint32_t> raii::move_constructor{0};
+std::atomic<std::uint32_t> raii::destructor{0};
+std::atomic<std::uint32_t> raii::copy_assignment{0};
+std::atomic<std::uint32_t> raii::move_assignment{0};
+
+std::size_t hash_value(raii const& r) noexcept
+{
+  boost::hash<int> hasher;
+  return hasher(r.x_);
+}
+
+template <class F>
+auto make_random_values(std::size_t count, F f) -> std::vector<decltype(f())>
+{
+  using vector_type = std::vector<decltype(f())>;
+
+  vector_type v;
+  v.reserve(count);
+  for (std::size_t i = 0; i < count; ++i) {
+    v.emplace_back(f());
+  }
+  return v;
+}
+
+struct value_type_generator_type
+{
+  std::pair<raii const, raii> operator()(test::random_generator rg)
+  {
+    int* p = nullptr;
+    int a = generate(p, rg);
+    int b = generate(p, rg);
+    return std::make_pair(raii{a}, raii{b});
+  }
+} value_type_generator;
+
+struct init_type_generator_type
+{
+  std::pair<raii, raii> operator()(test::random_generator rg)
+  {
+    int* p = nullptr;
+    int a = generate(p, rg);
+    int b = generate(p, rg);
+    return std::make_pair(raii{a}, raii{b});
+  }
+} init_type_generator;
+
+template <class T>
+std::vector<boost::span<T> > split(
+  boost::span<T> s, std::size_t const nt /* num threads*/)
+{
+  std::vector<boost::span<T> > subslices;
+  subslices.reserve(nt);
+
+  auto a = s.size() / nt;
+  auto b = a;
+  if (s.size() % nt != 0) {
+    ++b;
+  }
+
+  auto num_a = nt;
+  auto num_b = std::size_t{0};
+
+  if (nt * b > s.size()) {
+    num_a = nt * b - s.size();
+    num_b = nt - num_a;
+  }
+
+  auto sub_b = s.subspan(0, num_b * b);
+  auto sub_a = s.subspan(num_b * b);
+
+  for (std::size_t i = 0; i < num_b; ++i) {
+    subslices.push_back(sub_b.subspan(i * b, b));
+  }
+
+  for (std::size_t i = 0; i < num_a; ++i) {
+    auto const is_last = i == (num_a - 1);
+    subslices.push_back(
+      sub_a.subspan(i * a, is_last ? boost::dynamic_extent : a));
+  }
+
+  return subslices;
+}
+
+template <class T, class F> void thread_runner(std::vector<T>& values, F f)
+{
+  std::mutex m;
+  std::condition_variable cv;
+  std::size_t c = 0;
+
+  std::vector<std::thread> threads;
+  auto subslices = split<T>(values, num_threads);
+
+  for (std::size_t i = 0; i < num_threads; ++i) {
+    threads.emplace_back([&f, &subslices, i, &m, &cv, &c] {
+      {
+        std::unique_lock<std::mutex> lk(m);
+        ++c;
+        if (c == num_threads) {
+          lk.unlock();
+          cv.notify_all();
+        } else {
+          cv.wait(lk, [&] { return c == num_threads; });
+        }
+      }
+
+      auto s = subslices[i];
+      f(s);
+    });
+  }
+
+  for (auto& t : threads) {
+    t.join();
+  }
+}
+
+template <class X, class Y>
+void test_matches_reference(X const& x, Y const& reference_map)
+{
+  using value_type = typename X::value_type;
+  BOOST_TEST_EQ(x.size(), x.visit_all([&](value_type const& kv) {
+    BOOST_TEST(reference_map.contains(kv.first));
+    BOOST_TEST_EQ(kv.second, reference_map.find(kv.first)->second);
+  }));
+}
+
+template <class X, class Y>
+void test_fuzzy_matches_reference(
+  X const& x, Y const& reference_map, test::random_generator rg)
+{
+  using value_type = typename X::value_type;
+  BOOST_TEST_EQ(x.size(), x.visit_all([&](value_type const& kv) {
+    BOOST_TEST(reference_map.contains(kv.first));
+    if (rg == test::sequential) {
+      BOOST_TEST_EQ(kv.second, reference_map.find(kv.first)->second);
+    }
+  }));
+}
+
+template <class T> using span_value_type = typename T::value_type;
+
+void check_raii_counts()
+{
+  BOOST_TEST_GE(raii::default_constructor, 0u);
+  BOOST_TEST_GE(raii::copy_constructor, 0u);
+  BOOST_TEST_GE(raii::move_constructor, 0u);
+  BOOST_TEST_GT(raii::destructor, 0u);
+
+  BOOST_TEST_EQ(
+    raii::default_constructor + raii::copy_constructor + raii::move_constructor,
+    raii::destructor);
+}
+
+#endif // BOOST_UNORDERED_TEST_CFOA_HELPERS_HPP

test/cfoa/insert_tests.cpp

@@ -0,0 +1,585 @@
+// Copyright (C) 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "helpers.hpp"
+
+#include <boost/unordered/concurrent_flat_map.hpp>
+
+#include <boost/core/ignore_unused.hpp>
+
+namespace {
+  test::seed_t initialize_seed(78937);
+
+  struct lvalue_inserter_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      thread_runner(values, [&x, &num_inserts](boost::span<T> s) {
+        for (auto const& r : s) {
+          bool b = x.insert(r);
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } lvalue_inserter;
+
+  struct norehash_lvalue_inserter_type : public lvalue_inserter_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      x.reserve(values.size());
+      lvalue_inserter_type::operator()(values, x);
+      BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
+      BOOST_TEST_EQ(raii::move_constructor, 0u);
+    }
+  } norehash_lvalue_inserter;
+
+  struct rvalue_inserter_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+
+      std::atomic<std::uint64_t> num_inserts{0};
+      thread_runner(values, [&x, &num_inserts](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.insert(std::move(r));
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+      BOOST_TEST_EQ(num_inserts, x.size());
+
+      if (std::is_same<T, typename X::value_type>::value) {
+        BOOST_TEST_EQ(raii::copy_constructor, x.size());
+      } else {
+        BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      }
+
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } rvalue_inserter;
+
+  struct norehash_rvalue_inserter_type : public rvalue_inserter_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      x.reserve(values.size());
+
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_EQ(raii::move_constructor, 0u);
+
+      rvalue_inserter_type::operator()(values, x);
+
+      if (std::is_same<T, typename X::value_type>::value) {
+        BOOST_TEST_EQ(raii::copy_constructor, x.size());
+        BOOST_TEST_EQ(raii::move_constructor, x.size());
+      } else {
+        BOOST_TEST_EQ(raii::copy_constructor, 0u);
+        BOOST_TEST_EQ(raii::move_constructor, 2 * x.size());
+      }
+    }
+  } norehash_rvalue_inserter;
+
+  struct iterator_range_inserter_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      thread_runner(
+        values, [&x](boost::span<T> s) { x.insert(s.begin(), s.end()); });
+
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } iterator_range_inserter;
+
+  struct lvalue_insert_or_assign_copy_assign_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      thread_runner(values, [&x](boost::span<T> s) {
+        for (auto& r : s) {
+          x.insert_or_assign(r.first, r.second);
+        }
+      });
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
+      // don't check move construction count here because of rehashing
+      BOOST_TEST_GT(raii::move_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, values.size() - x.size());
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } lvalue_insert_or_assign_copy_assign;
+
+  struct lvalue_insert_or_assign_move_assign_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      thread_runner(values, [&x](boost::span<T> s) {
+        for (auto& r : s) {
+          x.insert_or_assign(r.first, std::move(r.second));
+        }
+      });
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, x.size());
+      BOOST_TEST_GT(raii::move_constructor, x.size()); // rehashing
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, values.size() - x.size());
+    }
+  } lvalue_insert_or_assign_move_assign;
+
+  struct rvalue_insert_or_assign_copy_assign_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      thread_runner(values, [&x](boost::span<T> s) {
+        for (auto& r : s) {
+          x.insert_or_assign(std::move(r.first), r.second);
+        }
+      });
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, x.size());
+      BOOST_TEST_GT(raii::move_constructor, x.size()); // rehashing
+      BOOST_TEST_EQ(raii::copy_assignment, values.size() - x.size());
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } rvalue_insert_or_assign_copy_assign;
+
+  struct rvalue_insert_or_assign_move_assign_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      thread_runner(values, [&x](boost::span<T> s) {
+        for (auto& r : s) {
+          x.insert_or_assign(std::move(r.first), std::move(r.second));
+        }
+      });
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_GE(raii::move_constructor, 2 * x.size());
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, values.size() - x.size());
+    }
+  } rvalue_insert_or_assign_move_assign;
+
+  struct trans_insert_or_assign_copy_assign_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      using is_transparent =
+        typename boost::make_void<typename X::hasher::is_transparent,
+          typename X::key_equal::is_transparent>::type;
+
+      boost::ignore_unused<is_transparent>();
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+
+      thread_runner(values, [&x](boost::span<T> s) {
+        for (auto& r : s) {
+          x.insert_or_assign(r.first.x_, r.second);
+        }
+      });
+
+      BOOST_TEST_EQ(raii::default_constructor, x.size());
+      BOOST_TEST_EQ(raii::copy_constructor, x.size());
+      BOOST_TEST_GT(raii::move_constructor, x.size()); // rehashing
+      BOOST_TEST_EQ(raii::copy_assignment, values.size() - x.size());
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } trans_insert_or_assign_copy_assign;
+
+  struct trans_insert_or_assign_move_assign_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      using is_transparent =
+        typename boost::make_void<typename X::hasher::is_transparent,
+          typename X::key_equal::is_transparent>::type;
+
+      boost::ignore_unused<is_transparent>();
+
+      thread_runner(values, [&x](boost::span<T> s) {
+        for (auto& r : s) {
+          x.insert_or_assign(r.first.x_, std::move(r.second));
+        }
+      });
+
+      BOOST_TEST_EQ(raii::default_constructor, x.size());
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_GT(raii::move_constructor, 2 * x.size()); // rehashing
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, values.size() - x.size());
+    }
+  } trans_insert_or_assign_move_assign;
+
+  struct lvalue_insert_or_cvisit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.insert_or_cvisit(
+            r, [&num_invokes](typename X::value_type const& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
+      // don't check move construction count here because of rehashing
+      BOOST_TEST_GT(raii::move_constructor, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } lvalue_insert_or_cvisit;
+
+  struct lvalue_insert_or_visit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b =
+            x.insert_or_visit(r, [&num_invokes](typename X::value_type& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
+      // don't check move construction count here because of rehashing
+      BOOST_TEST_GT(raii::move_constructor, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } lvalue_insert_or_visit;
+
+  struct rvalue_insert_or_cvisit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.insert_or_cvisit(
+            std::move(r), [&num_invokes](typename X::value_type const& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+
+      if (std::is_same<T, typename X::value_type>::value) {
+        BOOST_TEST_EQ(raii::copy_constructor, x.size());
+        BOOST_TEST_GE(raii::move_constructor, x.size());
+      } else {
+        BOOST_TEST_EQ(raii::copy_constructor, 0u);
+        BOOST_TEST_GE(raii::move_constructor, 2 * x.size());
+      }
+    }
+  } rvalue_insert_or_cvisit;
+
+  struct rvalue_insert_or_visit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.insert_or_visit(
+            std::move(r), [&num_invokes](typename X::value_type& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+      if (std::is_same<T, typename X::value_type>::value) {
+        BOOST_TEST_EQ(raii::copy_constructor, x.size());
+        BOOST_TEST_GE(raii::move_constructor, x.size());
+      } else {
+        BOOST_TEST_EQ(raii::copy_constructor, 0u);
+        BOOST_TEST_GE(raii::move_constructor, 2 * x.size());
+      }
+    }
+  } rvalue_insert_or_visit;
+
+  struct iterator_range_insert_or_cvisit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_invokes](boost::span<T> s) {
+        x.insert_or_cvisit(
+          s.begin(), s.end(), [&num_invokes](typename X::value_type const& v) {
+            (void)v;
+            ++num_invokes;
+          });
+      });
+
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
+      BOOST_TEST_GT(raii::move_constructor, 0u);
+    }
+  } iterator_range_insert_or_cvisit;
+
+  struct iterator_range_insert_or_visit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_invokes](boost::span<T> s) {
+        x.insert_or_visit(
+          s.begin(), s.end(), [&num_invokes](typename X::value_type const& v) {
+            (void)v;
+            ++num_invokes;
+          });
+      });
+
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_constructor, 2 * x.size());
+      BOOST_TEST_GT(raii::move_constructor, 0u);
+    }
+  } iterator_range_insert_or_visit;
+
+  template <class X, class G, class F>
+  void insert(X*, G gen, F inserter, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+    raii::reset_counts();
+
+    {
+      X x;
+
+      inserter(values, x);
+
+      BOOST_TEST_EQ(x.size(), reference_map.size());
+
+      using value_type = typename X::value_type;
+      BOOST_TEST_EQ(x.size(), x.visit_all([&](value_type const& kv) {
+        BOOST_TEST(reference_map.contains(kv.first));
+        if (rg == test::sequential) {
+          BOOST_TEST_EQ(kv.second, reference_map[kv.first]);
+        }
+      }));
+    }
+
+    BOOST_TEST_GE(raii::default_constructor, 0u);
+    BOOST_TEST_GE(raii::copy_constructor, 0u);
+    BOOST_TEST_GE(raii::move_constructor, 0u);
+    BOOST_TEST_GT(raii::destructor, 0u);
+
+    BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                    raii::move_constructor,
+      raii::destructor);
+  }
+
+  template <class X> void insert_initializer_list(X*)
+  {
+    using value_type = typename X::value_type;
+
+    std::initializer_list<value_type> values{
+      value_type{raii{0}, raii{0}},
+      value_type{raii{1}, raii{1}},
+      value_type{raii{2}, raii{2}},
+      value_type{raii{3}, raii{3}},
+      value_type{raii{4}, raii{4}},
+      value_type{raii{5}, raii{5}},
+      value_type{raii{6}, raii{6}},
+      value_type{raii{6}, raii{6}},
+      value_type{raii{7}, raii{7}},
+      value_type{raii{8}, raii{8}},
+      value_type{raii{9}, raii{9}},
+      value_type{raii{10}, raii{10}},
+      value_type{raii{9}, raii{9}},
+      value_type{raii{8}, raii{8}},
+      value_type{raii{7}, raii{7}},
+      value_type{raii{6}, raii{6}},
+      value_type{raii{5}, raii{5}},
+      value_type{raii{4}, raii{4}},
+      value_type{raii{3}, raii{3}},
+      value_type{raii{2}, raii{2}},
+      value_type{raii{1}, raii{1}},
+      value_type{raii{0}, raii{0}},
+    };
+
+    std::vector<raii> dummy;
+
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+    raii::reset_counts();
+
+    {
+      {
+        X x;
+
+        thread_runner(
+          dummy, [&x, &values](boost::span<raii>) { x.insert(values); });
+
+        BOOST_TEST_EQ(x.size(), reference_map.size());
+
+        BOOST_TEST_EQ(x.size(), x.visit_all([&](value_type const& kv) {
+          BOOST_TEST(reference_map.contains(kv.first));
+          BOOST_TEST_EQ(kv.second, reference_map[kv.first]);
+        }));
+      }
+
+      BOOST_TEST_GE(raii::default_constructor, 0u);
+      BOOST_TEST_GE(raii::copy_constructor, 0u);
+      BOOST_TEST_GE(raii::move_constructor, 0u);
+      BOOST_TEST_GT(raii::destructor, 0u);
+
+      BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                      raii::move_constructor,
+        raii::destructor);
+
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+
+    {
+      {
+        std::atomic<std::uint64_t> num_invokes{0};
+
+        X x;
+
+        thread_runner(dummy, [&x, &values, &num_invokes](boost::span<raii>) {
+          x.insert_or_visit(values, [&num_invokes](typename X::value_type& v) {
+            (void)v;
+            ++num_invokes;
+          });
+
+          x.insert_or_cvisit(
+            values, [&num_invokes](typename X::value_type const& v) {
+              (void)v;
+              ++num_invokes;
+            });
+        });
+
+        BOOST_TEST_EQ(num_invokes, (values.size() - x.size()) +
+                                     (num_threads - 1) * values.size() +
+                                     num_threads * values.size());
+        BOOST_TEST_EQ(x.size(), reference_map.size());
+
+        BOOST_TEST_EQ(x.size(), x.visit_all([&](value_type const& kv) {
+          BOOST_TEST(reference_map.contains(kv.first));
+          BOOST_TEST_EQ(kv.second, reference_map[kv.first]);
+        }));
+      }
+
+      BOOST_TEST_GE(raii::default_constructor, 0u);
+      BOOST_TEST_GE(raii::copy_constructor, 0u);
+      BOOST_TEST_GE(raii::move_constructor, 0u);
+      BOOST_TEST_GT(raii::destructor, 0u);
+
+      BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                      raii::move_constructor,
+        raii::destructor);
+
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  }
+
+  boost::unordered::concurrent_flat_map<raii, raii>* map;
+  boost::unordered::concurrent_flat_map<raii, raii, transp_hash,
+    transp_key_equal>* trans_map;
+
+} // namespace
+
+using test::default_generator;
+using test::limited_range;
+using test::sequential;
+
+// clang-format off
+UNORDERED_TEST(
+  insert_initializer_list,
+  ((map)))
+
+UNORDERED_TEST(
+  insert,
+  ((map))
+  ((value_type_generator)(init_type_generator))
+  ((lvalue_inserter)(rvalue_inserter)(iterator_range_inserter)
+   (norehash_lvalue_inserter)(norehash_rvalue_inserter)
+   (lvalue_insert_or_cvisit)(lvalue_insert_or_visit)
+   (rvalue_insert_or_cvisit)(rvalue_insert_or_visit)
+   (iterator_range_insert_or_cvisit)(iterator_range_insert_or_visit))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  insert,
+  ((map))
+  ((init_type_generator))
+  ((lvalue_insert_or_assign_copy_assign)(lvalue_insert_or_assign_move_assign)
+   (rvalue_insert_or_assign_copy_assign)(rvalue_insert_or_assign_move_assign))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  insert,
+  ((trans_map))
+  ((init_type_generator))
+  ((trans_insert_or_assign_copy_assign)(trans_insert_or_assign_move_assign))
+  ((default_generator)(sequential)(limited_range)))
+// clang-format on
+
+RUN_TESTS()

test/cfoa/try_emplace_tests.cpp

@@ -0,0 +1,396 @@
+// Copyright (C) 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "helpers.hpp"
+
+#include <boost/unordered/concurrent_flat_map.hpp>
+
+#include <boost/core/ignore_unused.hpp>
+
+namespace {
+  test::seed_t initialize_seed(511933564);
+
+  struct lvalue_try_emplacer_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      thread_runner(values, [&x, &num_inserts](boost::span<T> s) {
+        for (auto const& r : s) {
+          bool b = x.try_emplace(r.first, r.second.x_);
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(raii::copy_constructor, x.size());
+      BOOST_TEST_EQ(raii::default_constructor, x.size());
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } lvalue_try_emplacer;
+
+  struct norehash_lvalue_try_emplacer_type : public lvalue_try_emplacer_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      x.reserve(values.size());
+      lvalue_try_emplacer_type::operator()(values, x);
+      BOOST_TEST_EQ(raii::move_constructor, 0u);
+    }
+  } norehash_lvalue_try_emplacer;
+
+  struct rvalue_try_emplacer_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+
+      std::atomic<std::uint64_t> num_inserts{0};
+      thread_runner(values, [&x, &num_inserts](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.try_emplace(std::move(r.first), r.second.x_);
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+
+      if (std::is_same<T, typename X::value_type>::value) {
+        BOOST_TEST_EQ(raii::copy_constructor, x.size());
+      } else {
+        BOOST_TEST_EQ(raii::copy_constructor, 0u);
+        BOOST_TEST_GE(raii::move_constructor, x.size());
+      }
+
+      BOOST_TEST_EQ(raii::default_constructor, x.size());
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } rvalue_try_emplacer;
+
+  struct norehash_rvalue_try_emplacer_type : public rvalue_try_emplacer_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      x.reserve(values.size());
+
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_EQ(raii::move_constructor, 0u);
+
+      rvalue_try_emplacer_type::operator()(values, x);
+
+      if (std::is_same<T, typename X::value_type>::value) {
+        BOOST_TEST_EQ(raii::copy_constructor, x.size());
+        BOOST_TEST_EQ(raii::move_constructor, 0u);
+      } else {
+        BOOST_TEST_EQ(raii::copy_constructor, 0u);
+        BOOST_TEST_EQ(raii::move_constructor, x.size());
+      }
+    }
+  } norehash_rvalue_try_emplacer;
+
+  struct transp_try_emplace_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      using is_transparent =
+        typename boost::make_void<typename X::hasher::is_transparent,
+          typename X::key_equal::is_transparent>::type;
+
+      boost::ignore_unused<is_transparent>();
+
+      BOOST_TEST_EQ(raii::default_constructor, 0u);
+
+      std::atomic<std::uint64_t> num_inserts{0};
+
+      thread_runner(values, [&x, &num_inserts](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.try_emplace(r.first.x_, r.second.x_);
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(raii::default_constructor, 2 * x.size());
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+    }
+  } transp_try_emplace;
+
+  struct norehash_transp_try_emplace_type : public transp_try_emplace_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      x.reserve(values.size());
+      transp_try_emplace_type::operator()(values, x);
+      BOOST_TEST_EQ(raii::move_constructor, 0u);
+    }
+  } norehash_transp_try_emplace;
+
+  struct lvalue_try_emplace_or_cvisit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.try_emplace_or_cvisit(
+            r.first, r.second.x_,
+            [&num_invokes](typename X::value_type const& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, x.size());
+      BOOST_TEST_EQ(raii::copy_constructor, x.size());
+      // don't check move construction count here because of rehashing
+      BOOST_TEST_GT(raii::move_constructor, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+    }
+  } lvalue_try_emplace_or_cvisit;
+
+  struct lvalue_try_emplace_or_visit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.try_emplace_or_visit(
+            r.first, r.second.x_,
+            [&num_invokes](typename X::value_type& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, x.size());
+      BOOST_TEST_EQ(raii::copy_constructor, x.size());
+      // don't check move construction count here because of rehashing
+      BOOST_TEST_GT(raii::move_constructor, 0u);
+      BOOST_TEST_EQ(raii::move_assignment, 0u);
+      BOOST_TEST_EQ(raii::copy_assignment, 0u);
+    }
+  } lvalue_try_emplace_or_visit;
+
+  struct rvalue_try_emplace_or_cvisit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.try_emplace_or_cvisit(
+            std::move(r.first), r.second.x_,
+            [&num_invokes](typename X::value_type const& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, x.size());
+
+      if (std::is_same<T, typename X::value_type>::value) {
+        BOOST_TEST_EQ(raii::copy_constructor, x.size());
+        BOOST_TEST_GE(raii::move_constructor, x.size());
+      } else {
+        BOOST_TEST_EQ(raii::copy_constructor, 0u);
+        BOOST_TEST_GE(raii::move_constructor, x.size());
+      }
+    }
+  } rvalue_try_emplace_or_cvisit;
+
+  struct rvalue_try_emplace_or_visit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.try_emplace_or_visit(
+            std::move(r.first), r.second.x_,
+            [&num_invokes](typename X::value_type& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, x.size());
+      if (std::is_same<T, typename X::value_type>::value) {
+        BOOST_TEST_EQ(raii::copy_constructor, x.size());
+        BOOST_TEST_GE(raii::move_constructor, x.size());
+      } else {
+        BOOST_TEST_EQ(raii::copy_constructor, 0u);
+        BOOST_TEST_GE(raii::move_constructor, x.size());
+      }
+    }
+  } rvalue_try_emplace_or_visit;
+
+  struct transp_try_emplace_or_cvisit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.try_emplace_or_cvisit(
+            r.first.x_, r.second.x_,
+            [&num_invokes](typename X::value_type const& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+      BOOST_TEST_EQ(raii::default_constructor, 2 * x.size());
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+    }
+  } transp_try_emplace_or_cvisit;
+
+  struct transp_try_emplace_or_visit_type
+  {
+    template <class T, class X> void operator()(std::vector<T>& values, X& x)
+    {
+      std::atomic<std::uint64_t> num_inserts{0};
+      std::atomic<std::uint64_t> num_invokes{0};
+      thread_runner(values, [&x, &num_inserts, &num_invokes](boost::span<T> s) {
+        for (auto& r : s) {
+          bool b = x.try_emplace_or_visit(
+            r.first.x_, r.second.x_,
+            [&num_invokes](typename X::value_type& v) {
+              (void)v;
+              ++num_invokes;
+            });
+
+          if (b) {
+            ++num_inserts;
+          }
+        }
+      });
+
+      BOOST_TEST_EQ(num_inserts, x.size());
+      BOOST_TEST_EQ(num_invokes, values.size() - x.size());
+
+      BOOST_TEST_EQ(raii::default_constructor, 2 * x.size());
+      BOOST_TEST_EQ(raii::copy_constructor, 0u);
+    }
+  } transp_try_emplace_or_visit;
+
+  template <class X, class G, class F>
+  void try_emplace(X*, G gen, F try_emplacer, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+    raii::reset_counts();
+
+    {
+      X x;
+
+      try_emplacer(values, x);
+
+      BOOST_TEST_EQ(x.size(), reference_map.size());
+
+      using value_type = typename X::value_type;
+      BOOST_TEST_EQ(x.size(), x.visit_all([&](value_type const& kv) {
+        BOOST_TEST(reference_map.contains(kv.first));
+        if (rg == test::sequential) {
+          BOOST_TEST_EQ(kv.second, reference_map[kv.first]);
+        }
+      }));
+    }
+
+    BOOST_TEST_GE(raii::default_constructor, 0u);
+    BOOST_TEST_GE(raii::copy_constructor, 0u);
+    BOOST_TEST_GE(raii::move_constructor, 0u);
+    BOOST_TEST_GT(raii::destructor, 0u);
+
+    BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                    raii::move_constructor,
+      raii::destructor);
+  }
+
+  boost::unordered::concurrent_flat_map<raii, raii>* map;
+  boost::unordered::concurrent_flat_map<raii, raii, transp_hash,
+    transp_key_equal>* transp_map;
+
+} // namespace
+
+using test::default_generator;
+using test::limited_range;
+using test::sequential;
+
+// clang-format off
+UNORDERED_TEST(
+  try_emplace,
+  ((map))
+  ((value_type_generator)(init_type_generator))
+  ((lvalue_try_emplacer)(norehash_lvalue_try_emplacer)
+   (rvalue_try_emplacer)(norehash_rvalue_try_emplacer)
+   (lvalue_try_emplace_or_cvisit)(lvalue_try_emplace_or_visit)
+   (rvalue_try_emplace_or_cvisit)(rvalue_try_emplace_or_visit))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  try_emplace,
+  ((transp_map))
+  ((init_type_generator))
+  ((transp_try_emplace)(norehash_transp_try_emplace)
+   (transp_try_emplace_or_cvisit)(transp_try_emplace_or_visit))
+  ((default_generator)(sequential)(limited_range)))
+// clang-format on
+
+RUN_TESTS()

test/cfoa/visit_tests.cpp

@@ -0,0 +1,461 @@
+// Copyright (C) 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "helpers.hpp"
+
+#include <boost/unordered/concurrent_flat_map.hpp>
+
+#include <boost/core/ignore_unused.hpp>
+
+#include <functional>
+#include <vector>
+
+namespace {
+  test::seed_t initialize_seed(335740237);
+
+  struct lvalue_visitor_type
+  {
+    template <class T, class X, class M>
+    void operator()(std::vector<T>& values, X& x, M const& reference_map)
+    {
+      using value_type = typename X::value_type;
+
+      std::atomic<std::uint64_t> num_visits{0};
+      std::atomic<std::uint64_t> total_count{0};
+
+      auto mut_visitor = [&num_visits, &reference_map](value_type& v) {
+        BOOST_TEST(reference_map.contains(v.first));
+        BOOST_TEST_EQ(v.second, reference_map.find(v.first)->second);
+        ++num_visits;
+      };
+
+      auto const_visitor = [&num_visits, &reference_map](value_type const& v) {
+        BOOST_TEST(reference_map.contains(v.first));
+        BOOST_TEST_EQ(v.second, reference_map.find(v.first)->second);
+        ++num_visits;
+      };
+
+      {
+        thread_runner(
+          values, [&x, &mut_visitor, &total_count](boost::span<T> s) {
+            for (auto const& val : s) {
+              auto r = val.first.x_;
+              BOOST_TEST(r >= 0);
+
+              auto count = x.visit(val.first, mut_visitor);
+              BOOST_TEST_EQ(count, 1u);
+              total_count += count;
+
+              count = x.visit(val.second, mut_visitor);
+              BOOST_TEST_EQ(count, 0u);
+            }
+          });
+
+        BOOST_TEST_EQ(num_visits, values.size());
+        BOOST_TEST_EQ(total_count, values.size());
+
+        num_visits = 0;
+        total_count = 0;
+      }
+
+      {
+        thread_runner(
+          values, [&x, &const_visitor, &total_count](boost::span<T> s) {
+            for (auto const& val : s) {
+              auto r = val.first.x_;
+              BOOST_TEST(r >= 0);
+
+              auto const& y = x;
+              auto count = y.visit(val.first, const_visitor);
+
+              BOOST_TEST_EQ(count, 1u);
+              total_count += count;
+
+              count = y.visit(val.second, const_visitor);
+              BOOST_TEST_EQ(count, 0u);
+            }
+          });
+
+        BOOST_TEST_EQ(num_visits, values.size());
+        BOOST_TEST_EQ(total_count, values.size());
+
+        num_visits = 0;
+        total_count = 0;
+      }
+
+      {
+        thread_runner(
+          values, [&x, &const_visitor, &total_count](boost::span<T> s) {
+            for (auto const& val : s) {
+              auto r = val.first.x_;
+              BOOST_TEST(r >= 0);
+
+              auto count = x.cvisit(val.first, const_visitor);
+
+              BOOST_TEST_EQ(count, 1u);
+              total_count += count;
+
+              count = x.cvisit(val.second, const_visitor);
+              BOOST_TEST_EQ(count, 0u);
+            }
+          });
+
+        BOOST_TEST_EQ(num_visits, values.size());
+        BOOST_TEST_EQ(total_count, values.size());
+
+        num_visits = 0;
+        total_count = 0;
+      }
+    }
+  } lvalue_visitor;
+
+  struct transp_visitor_type
+  {
+    template <class T, class X, class M>
+    void operator()(std::vector<T>& values, X& x, M const& reference_map)
+    {
+      using value_type = typename X::value_type;
+
+      std::atomic<std::uint64_t> num_visits{0};
+      std::atomic<std::uint64_t> total_count{0};
+
+      auto mut_visitor = [&num_visits, &reference_map](value_type& v) {
+        BOOST_TEST(reference_map.contains(v.first));
+        BOOST_TEST_EQ(v.second, reference_map.find(v.first)->second);
+        ++num_visits;
+      };
+
+      auto const_visitor = [&num_visits, &reference_map](value_type const& v) {
+        BOOST_TEST(reference_map.contains(v.first));
+        BOOST_TEST_EQ(v.second, reference_map.find(v.first)->second);
+        ++num_visits;
+      };
+
+      {
+        thread_runner(
+          values, [&x, &mut_visitor, &total_count](boost::span<T> s) {
+            for (auto const& val : s) {
+              auto r = val.first.x_;
+              BOOST_TEST(r >= 0);
+
+              auto count = x.visit(val.first.x_, mut_visitor);
+
+              BOOST_TEST_EQ(count, 1u);
+              total_count += count;
+
+              count = x.visit(val.second.x_, mut_visitor);
+              BOOST_TEST_EQ(count, 0u);
+            }
+          });
+
+        BOOST_TEST_EQ(num_visits, values.size());
+        BOOST_TEST_EQ(total_count, values.size());
+
+        num_visits = 0;
+        total_count = 0;
+      }
+
+      {
+        thread_runner(
+          values, [&x, &const_visitor, &total_count](boost::span<T> s) {
+            for (auto const& val : s) {
+              auto r = val.first.x_;
+              BOOST_TEST(r >= 0);
+
+              auto const& y = x;
+              auto count = y.visit(val.first.x_, const_visitor);
+
+              BOOST_TEST_EQ(count, 1u);
+              total_count += count;
+
+              count = y.visit(val.second.x_, const_visitor);
+              BOOST_TEST_EQ(count, 0u);
+            }
+          });
+
+        BOOST_TEST_EQ(num_visits, values.size());
+        BOOST_TEST_EQ(total_count, values.size());
+
+        num_visits = 0;
+        total_count = 0;
+      }
+
+      {
+        thread_runner(
+          values, [&x, &const_visitor, &total_count](boost::span<T> s) {
+            for (auto const& val : s) {
+              auto r = val.first.x_;
+              BOOST_TEST(r >= 0);
+
+              auto count = x.cvisit(val.first.x_, const_visitor);
+
+              BOOST_TEST_EQ(count, 1u);
+              total_count += count;
+
+              count = x.cvisit(val.second.x_, const_visitor);
+              BOOST_TEST_EQ(count, 0u);
+            }
+          });
+
+        BOOST_TEST_EQ(num_visits, values.size());
+        BOOST_TEST_EQ(total_count, values.size());
+
+        num_visits = 0;
+        total_count = 0;
+      }
+    }
+  } transp_visitor;
+
+  struct visit_all_type
+  {
+    template <class T, class X, class M>
+    void operator()(std::vector<T>& values, X& x, M const& reference_map)
+    {
+      using value_type = typename X::value_type;
+
+      std::atomic<std::uint64_t> total_count{0};
+
+      auto mut_visitor = [&reference_map](std::atomic<uint64_t>& num_visits) {
+        return [&reference_map, &num_visits](value_type& kv) {
+          BOOST_TEST(reference_map.contains(kv.first));
+          BOOST_TEST_EQ(kv.second, reference_map.find(kv.first)->second);
+          ++num_visits;
+        };
+      };
+
+      auto const_visitor = [&reference_map](std::atomic<uint64_t>& num_visits) {
+        return [&reference_map, &num_visits](value_type const& kv) {
+          BOOST_TEST(reference_map.contains(kv.first));
+          BOOST_TEST_EQ(kv.second, reference_map.find(kv.first)->second);
+          ++num_visits;
+        };
+      };
+
+      {
+        thread_runner(values, [&x, &total_count, &mut_visitor](boost::span<T>) {
+          std::atomic<std::uint64_t> num_visits{0};
+          total_count += x.visit_all(mut_visitor(num_visits));
+          BOOST_TEST_EQ(x.size(), num_visits);
+        });
+
+        BOOST_TEST_EQ(total_count, num_threads * x.size());
+        total_count = 0;
+      }
+
+      {
+        thread_runner(
+          values, [&x, &total_count, &const_visitor](boost::span<T>) {
+            std::atomic<std::uint64_t> num_visits{0};
+            auto const& y = x;
+            total_count += y.visit_all(const_visitor(num_visits));
+            BOOST_TEST_EQ(x.size(), num_visits);
+          });
+
+        BOOST_TEST_EQ(total_count, num_threads * x.size());
+        total_count = 0;
+      }
+
+      {
+        thread_runner(
+          values, [&x, &total_count, &const_visitor](boost::span<T>) {
+            std::atomic<std::uint64_t> num_visits{0};
+            total_count += x.cvisit_all(const_visitor(num_visits));
+            BOOST_TEST_EQ(x.size(), num_visits);
+          });
+
+        BOOST_TEST_EQ(total_count, num_threads * x.size());
+        total_count = 0;
+      }
+    }
+
+  } visit_all;
+
+  struct exec_policy_visit_all_type
+  {
+    template <class T, class X, class M>
+    void operator()(std::vector<T>& values, X& x, M const& reference_map)
+    {
+#if defined(BOOST_UNORDERED_PARALLEL_ALGORITHMS)
+      using value_type = typename X::value_type;
+
+      auto mut_visitor = [&reference_map](std::atomic<uint64_t>& num_visits) {
+        return [&reference_map, &num_visits](value_type& kv) {
+          BOOST_TEST(reference_map.contains(kv.first));
+          BOOST_TEST_EQ(kv.second, reference_map.find(kv.first)->second);
+          ++num_visits;
+        };
+      };
+
+      auto const_visitor = [&reference_map](std::atomic<uint64_t>& num_visits) {
+        return [&reference_map, &num_visits](value_type const& kv) {
+          BOOST_TEST(reference_map.contains(kv.first));
+          BOOST_TEST_EQ(kv.second, reference_map.find(kv.first)->second);
+          ++num_visits;
+        };
+      };
+
+      {
+        thread_runner(values, [&x, &mut_visitor](boost::span<T>) {
+          std::atomic<std::uint64_t> num_visits{0};
+
+          x.visit_all(std::execution::par_unseq, mut_visitor(num_visits));
+          BOOST_TEST_EQ(x.size(), num_visits);
+        });
+      }
+
+      {
+        thread_runner(values, [&x, &const_visitor](boost::span<T>) {
+          std::atomic<std::uint64_t> num_visits{0};
+          auto const& y = x;
+
+          y.visit_all(std::execution::par_unseq, const_visitor(num_visits));
+          BOOST_TEST_EQ(x.size(), num_visits);
+        });
+      }
+
+      {
+        thread_runner(values, [&x, &const_visitor](boost::span<T>) {
+          std::atomic<std::uint64_t> num_visits{0};
+          x.cvisit_all(std::execution::par_unseq, const_visitor(num_visits));
+          BOOST_TEST_EQ(x.size(), num_visits);
+        });
+      }
+#else
+      (void)values;
+      (void)x;
+      (void)reference_map;
+#endif
+    }
+  } exec_policy_visit_all;
+
+  template <class X, class G, class F>
+  void visit(X*, G gen, F visitor, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    for (auto& val : values) {
+      if (val.second.x_ == 0) {
+        val.second.x_ = 1;
+      }
+      val.second.x_ *= -1;
+    }
+
+    auto reference_map =
+      boost::unordered_flat_map<raii, raii>(values.begin(), values.end());
+    raii::reset_counts();
+
+    {
+      X x;
+      for (auto const& v : values) {
+        x.insert(v);
+      }
+      BOOST_TEST_EQ(x.size(), reference_map.size());
+
+      std::uint64_t old_default_constructor = raii::default_constructor;
+      std::uint64_t old_copy_constructor = raii::copy_constructor;
+      std::uint64_t old_move_constructor = raii::move_constructor;
+      std::uint64_t old_copy_assignment = raii::copy_assignment;
+      std::uint64_t old_move_assignment = raii::move_assignment;
+
+      visitor(values, x, reference_map);
+
+      BOOST_TEST_EQ(old_default_constructor, raii::default_constructor);
+      BOOST_TEST_EQ(old_copy_constructor, raii::copy_constructor);
+      BOOST_TEST_EQ(old_move_constructor, raii::move_constructor);
+      BOOST_TEST_EQ(old_copy_assignment, raii::copy_assignment);
+      BOOST_TEST_EQ(old_move_assignment, raii::move_assignment);
+    }
+
+    BOOST_TEST_GE(raii::default_constructor, 0u);
+    BOOST_TEST_GE(raii::copy_constructor, 0u);
+    BOOST_TEST_GE(raii::move_constructor, 0u);
+    BOOST_TEST_GT(raii::destructor, 0u);
+
+    BOOST_TEST_EQ(raii::default_constructor + raii::copy_constructor +
+                    raii::move_constructor,
+      raii::destructor);
+  }
+
+  template <class X, class G>
+  void empty_visit(X*, G gen, test::random_generator rg)
+  {
+    auto values = make_random_values(1024 * 16, [&] { return gen(rg); });
+    using values_type = decltype(values);
+    using span_value_type = typename values_type::value_type;
+
+    raii::reset_counts();
+
+    {
+      X x;
+
+      std::uint64_t old_default_constructor = raii::default_constructor;
+      std::uint64_t old_copy_constructor = raii::copy_constructor;
+      std::uint64_t old_move_constructor = raii::move_constructor;
+      std::uint64_t old_copy_assignment = raii::copy_assignment;
+      std::uint64_t old_move_assignment = raii::move_assignment;
+
+      {
+        thread_runner(values, [&x](boost::span<span_value_type> s) {
+          std::atomic<std::uint64_t> num_visits{0};
+
+          x.visit_all(
+            [&num_visits](typename X::value_type const&) { ++num_visits; });
+          BOOST_TEST_EQ(num_visits, 0u);
+
+          for (auto const& val : s) {
+            auto count = x.visit(val.first,
+              [&num_visits](typename X::value_type const&) { ++num_visits; });
+            BOOST_TEST_EQ(count, 0u);
+          }
+        });
+      }
+
+      BOOST_TEST_EQ(old_default_constructor, raii::default_constructor);
+      BOOST_TEST_EQ(old_copy_constructor, raii::copy_constructor);
+      BOOST_TEST_EQ(old_move_constructor, raii::move_constructor);
+      BOOST_TEST_EQ(old_copy_assignment, raii::copy_assignment);
+      BOOST_TEST_EQ(old_move_assignment, raii::move_assignment);
+    }
+
+    BOOST_TEST_EQ(raii::default_constructor, 0u);
+    BOOST_TEST_EQ(raii::copy_constructor, 0u);
+    BOOST_TEST_EQ(raii::move_constructor, 0u);
+    BOOST_TEST_EQ(raii::destructor, 0u);
+  }
+
+  boost::unordered::concurrent_flat_map<raii, raii>* map;
+  boost::unordered::concurrent_flat_map<raii, raii, transp_hash,
+    transp_key_equal>* transp_map;
+
+} // namespace
+
+using test::default_generator;
+using test::limited_range;
+using test::sequential;
+
+// clang-format off
+
+UNORDERED_TEST(
+  visit,
+  ((map))
+  ((value_type_generator)(init_type_generator))
+  ((lvalue_visitor)(visit_all)(exec_policy_visit_all))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  visit,
+  ((transp_map))
+  ((value_type_generator)(init_type_generator))
+  ((transp_visitor))
+  ((default_generator)(sequential)(limited_range)))
+
+UNORDERED_TEST(
+  empty_visit,
+  ((map)(transp_map))
+  ((value_type_generator)(init_type_generator))
+  ((default_generator)(sequential)(limited_range))
+)
+
+// clang-format on
+
+RUN_TESTS()

test/cmake_subdir_test/CMakeLists.txt

@@ -22,6 +22,7 @@ move
 mp11
 predef
 preprocessor
+static_assert
 throw_exception
 tuple
 type_traits
@@ -29,8 +30,6 @@ type_traits
 # Secondary dependencies
 
 describe
-static_assert
-winapi
 )
 
 foreach(dep IN LISTS deps)

test/exception/assign_exception_tests.cpp

@@ -60,6 +60,9 @@ template <class T> struct assign_base : public test::exception_base
   test::random_values<T> x_values, y_values;
   T x, y;
 
+  int t1;
+  int t2;
+
   typedef typename T::hasher hasher;
   typedef typename T::key_equal key_equal;
   typedef typename T::allocator_type allocator_type;
@@ -67,7 +70,10 @@ template <class T> struct assign_base : public test::exception_base
   assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
       : x_values(), y_values(),
         x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
-        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
+        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2)),
+        t1(tag1),
+        t2(tag2)
+
   {
     x.max_load_factor(mlf1);
     y.max_load_factor(mlf2);
@@ -89,6 +95,22 @@ template <class T> struct assign_base : public test::exception_base
   {
     test::check_equivalent_keys(x1);
 
+    if (x1.hash_function() == hasher(t1)) {
+      BOOST_TEST(x1.key_eq() == key_equal(t1));
+    }
+
+    if (x1.hash_function() == hasher(t2)) {
+      BOOST_TEST(x1.key_eq() == key_equal(t2));
+    }
+
+    if (x1.key_eq() == key_equal(t1)) {
+      BOOST_TEST(x1.hash_function() == hasher(t1));
+    }
+
+    if (x1.key_eq() == key_equal(t2)) {
+      BOOST_TEST(x1.hash_function() == hasher(t2));
+    }
+
     // If the container is empty at the point of the exception, the
     // internal structure is hidden, this exposes it, at the cost of
     // messing up the data.

test/exception/containers.hpp

@@ -25,8 +25,24 @@ typedef boost::unordered_flat_set<
   test::exception::allocator<test::exception::object> >
   test_pair_set;
 
-#define CONTAINER_SEQ (test_set)(test_map)
-#define CONTAINER_PAIR_SEQ (test_pair_set)(test_map)
+typedef boost::unordered_node_set<test::exception::object,
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >
+  test_node_set;
+
+typedef boost::unordered_node_map<test::exception::object,
+  test::exception::object, test::exception::hash, test::exception::equal_to,
+  test::exception::allocator2<test::exception::object> >
+  test_node_map;
+
+typedef boost::unordered_node_set<
+  std::pair<test::exception::object, test::exception::object>,
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >
+  test_pair_node_set;
+
+#define CONTAINER_SEQ (test_set)(test_map)(test_node_set)(test_node_map)
+#define CONTAINER_PAIR_SEQ (test_pair_set)(test_map)(test_pair_node_set)(test_node_map)
 #else
 typedef boost::unordered_set<test::exception::object, test::exception::hash,
   test::exception::equal_to,

test/exception/insert_exception_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 #include "./containers.hpp"
@@ -229,10 +229,12 @@ using test::generate_collisions;
 #ifdef BOOST_UNORDERED_FOA_TESTS
 test_set* test_set_;
 test_map* test_map_;
+test_node_set* test_node_set_;
+test_node_map* test_node_map_;
 
 // clang-format off
 UNORDERED_TEST(insert_exception_test,
-    ((test_set_)(test_map_))
+    ((test_set_)(test_map_)(test_node_set_)(test_node_map_))
     ((insert_lvalue)(insert_lvalue_begin)(insert_lvalue_end)
      (insert_lvalue_pos)(insert_single_item_range)
      (emplace_lvalue)(emplace_lvalue_begin)(emplace_lvalue_end)
@@ -242,7 +244,7 @@ UNORDERED_TEST(insert_exception_test,
 )
 
 UNORDERED_TEST(insert_rehash_exception_test,
-    ((test_set_)(test_map_))
+    ((test_set_)(test_map_)(test_node_set_)(test_node_map_))
     ((insert_lvalue)(insert_lvalue_begin)(insert_lvalue_end)
      (insert_lvalue_pos)(insert_single_item_range)
      (emplace_lvalue)(emplace_lvalue_begin)(emplace_lvalue_end)
@@ -314,15 +316,16 @@ struct pair_emplace2_type : inserter_base
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
 test_pair_set* test_pair_set_;
+test_pair_node_set* test_pair_node_set_;
 
 // clang-format off
 UNORDERED_TEST(insert_exception_test,
-    ((test_pair_set_)(test_map_))
+    ((test_pair_set_)(test_map_)(test_pair_node_set_)(test_node_map_))
     ((pair_emplace)(pair_emplace2))
     ((default_generator)(limited_range)(generate_collisions))
 )
 UNORDERED_TEST(insert_rehash_exception_test,
-    ((test_pair_set_)(test_map_))
+    ((test_pair_set_)(test_map_)(test_pair_node_set_)(test_node_map_))
     ((pair_emplace)(pair_emplace2))
     ((default_generator)(limited_range)(generate_collisions))
 )
@@ -399,6 +402,20 @@ struct map_insert_or_assign_type : map_inserter_base
   }
 } map_insert_or_assign;
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+// clang-format off
+UNORDERED_TEST(insert_exception_test,
+    ((test_map_)(test_node_map_))
+    ((try_emplace)(try_emplace2)(map_insert_operator)(map_insert_or_assign))
+    ((default_generator)(limited_range)(generate_collisions))
+)
+UNORDERED_TEST(insert_rehash_exception_test,
+    ((test_map_)(test_node_map_))
+    ((try_emplace)(try_emplace2)(map_insert_operator)(map_insert_or_assign))
+    ((default_generator)(limited_range)(generate_collisions))
+)
+// clang-format on
+#else
 // clang-format off
 UNORDERED_TEST(insert_exception_test,
     ((test_map_))
@@ -411,6 +428,7 @@ UNORDERED_TEST(insert_rehash_exception_test,
     ((default_generator)(limited_range)(generate_collisions))
 )
 // clang-format on
+#endif
 
 // Range insert tests
 
@@ -459,12 +477,12 @@ void insert_range_rehash_exception_test(T*, test::random_generator gen)
 #ifdef BOOST_UNORDERED_FOA_TESTS
 // clang-format off
 UNORDERED_TEST(insert_range_exception_test,
-    ((test_set_)(test_map_))
+    ((test_set_)(test_map_)(test_node_set_)(test_node_map_))
     ((default_generator)(limited_range)(generate_collisions))
 )
 
 UNORDERED_TEST(insert_range_rehash_exception_test,
-    ((test_set_)(test_map_))
+    ((test_set_)(test_map_)(test_node_set_)(test_node_map_))
     ((default_generator)(limited_range)(generate_collisions))
 )
 // clang-format on

test/exception/less_tests.cpp

@@ -0,0 +1,50 @@
+
+// Copyright 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "./containers.hpp"
+
+#include "../helpers/helpers.hpp"
+#include "../helpers/invariants.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/strong.hpp"
+#include "../helpers/tracker.hpp"
+
+#include <vector>
+
+UNORDERED_AUTO_TEST (less_osx_regression) {
+  DISABLE_EXCEPTIONS;
+  typedef test_pair_set::value_type value_type;
+  typedef test::exception::object object;
+
+  std::vector<value_type> v;
+  v.push_back(value_type(object(12, 98), object(88, 13)));
+  v.push_back(value_type(object(24, 71), object(62, 84)));
+  v.push_back(value_type(object(30, 0), object(5, 73)));
+  v.push_back(value_type(object(34, 64), object(79, 58)));
+  v.push_back(value_type(object(36, 95), object(64, 23)));
+  v.push_back(value_type(object(42, 89), object(68, 44)));
+  v.push_back(value_type(object(42, 26), object(93, 64)));
+  v.push_back(value_type(object(86, 86), object(16, 62)));
+  v.push_back(value_type(object(86, 86), object(75, 23)));
+  v.push_back(value_type(object(92, 37), object(41, 90)));
+
+  BOOST_TEST_EQ(v.size(), 10u);
+
+  std::set<value_type, test::exception::less> s;
+  s.insert(v.begin(), v.end());
+  BOOST_TEST_EQ(s.size(), v.size());
+
+  test::ordered<test_pair_set> tracker;
+  test_pair_set x;
+  for (std::vector<value_type>::iterator it = v.begin(); it != v.end();
+       ++it) {
+    x.insert(*it);
+  }
+
+  tracker.insert(v.begin(), v.end());
+  tracker.compare(x);
+}
+
+RUN_TESTS()

test/exception/merge_exception_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2017-2018 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -64,6 +64,12 @@ boost::unordered_flat_set<test::exception::object, test::exception::hash,
 boost::unordered_flat_map<test::exception::object, test::exception::object,
   test::exception::hash, test::exception::equal_to,
   test::exception::allocator2<test::exception::object> >* test_map_;
+boost::unordered_node_set<test::exception::object, test::exception::hash,
+  test::exception::equal_to,
+  test::exception::allocator<test::exception::object> >* test_node_set_;
+boost::unordered_node_map<test::exception::object, test::exception::object,
+  test::exception::hash, test::exception::equal_to,
+  test::exception::allocator2<test::exception::object> >* test_node_map_;
 
 // clang-format off
 UNORDERED_MULTI_TEST(set_merge, merge_exception_test,
@@ -99,6 +105,40 @@ UNORDERED_MULTI_TEST(map_merge_collisions, merge_exception_test,
     ((generate_collisions))
     ((generate_collisions))
 )
+UNORDERED_MULTI_TEST(node_set_merge, merge_exception_test,
+    ((test_node_set_))
+    ((test_node_set_))
+    (/* (0x0000)(0x6400) */(0x0064)/* (0x0a64)(0x3232) */)
+    ((0x0000)(0x0001)(0x0102))
+    ((default_generator)(limited_range))
+    ((default_generator)(limited_range))
+)
+UNORDERED_MULTI_TEST(node_map_merge, merge_exception_test,
+    ((test_node_map_))
+    ((test_node_map_))
+    ((0x0000)(0x6400)(0x0064)(0x0a64)(0x3232))
+    ((0x0101)(0x0200)(0x0201))
+    ((default_generator)(limited_range))
+    ((default_generator)(limited_range))
+)
+// Run fewer generate_collisions tests, as they're slow.
+UNORDERED_MULTI_TEST(node_set_merge_collisions, merge_exception_test,
+    ((test_node_set_))
+    ((test_node_set_))
+    ((0x0a0a))
+    ((0x0202)(0x0100)(0x0201))
+    ((generate_collisions))
+    ((generate_collisions))
+)
+UNORDERED_MULTI_TEST(node_map_merge_collisions, merge_exception_test,
+    ((test_node_map_))
+    ((test_node_map_))
+    ((0x0a0a))
+    ((0x0000)(0x0002)(0x0102))
+    ((generate_collisions))
+    ((generate_collisions))
+)
+// clang-format on
 #else
 boost::unordered_set<test::exception::object, test::exception::hash,
   test::exception::equal_to,

test/exception/move_assign_exception_tests.cpp

@@ -20,6 +20,7 @@ template <class T> struct move_assign_base : public test::exception_base
 {
   test::random_values<T> x_values, y_values;
   T x, y;
+  int t1, t2;
 
   typedef typename T::hasher hasher;
   typedef typename T::key_equal key_equal;
@@ -28,7 +29,9 @@ template <class T> struct move_assign_base : public test::exception_base
   move_assign_base(int tag1, int tag2, float mlf1 = 1.0, float mlf2 = 1.0)
       : x_values(), y_values(),
         x(0, hasher(tag1), key_equal(tag1), allocator_type(tag1)),
-        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
+        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2)),
+        t1(tag1),
+        t2(tag2)
   {
     x.max_load_factor(mlf1);
     y.max_load_factor(mlf2);
@@ -52,6 +55,22 @@ template <class T> struct move_assign_base : public test::exception_base
   {
     test::check_equivalent_keys(x1);
 
+    if (x1.hash_function() == hasher(t1)) {
+      BOOST_TEST(x1.key_eq() == key_equal(t1));
+    }
+
+    if (x1.hash_function() == hasher(t2)) {
+      BOOST_TEST(x1.key_eq() == key_equal(t2));
+    }
+
+    if (x1.key_eq() == key_equal(t1)) {
+      BOOST_TEST(x1.hash_function() == hasher(t1));
+    }
+
+    if (x1.key_eq() == key_equal(t2)) {
+      BOOST_TEST(x1.hash_function() == hasher(t2));
+    }
+
     // If the container is empty at the point of the exception, the
     // internal structure is hidden, this exposes it, at the cost of
     // messing up the data.

test/exception/swap_exception_tests.cpp

@@ -4,15 +4,40 @@
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
-#include "./containers.hpp"
+#define BOOST_ENABLE_ASSERT_HANDLER
+#include <boost/assert.hpp>
 
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-#define BOOST_UNORDERED_FOA_WEAK_GUARANTEE_SWAP_EXCEPTIONS_TESTS
-#endif
+#include "./containers.hpp"
 
 #include "../helpers/invariants.hpp"
 #include "../helpers/random_values.hpp"
 #include "../helpers/tracker.hpp"
+#include "../objects/test.hpp"
+
+#include <sstream>
+
+namespace boost {
+  void assertion_failed(
+    char const* expr, char const* function, char const* file, long line)
+  {
+    std::stringstream ss;
+    ss << expr << "\nin " << function << " failed at : " << file << ", line "
+       << line;
+
+    throw std::runtime_error(ss.str());
+  }
+
+  void assertion_failed_msg(char const* expr, char const* msg,
+    char const* function, char const* file, long line)
+  {
+    std::stringstream ss;
+    ss << expr << "\nin " << function << " failed at : " << file << ", line "
+       << line << "\n"
+       << msg;
+
+    throw std::runtime_error(ss.str());
+  }
+} // namespace boost
 
 #if defined(BOOST_MSVC)
 #pragma warning(disable : 4512) // assignment operator could not be generated
@@ -39,15 +64,10 @@ template <class T> struct self_swap_base : public test::exception_base
 
   void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
   {
-    std::string scope(test::scope);
+    (void)x;
 
-    // TODO: In C++11 exceptions are only allowed in the swap function.
-    BOOST_TEST(scope == "hash::hash(hash)" ||
-               scope == "hash::operator=(hash)" ||
-               scope == "equal_to::equal_to(equal_to)" ||
-               scope == "equal_to::operator=(equal_to)");
-
-    test::check_equivalent_keys(x);
+    BOOST_ERROR("An exception leaked when it should not have. Allocator "
+                "equality assertion must precede all other ops");
   }
 };
 
@@ -140,11 +160,139 @@ template <class T> struct swap_test4 : swap_base<T>
   swap_test4() : swap_base<T>(10, 10, 1, 2) {}
 };
 
+template <class T> struct unequal_alloc_swap_base : public test::exception_base
+{
+  const test::random_values<T> x_values, y_values;
+  const T initial_x, initial_y;
+
+  typedef typename T::hasher hasher;
+  typedef typename T::key_equal key_equal;
+  typedef typename T::allocator_type allocator_type;
+
+  unequal_alloc_swap_base(unsigned int count1, unsigned int count2)
+      : x_values(count1, test::limited_range),
+        y_values(count2, test::limited_range),
+        initial_x(x_values.begin(), x_values.end(), 0, allocator_type(1337)),
+        initial_y(y_values.begin(), y_values.end(), 0, allocator_type(7331))
+  {
+  }
+
+  struct data_type
+  {
+    data_type(T const& x_, T const& y_) : x(x_), y(y_) {}
+
+    T x, y;
+  };
+
+  data_type init() const { return data_type(initial_x, initial_y); }
+
+  void run(data_type& d) const
+  {
+    bool assert_threw = false;
+
+    BOOST_TEST(d.x.get_allocator() != d.y.get_allocator());
+
+    try {
+      d.x.swap(d.y);
+    } catch (std::runtime_error&) {
+      assert_threw = true;
+    }
+
+    DISABLE_EXCEPTIONS;
+    BOOST_TEST(assert_threw);
+    test::check_container(d.x, this->x_values);
+    test::check_equivalent_keys(d.x);
+    test::check_container(d.y, this->y_values);
+    test::check_equivalent_keys(d.y);
+  }
+
+  void check BOOST_PREVENT_MACRO_SUBSTITUTION(data_type const& d) const
+  {
+    std::string scope(test::scope);
+
+    // TODO: In C++11 exceptions are only allowed in the swap function.
+    BOOST_TEST(scope == "hash::hash(hash)" ||
+               scope == "hash::operator=(hash)" ||
+               scope == "equal_to::equal_to(equal_to)" ||
+               scope == "equal_to::operator=(equal_to)");
+
+    test::check_equivalent_keys(d.x);
+    test::check_equivalent_keys(d.y);
+  }
+};
+
+template <class T> struct unequal_alloc_swap_test1 : unequal_alloc_swap_base<T>
+{
+  unequal_alloc_swap_test1() : unequal_alloc_swap_base<T>(0, 0) {}
+};
+
+template <class T> struct unequal_alloc_swap_test2 : unequal_alloc_swap_base<T>
+{
+  unequal_alloc_swap_test2() : unequal_alloc_swap_base<T>(0, 10) {}
+};
+
+template <class T> struct unequal_alloc_swap_test3 : unequal_alloc_swap_base<T>
+{
+  unequal_alloc_swap_test3() : unequal_alloc_swap_base<T>(10, 0) {}
+};
+
+template <class T> struct unequal_alloc_swap_test4 : unequal_alloc_swap_base<T>
+{
+  unequal_alloc_swap_test4() : unequal_alloc_swap_base<T>(10, 10) {}
+};
+
+#if defined(BOOST_UNORDERED_FOA_TESTS)
+
+using unordered_flat_set = boost::unordered_flat_set<int, boost::hash<int>,
+  std::equal_to<int>, test::allocator1<int> >;
+using unordered_flat_map = boost::unordered_flat_map<int, int, boost::hash<int>,
+  std::equal_to<int>, test::allocator1<std::pair<int const, int> > >;
+using unordered_node_set = boost::unordered_node_set<int, boost::hash<int>,
+  std::equal_to<int>, test::allocator1<int> >;
+using unordered_node_map = boost::unordered_node_map<int, int, boost::hash<int>,
+  std::equal_to<int>, test::allocator1<std::pair<int const, int> > >;
+
+#define SWAP_CONTAINER_SEQ \
+ (unordered_flat_set)(unordered_flat_map) \
+ (unordered_node_set)(unordered_node_map)
+
+#else
+
+typedef boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
+  test::allocator1<int> >
+  unordered_set;
+typedef boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+  test::allocator1<std::pair<int const, int> > >
+  unordered_map;
+typedef boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
+  test::allocator1<int> >
+  unordered_multiset;
+typedef boost::unordered_multimap<int, int, boost::hash<int>,
+  std::equal_to<int>, test::allocator1<std::pair<int const, int> > >
+  unordered_multimap;
+
+#define SWAP_CONTAINER_SEQ                                                     \
+  (unordered_set)(unordered_map)(unordered_multiset)(unordered_multimap)
+#endif
+
+// FOA containers deliberately choose to not offer the strong exception
+// guarantee so we can't reliably test what happens if swapping one of the data
+// members throws
+//
 // clang-format off
+#if !defined(BOOST_UNORDERED_FOA_TESTS)
 EXCEPTION_TESTS(
   (self_swap_test1)(self_swap_test2)
   (swap_test1)(swap_test2)(swap_test3)(swap_test4),
   CONTAINER_SEQ)
+#endif
+
+// want to prove that when assertions are defined as throwing operations that we
+// uphold invariants
+EXCEPTION_TESTS(
+  (unequal_alloc_swap_test1)(unequal_alloc_swap_test2)
+  (unequal_alloc_swap_test3)(unequal_alloc_swap_test4),
+  SWAP_CONTAINER_SEQ)
 // clang-format on
 
 RUN_TESTS()

test/helpers/invariants.hpp

@@ -54,20 +54,10 @@ namespace test {
       if (test::has_unique_keys<X>::value && count != 1)
         BOOST_ERROR("Non-unique key.");
 
-#if !defined(BOOST_UNORDERED_FOA_WEAK_GUARANTEE_SWAP_EXCEPTIONS_TESTS)
-      // we conditionally compile this check because our FOA implementation only
-      // exhibits the weak guarantee when swapping throws
-      //
-      // in this case, the hasher may be changed before the predicate and the
-      // arrays are swapped in which case, we can can find an element by
-      // iteration but unfortunately, it's in the wrong slot according to the
-      // new hash function so count(key) can wind up returning nothing when
-      // there really is something
       if (x1.count(key) != count) {
         BOOST_ERROR("Incorrect output of count.");
         std::cerr << x1.count(key) << "," << count << "\n";
       }
-#endif
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
       // Check that the keys are in the correct bucket and are

test/helpers/test.hpp

@@ -6,6 +6,7 @@
 #if !defined(BOOST_UNORDERED_TEST_TEST_HEADER)
 #define BOOST_UNORDERED_TEST_TEST_HEADER
 
+#include <boost/unordered/detail/fwd.hpp>
 #include <boost/core/lightweight_test.hpp>
 #include <boost/preprocessor/cat.hpp>
 #include <boost/preprocessor/stringize.hpp>