fourth attempt

.drone.jsonnet

@@ -6,7 +6,7 @@ local library = "unordered";
 
 local triggers =
 {
-    branch: [ "master", "develop", "feature/*", "bugfix/*", "fix/*", "pr/*" ]
+    branch: [ "master", "develop", "feature/*", "bugfix/*" ]
 };
 
 local ubsan = { UBSAN: '1', UBSAN_OPTIONS: 'print_stacktrace=1' };
@@ -359,7 +359,7 @@ 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", arch = "arm64",
+        xcode_version = "13.4.1", osx_version = "monterey",
     ),
 
     windows_pipeline(

.github/workflows/ci.yml

@@ -72,10 +72,9 @@ jobs:
               compiler: clang-14,  cxxstd: '17,20,2b',          os: ubuntu-22.04, ccache_key: "san2" }
 
           # OSX, clang
-          - { compiler: clang,     cxxstd: '03,11,14,17,2a',    os: macos-11, }
-          - { compiler: clang,     cxxstd: '03,11,14,17,2a',    os: macos-12, sanitize: yes }
+          - { compiler: clang,     cxxstd: '03,11,14,17,2a',    os: macos-11, sanitize: yes }
 
-    timeout-minutes: 180
+    timeout-minutes: 120
     runs-on: ${{matrix.os}}
     container: ${{matrix.container}}
     env: {B2_USE_CCACHE: 1}
@@ -218,13 +217,11 @@ jobs:
       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' }
+          - { toolset: msvc-14.0, cxxstd: '14,latest',       addrmd: '32,64', os: windows-2019 }
+          - { toolset: msvc-14.2, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2019 }
+          - { toolset: msvc-14.3, cxxstd: '14,17,20,latest', addrmd: '32,64', os: windows-2022 }
+          - { toolset: clang-win, cxxstd: '14,17,latest',    addrmd: '32,64', os: windows-2022 }
+          - { toolset: gcc,       cxxstd: '03,11,14,17,2a',  addrmd: '64',    os: windows-2019 }
 
     runs-on: ${{matrix.os}}
 
@@ -253,9 +250,6 @@ jobs:
           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

.gitignore

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

benchmark/.gitignore

@@ -1,3 +0,0 @@
-enwik8
-enwik9
-*.exe

benchmark/string.cpp

@@ -1,22 +1,25 @@
 // 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
 
 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#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/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
 #ifdef HAVE_ABSEIL
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
+#ifdef HAVE_TSL_HOPSCOTCH
+# include "tsl/hopscotch_map.h"
+#endif
+#ifdef HAVE_TSL_ROBIN
+# include "tsl/robin_map.h"
 #endif
 #include <unordered_map>
 #include <vector>
@@ -264,6 +267,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
     times.push_back( rec );
 }
 
+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator
 
 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -274,9 +295,6 @@ 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>>;
 
@@ -290,10 +308,23 @@ template<class K, class V> using absl_flat_hash_map =
 
 #endif
 
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH
 
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map =
+    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map =
+    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map =
+    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map =
+    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
 
 #endif
 
@@ -350,12 +381,17 @@ 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>>;
 
+template<class K, class V> using multi_index_map_fnv1a = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first>, fnv1a_hash >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 #ifdef HAVE_ABSEIL
 
 template<class K, class V> using absl_node_hash_map_fnv1a =
@@ -366,10 +402,23 @@ template<class K, class V> using absl_flat_hash_map_fnv1a =
 
 #endif
 
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH
 
-template<class K, class V> using ankerl_unordered_dense_map_fnv1a =
-    ankerl::unordered_dense::map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map_fnv1a =
+    tsl::hopscotch_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map_fnv1a =
+    tsl::hopscotch_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map_fnv1a =
+    tsl::robin_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map_fnv1a =
+    tsl::robin_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
 
 #endif
 
@@ -379,16 +428,12 @@ int main()
 {
     init_indices();
 
+#if 1
+
     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
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<multi_index_map>( "multi_index_map" );
 
 #ifdef HAVE_ABSEIL
 
@@ -397,29 +442,53 @@ int main()
 
 #endif
 
-    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_TSL_HOPSCOTCH
 
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map_fnv1a>( "ankerl::unordered_dense::map, FNV-1a" );
+    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
+    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
 
 #endif
 
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map>( "tsl::robin_map" );
+    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
+
+#endif
+
+#endif
+
+    test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
+    test<boost_unordered_map_fnv1a>( "boost::unordered_map, FNV-1a" );
+    test<boost_unordered_flat_map_fnv1a>( "boost::unordered_flat_map, FNV-1a" );
+    test<multi_index_map_fnv1a>( "multi_index_map, FNV-1a" );
+
 #ifdef HAVE_ABSEIL
 
     test<absl_node_hash_map_fnv1a>( "absl::node_hash_map, FNV-1a" );
     test<absl_flat_hash_map_fnv1a>( "absl::flat_hash_map, FNV-1a" );
 
+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map_fnv1a>( "tsl::hopscotch_map, FNV-1a" );
+    test<tsl_hopscotch_pg_map_fnv1a>( "tsl::hopscotch_pg_map, FNV-1a" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map_fnv1a>( "tsl::robin_map, FNV-1a" );
+    test<tsl_robin_pg_map_fnv1a>( "tsl::robin_pg_map, FNV-1a" );
+
 #endif
 
     std::cout << "---\n\n";
 
     for( auto const& x: times )
     {
-        std::cout << std::setw( 38 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 35 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
     }
 }
 

benchmark/string_view.cpp

@@ -1,22 +1,25 @@
 // 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
 
 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#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/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
 #ifdef HAVE_ABSEIL
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
+#ifdef HAVE_TSL_HOPSCOTCH
+# include "tsl/hopscotch_map.h"
+#endif
+#ifdef HAVE_TSL_ROBIN
+# include "tsl/robin_map.h"
 #endif
 #include <unordered_map>
 #include <string_view>
@@ -265,6 +268,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
     times.push_back( rec );
 }
 
+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator
 
 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -275,9 +296,6 @@ 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>>;
 
@@ -291,10 +309,23 @@ template<class K, class V> using absl_flat_hash_map =
 
 #endif
 
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH
 
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map =
+    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map =
+    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map =
+    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map =
+    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
 
 #endif
 
@@ -351,12 +382,17 @@ 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>>;
 
+template<class K, class V> using multi_index_map_fnv1a = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first>, fnv1a_hash >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 #ifdef HAVE_ABSEIL
 
 template<class K, class V> using absl_node_hash_map_fnv1a =
@@ -367,10 +403,23 @@ template<class K, class V> using absl_flat_hash_map_fnv1a =
 
 #endif
 
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH
 
-template<class K, class V> using ankerl_unordered_dense_map_fnv1a =
-    ankerl::unordered_dense::map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map_fnv1a =
+    tsl::hopscotch_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map_fnv1a =
+    tsl::hopscotch_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map_fnv1a =
+    tsl::robin_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map_fnv1a =
+    tsl::robin_pg_map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
 
 #endif
 
@@ -380,16 +429,12 @@ int main()
 {
     init_indices();
 
+#if 1
+
     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
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<multi_index_map>( "multi_index_map" );
 
 #ifdef HAVE_ABSEIL
 
@@ -398,29 +443,53 @@ int main()
 
 #endif
 
-    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_TSL_HOPSCOTCH
 
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-    test<ankerl_unordered_dense_map_fnv1a>( "ankerl::unordered_dense::map, FNV-1a" );
+    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
+    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
 
 #endif
 
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map>( "tsl::robin_map" );
+    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
+
+#endif
+
+#endif
+
+    test<std_unordered_map_fnv1a>( "std::unordered_map, FNV-1a" );
+    test<boost_unordered_map_fnv1a>( "boost::unordered_map, FNV-1a" );
+    test<boost_unordered_flat_map_fnv1a>( "boost::unordered_flat_map, FNV-1a" );
+    test<multi_index_map_fnv1a>( "multi_index_map, FNV-1a" );
+
 #ifdef HAVE_ABSEIL
 
     test<absl_node_hash_map_fnv1a>( "absl::node_hash_map, FNV-1a" );
     test<absl_flat_hash_map_fnv1a>( "absl::flat_hash_map, FNV-1a" );
 
+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map_fnv1a>( "tsl::hopscotch_map, FNV-1a" );
+    test<tsl_hopscotch_pg_map_fnv1a>( "tsl::hopscotch_pg_map, FNV-1a" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map_fnv1a>( "tsl::robin_map, FNV-1a" );
+    test<tsl_robin_pg_map_fnv1a>( "tsl::robin_pg_map, FNV-1a" );
+
 #endif
 
     std::cout << "---\n\n";
 
     for( auto const& x: times )
     {
-        std::cout << std::setw( 38 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 35 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
     }
 }
 

benchmark/uint32.cpp

@@ -1,14 +1,14 @@
 // 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
 
 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#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/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
@@ -16,8 +16,11 @@
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
+#ifdef HAVE_TSL_HOPSCOTCH
+# include "tsl/hopscotch_map.h"
+#endif
+#ifdef HAVE_TSL_ROBIN
+# include "tsl/robin_map.h"
 #endif
 #include <unordered_map>
 #include <vector>
@@ -281,6 +284,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
     times.push_back( rec );
 }
 
+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator
 
 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -291,9 +312,6 @@ 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>>;
 
@@ -307,10 +325,23 @@ template<class K, class V> using absl_flat_hash_map =
 
 #endif
 
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH
 
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map =
+    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map =
+    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map =
+    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map =
+    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
 
 #endif
 
@@ -320,27 +351,35 @@ 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
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<multi_index_map>( "multi_index_map" );
 
 #ifdef HAVE_ABSEIL
 
     test<absl_node_hash_map>( "absl::node_hash_map" );
     test<absl_flat_hash_map>( "absl::flat_hash_map" );
 
+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
+    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map>( "tsl::robin_map" );
+    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
+
 #endif
 
     std::cout << "---\n\n";
 
     for( auto const& x: times )
     {
-        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 27 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
     }
 }
 

benchmark/uint64.cpp

@@ -1,14 +1,14 @@
 // 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
 
 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#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/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/config.hpp>
@@ -16,8 +16,11 @@
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
+#ifdef HAVE_TSL_HOPSCOTCH
+# include "tsl/hopscotch_map.h"
+#endif
+#ifdef HAVE_TSL_ROBIN
+# include "tsl/robin_map.h"
 #endif
 #include <unordered_map>
 #include <vector>
@@ -281,6 +284,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
     times.push_back( rec );
 }
 
+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator
 
 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -291,9 +312,6 @@ 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>>;
 
@@ -307,10 +325,23 @@ template<class K, class V> using absl_flat_hash_map =
 
 #endif
 
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
+#ifdef HAVE_TSL_HOPSCOTCH
 
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+template<class K, class V> using tsl_hopscotch_map =
+    tsl::hopscotch_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_hopscotch_pg_map =
+    tsl::hopscotch_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+template<class K, class V> using tsl_robin_map =
+    tsl::robin_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
+
+template<class K, class V> using tsl_robin_pg_map =
+    tsl::robin_pg_map<K, V, std::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
 
 #endif
 
@@ -318,39 +349,37 @@ int main()
 {
     init_indices();
 
-#if defined(BOOST_LIBSTDCXX_VERSION) && __SIZE_WIDTH__ == 32
-
-    // Pathological behavior:
-    // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=104945
-
-#else
-
     test<std_unordered_map>( "std::unordered_map" );
-
-#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
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<multi_index_map>( "multi_index_map" );
 
 #ifdef HAVE_ABSEIL
 
     test<absl_node_hash_map>( "absl::node_hash_map" );
     test<absl_flat_hash_map>( "absl::flat_hash_map" );
 
+#endif
+
+#ifdef HAVE_TSL_HOPSCOTCH
+
+    test<tsl_hopscotch_map>( "tsl::hopscotch_map" );
+    test<tsl_hopscotch_pg_map>( "tsl::hopscotch_pg_map" );
+
+#endif
+
+#ifdef HAVE_TSL_ROBIN
+
+    test<tsl_robin_map>( "tsl::robin_map" );
+    test<tsl_robin_pg_map>( "tsl::robin_pg_map" );
+
 #endif
 
     std::cout << "---\n\n";
 
     for( auto const& x: times )
     {
-        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 27 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
     }
 }
 

benchmark/uuid.cpp

@@ -1,14 +1,14 @@
 // 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
 
 #define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#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/multi_index_container.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
 #include <boost/endian/conversion.hpp>
 #include <boost/core/detail/splitmix64.hpp>
 #include <boost/container_hash/hash.hpp>
@@ -17,9 +17,6 @@
 # include "absl/container/node_hash_map.h"
 # include "absl/container/flat_hash_map.h"
 #endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
-#endif
 #include <unordered_map>
 #include <vector>
 #include <memory>
@@ -332,6 +329,24 @@ template<template<class...> class Map> BOOST_NOINLINE void test( char const* lab
     times.push_back( rec );
 }
 
+// multi_index emulation of unordered_map
+
+template<class K, class V> struct pair
+{
+    K first;
+    mutable V second;
+};
+
+using namespace boost::multi_index;
+
+template<class K, class V> using multi_index_map = multi_index_container<
+  pair<K, V>,
+  indexed_by<
+    hashed_unique< member<pair<K, V>, K, &pair<K, V>::first> >
+  >,
+  ::allocator< pair<K, V> >
+>;
+
 // aliases using the counting allocator
 
 template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
@@ -342,9 +357,6 @@ 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>>;
 
@@ -358,27 +370,14 @@ template<class K, class V> using absl_flat_hash_map =
 
 #endif
 
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
 int main()
 {
     init_indices();
 
     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
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
+    test<multi_index_map>( "multi_index_map" );
 
 #ifdef HAVE_ABSEIL
 
@@ -391,7 +390,7 @@ int main()
 
     for( auto const& x: times )
     {
-        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 27 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
     }
 }
 

benchmark/word_count.cpp

@@ -1,386 +0,0 @@
-// 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
-
-#define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#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
-# include "absl/container/node_hash_map.h"
-# include "absl/container/flat_hash_map.h"
-#endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
-#endif
-#include <unordered_map>
-#include <vector>
-#include <memory>
-#include <cstdint>
-#include <iostream>
-#include <iomanip>
-#include <chrono>
-#include <fstream>
-#include <string_view>
-#include <string>
-
-using namespace std::chrono_literals;
-
-static void print_time( std::chrono::steady_clock::time_point & t1, char const* label, std::size_t s, std::size_t size )
-{
-    auto t2 = std::chrono::steady_clock::now();
-
-    std::cout << label << ": " << ( t2 - t1 ) / 1ms << " ms (s=" << s << ", size=" << size << ")\n";
-
-    t1 = t2;
-}
-
-static std::vector<std::string> words;
-
-static void init_words()
-{
-#if SIZE_MAX > UINT32_MAX
-
-    char const* fn = "enwik9"; // http://mattmahoney.net/dc/textdata
-
-#else
-
-    char const* fn = "enwik8"; // ditto
-
-#endif
-
-    auto t1 = std::chrono::steady_clock::now();
-
-    std::ifstream is( fn );
-    std::string in( std::istreambuf_iterator<char>( is ), std::istreambuf_iterator<char>{} );
-
-    boost::regex re( "[a-zA-Z]+");
-    boost::sregex_token_iterator it( in.begin(), in.end(), re, 0 ), end;
-
-    words.assign( it, end );
-
-    auto t2 = std::chrono::steady_clock::now();
-
-    std::cout << fn << ": " << words.size() << " words, " << ( t2 - t1 ) / 1ms << " ms\n\n";
-}
-
-template<class Map> BOOST_NOINLINE void test_word_count( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t s = 0;
-
-    for( auto const& word: words )
-    {
-        ++map[ word ];
-        ++s;
-    }
-
-    print_time( t1, "Word count", s, map.size() );
-
-    std::cout << std::endl;
-}
-
-template<class Map> BOOST_NOINLINE void test_contains( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t s = 0;
-
-    for( auto const& word: words )
-    {
-        std::string_view w2( word );
-        w2.remove_prefix( 1 );
-
-        s += map.contains( w2 );
-    }
-
-    print_time( t1, "Contains", s, map.size() );
-
-    std::cout << std::endl;
-}
-
-template<class Map> BOOST_NOINLINE void test_count( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t s = 0;
-
-    for( auto const& word: words )
-    {
-        std::string_view w2( word );
-        w2.remove_prefix( 1 );
-
-        s += map.count( w2 );
-    }
-
-    print_time( t1, "Count", s, map.size() );
-
-    std::cout << std::endl;
-}
-
-template<class Map> BOOST_NOINLINE void test_iteration( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t max = 0;
-    std::string_view word;
-
-    for( auto const& x: map )
-    {
-        if( x.second > max )
-        {
-            word = x.first;
-            max = x.second;
-        }
-    }
-
-    print_time( t1, "Iterate and find max element",  max, map.size() );
-
-    std::cout << std::endl;
-}
-
-// counting allocator
-
-static std::size_t s_alloc_bytes = 0;
-static std::size_t s_alloc_count = 0;
-
-template<class T> struct allocator
-{
-    using value_type = T;
-
-    allocator() = default;
-
-    template<class U> allocator( allocator<U> const & ) noexcept
-    {
-    }
-
-    template<class U> bool operator==( allocator<U> const & ) const noexcept
-    {
-        return true;
-    }
-
-    template<class U> bool operator!=( allocator<U> const& ) const noexcept
-    {
-        return false;
-    }
-
-    T* allocate( std::size_t n ) const
-    {
-        s_alloc_bytes += n * sizeof(T);
-        s_alloc_count++;
-
-        return std::allocator<T>().allocate( n );
-    }
-
-    void deallocate( T* p, std::size_t n ) const noexcept
-    {
-        s_alloc_bytes -= n * sizeof(T);
-        s_alloc_count--;
-
-        std::allocator<T>().deallocate( p, n );
-    }
-};
-
-//
-
-struct record
-{
-    std::string label_;
-    long long time_;
-    std::size_t bytes_;
-    std::size_t count_;
-};
-
-static std::vector<record> times;
-
-template<template<class...> class Map> BOOST_NOINLINE void test( char const* label )
-{
-    std::cout << label << ":\n\n";
-
-    s_alloc_bytes = 0;
-    s_alloc_count = 0;
-
-    Map<std::string_view, std::size_t> map;
-
-    auto t0 = std::chrono::steady_clock::now();
-    auto t1 = t0;
-
-    test_word_count( map, t1 );
-
-    std::cout << "Memory: " << s_alloc_bytes << " bytes in " << s_alloc_count << " allocations\n\n";
-
-    record rec = { label, 0, s_alloc_bytes, s_alloc_count };
-
-    test_contains( map, t1 );
-    test_count( map, t1 );
-    test_iteration( map, t1 );
-
-    auto tN = std::chrono::steady_clock::now();
-    std::cout << "Total: " << ( tN - t0 ) / 1ms << " ms\n\n";
-
-    rec.time_ = ( tN - t0 ) / 1ms;
-    times.push_back( rec );
-}
-
-// aliases using the counting allocator
-
-template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
-
-template<class K, class V> using std_unordered_map =
-    std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
-
-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>>;
-
-#ifdef HAVE_ABSEIL
-
-template<class K, class V> using absl_node_hash_map =
-    absl::node_hash_map<K, V, absl::container_internal::hash_default_hash<K>, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-template<class K, class V> using absl_flat_hash_map =
-    absl::flat_hash_map<K, V, absl::container_internal::hash_default_hash<K>, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-#endif
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-// fnv1a_hash
-
-template<int Bits> struct fnv1a_hash_impl;
-
-template<> struct fnv1a_hash_impl<32>
-{
-    std::size_t operator()( std::string_view const& s ) const
-    {
-        std::size_t h = 0x811C9DC5u;
-
-        char const * first = s.data();
-        char const * last = first + s.size();
-
-        for( ; first != last; ++first )
-        {
-            h ^= static_cast<unsigned char>( *first );
-            h *= 0x01000193ul;
-        }
-
-        return h;
-    }
-};
-
-template<> struct fnv1a_hash_impl<64>
-{
-    std::size_t operator()( std::string_view const& s ) const
-    {
-        std::size_t h = 0xCBF29CE484222325ull;
-
-        char const * first = s.data();
-        char const * last = first + s.size();
-
-        for( ; first != last; ++first )
-        {
-            h ^= static_cast<unsigned char>( *first );
-            h *= 0x00000100000001B3ull;
-        }
-
-        return h;
-    }
-};
-
-struct fnv1a_hash: fnv1a_hash_impl< std::numeric_limits<std::size_t>::digits >
-{
-    using is_avalanching = void;
-};
-
-template<class K, class V> using std_unordered_map_fnv1a =
-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>>;
-
-#ifdef HAVE_ABSEIL
-
-template<class K, class V> using absl_node_hash_map_fnv1a =
-    absl::node_hash_map<K, V, fnv1a_hash, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-template<class K, class V> using absl_flat_hash_map_fnv1a =
-    absl::flat_hash_map<K, V, fnv1a_hash, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-#endif
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-template<class K, class V> using ankerl_unordered_dense_map_fnv1a =
-    ankerl::unordered_dense::map<K, V, fnv1a_hash, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-//
-
-int main()
-{
-    init_words();
-
-    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
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
-
-#ifdef HAVE_ABSEIL
-
-    test<absl_node_hash_map>( "absl::node_hash_map" );
-    test<absl_flat_hash_map>( "absl::flat_hash_map" );
-
-#endif
-
-    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
-
-    test<ankerl_unordered_dense_map_fnv1a>( "ankerl::unordered_dense::map, FNV-1a" );
-
-#endif
-
-#ifdef HAVE_ABSEIL
-
-    test<absl_node_hash_map_fnv1a>( "absl::node_hash_map, FNV-1a" );
-    test<absl_flat_hash_map_fnv1a>( "absl::flat_hash_map, FNV-1a" );
-
-#endif
-
-    std::cout << "---\n\n";
-
-    for( auto const& x: times )
-    {
-        std::cout << std::setw( 38 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
-    }
-}
-
-#ifdef HAVE_ABSEIL
-# include "absl/container/internal/raw_hash_set.cc"
-# include "absl/hash/internal/hash.cc"
-# include "absl/hash/internal/low_level_hash.cc"
-# include "absl/hash/internal/city.cc"
-#endif

benchmark/word_size.cpp

@@ -1,244 +0,0 @@
-// 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
-
-#define _SILENCE_CXX17_OLD_ALLOCATOR_MEMBERS_DEPRECATION_WARNING
-#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
-# include "absl/container/node_hash_map.h"
-# include "absl/container/flat_hash_map.h"
-#endif
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-# include "ankerl/unordered_dense.h"
-#endif
-#include <unordered_map>
-#include <vector>
-#include <memory>
-#include <cstdint>
-#include <iostream>
-#include <iomanip>
-#include <chrono>
-#include <fstream>
-
-using namespace std::chrono_literals;
-
-static void print_time( std::chrono::steady_clock::time_point & t1, char const* label, std::size_t s, std::size_t size )
-{
-    auto t2 = std::chrono::steady_clock::now();
-
-    std::cout << label << ": " << ( t2 - t1 ) / 1ms << " ms (s=" << s << ", size=" << size << ")\n";
-
-    t1 = t2;
-}
-
-static std::vector<std::string> words;
-
-static void init_words()
-{
-#if SIZE_MAX > UINT32_MAX
-
-    char const* fn = "enwik9"; // http://mattmahoney.net/dc/textdata
-
-#else
-
-    char const* fn = "enwik8"; // ditto
-
-#endif
-
-    auto t1 = std::chrono::steady_clock::now();
-
-    std::ifstream is( fn );
-    std::string in( std::istreambuf_iterator<char>( is ), std::istreambuf_iterator<char>{} );
-
-    boost::regex re( "[a-zA-Z]+");
-    boost::sregex_token_iterator it( in.begin(), in.end(), re, 0 ), end;
-
-    words.assign( it, end );
-
-    auto t2 = std::chrono::steady_clock::now();
-
-    std::cout << fn << ": " << words.size() << " words, " << ( t2 - t1 ) / 1ms << " ms\n\n";
-}
-
-template<class Map> BOOST_NOINLINE void test_word_size( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    for( auto const& word: words )
-    {
-        ++map[ word.size() ];
-    }
-
-    print_time( t1, "Word size count",  0, map.size() );
-
-    std::cout << std::endl;
-}
-
-template<class Map> BOOST_NOINLINE void test_iteration( Map& map, std::chrono::steady_clock::time_point & t1 )
-{
-    std::size_t s = 0;
-
-    for( auto const& x: map )
-    {
-        s += x.second;
-    }
-
-    print_time( t1, "Iterate and sum counts",  s, map.size() );
-
-    std::cout << std::endl;
-}
-
-// counting allocator
-
-static std::size_t s_alloc_bytes = 0;
-static std::size_t s_alloc_count = 0;
-
-template<class T> struct allocator
-{
-    using value_type = T;
-
-    allocator() = default;
-
-    template<class U> allocator( allocator<U> const & ) noexcept
-    {
-    }
-
-    template<class U> bool operator==( allocator<U> const & ) const noexcept
-    {
-        return true;
-    }
-
-    template<class U> bool operator!=( allocator<U> const& ) const noexcept
-    {
-        return false;
-    }
-
-    T* allocate( std::size_t n ) const
-    {
-        s_alloc_bytes += n * sizeof(T);
-        s_alloc_count++;
-
-        return std::allocator<T>().allocate( n );
-    }
-
-    void deallocate( T* p, std::size_t n ) const noexcept
-    {
-        s_alloc_bytes -= n * sizeof(T);
-        s_alloc_count--;
-
-        std::allocator<T>().deallocate( p, n );
-    }
-};
-
-//
-
-struct record
-{
-    std::string label_;
-    long long time_;
-    std::size_t bytes_;
-    std::size_t count_;
-};
-
-static std::vector<record> times;
-
-template<template<class...> class Map> BOOST_NOINLINE void test( char const* label )
-{
-    std::cout << label << ":\n\n";
-
-    s_alloc_bytes = 0;
-    s_alloc_count = 0;
-
-    Map<std::size_t, std::size_t> map;
-
-    auto t0 = std::chrono::steady_clock::now();
-    auto t1 = t0;
-
-    test_word_size( map, t1 );
-
-    std::cout << "Memory: " << s_alloc_bytes << " bytes in " << s_alloc_count << " allocations\n\n";
-
-    record rec = { label, 0, s_alloc_bytes, s_alloc_count };
-
-    test_iteration( map, t1 );
-
-    auto tN = std::chrono::steady_clock::now();
-    std::cout << "Total: " << ( tN - t0 ) / 1ms << " ms\n\n";
-
-    rec.time_ = ( tN - t0 ) / 1ms;
-    times.push_back( rec );
-}
-
-// aliases using the counting allocator
-
-template<class K, class V> using allocator_for = ::allocator< std::pair<K const, V> >;
-
-template<class K, class V> using std_unordered_map =
-    std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, allocator_for<K, V>>;
-
-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>>;
-
-#ifdef HAVE_ABSEIL
-
-template<class K, class V> using absl_node_hash_map =
-    absl::node_hash_map<K, V, absl::container_internal::hash_default_hash<K>, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-template<class K, class V> using absl_flat_hash_map =
-    absl::flat_hash_map<K, V, absl::container_internal::hash_default_hash<K>, absl::container_internal::hash_default_eq<K>, allocator_for<K, V>>;
-
-#endif
-
-#ifdef HAVE_ANKERL_UNORDERED_DENSE
-
-template<class K, class V> using ankerl_unordered_dense_map =
-    ankerl::unordered_dense::map<K, V, ankerl::unordered_dense::hash<K>, std::equal_to<K>, ::allocator< std::pair<K, V> >>;
-
-#endif
-
-int main()
-{
-    init_words();
-
-    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
-
-    test<ankerl_unordered_dense_map>( "ankerl::unordered_dense::map" );
-
-#endif
-
-#ifdef HAVE_ABSEIL
-
-    test<absl_node_hash_map>( "absl::node_hash_map" );
-    test<absl_flat_hash_map>( "absl::flat_hash_map" );
-
-#endif
-
-    std::cout << "---\n\n";
-
-    for( auto const& x: times )
-    {
-        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
-    }
-}
-
-#ifdef HAVE_ABSEIL
-# include "absl/container/internal/raw_hash_set.cc"
-# include "absl/hash/internal/hash.cc"
-# include "absl/hash/internal/low_level_hash.cc"
-# include "absl/hash/internal/city.cc"
-#endif

doc/unordered/benchmarks.adoc

@@ -278,14 +278,13 @@ max load factor 5
 
 |===
 
-== boost::unordered_(flat|node)_map
+== boost::unordered_flat_map
 
 All benchmarks were created using:
 
 * `https://abseil.io/docs/cpp/guides/container[absl::flat_hash_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>`
+* `boost::unordered_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,8 +134,7 @@ 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_node_set`, `boost::unordered_node_map` +
+`boost::unordered_flat_set`, `boost::unordered_flat_map` 
 h|*Method* h|*Description*
 
 |`size_type max_load() const`
@@ -161,9 +160,8 @@ 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 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
+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
 `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.
@@ -246,70 +244,4 @@ image::fca.png[align=center]
 
 Thus container-wide iteration is turned into traversing the non-empty bucket groups (an operation with constant time complexity) which reduces the time complexity back to `O(size())`. In total, a bucket group is only 4 words in size and it views `sizeof(std::size_t) * CHAR_BIT` buckets meaning that for all common implementations, there's only 4 bits of space overhead per bucket introduced by the bucket groups.
 
-A more detailed description of Boost.Unordered's closed-addressing implementation is
-given in an
-https://bannalia.blogspot.com/2022/06/advancing-state-of-art-for.html[external article].
-For more information on implementation rationale, read the
-xref:#rationale_boostunordered_multiset_and_boostunordered_multimap[corresponding section].
-
-== Open Addressing Implementation
-
-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 (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.
-
-[#img-foa-metadata]
-.Breakdown of a metadata word.
-image::foa-metadata.png[align=center]
-
-A metadata word is divided into 15 _h_~_i_~ bytes (one for each associated
-bucket), and an _overflow byte_ (_ofw_ in the diagram). The value of _h_~_i_~ is:
-
-  - 0 if the corresponding bucket is empty.
-  - 1 to encode a special empty bucket called a _sentinel_, which is used internally to
-  stop iteration when the container has been fully traversed.
-  - If the bucket is occupied, a _reduced hash value_ obtained from the hash value of
-  the element.
-
-When looking for an element with hash value _h_, SIMD technologies such as
-https://en.wikipedia.org/wiki/SSE2[SSE2] and
-https://en.wikipedia.org/wiki/ARM_architecture_family#Advanced_SIMD_(Neon)[Neon] allow us
-to very quickly inspect the full metadata word and look for the reduced value of _h_ among all the
-15 buckets with just a handful of CPU instructions: non-matching buckets can be
-readily discarded, and those whose reduced hash value matches need be inspected via full
-comparison with the corresponding element. If the looked-for element is not present,
-the overflow byte is inspected:
-
-- If the bit in the position _h_ mod 8 is zero, lookup terminates (and the
-element is not present).
-- If the bit is set to 1 (the group has been _overflowed_), further groups are
-checked using https://en.wikipedia.org/wiki/Quadratic_probing[_quadratic probing_], and
-the process is repeated.
-
-Insertion is algorithmically similar: empty buckets are located using SIMD,
-and when going past a full group its corresponding overflow bit is set to 1.
-
-In architectures without SIMD support, the logical layout stays the same, but the metadata
-word is codified using a technique we call _bit interleaving_: this layout allows us
-to emulate SIMD with reasonably good performance using only standard arithmetic and
-logical operations.
-
-[#img-foa-metadata-interleaving]
-.Bit-interleaved metadata word.
-image::foa-metadata-interleaving.png[align=center]
-
-A more detailed description of Boost.Unordered's open-addressing implementation is
-given in an
-https://bannalia.blogspot.com/2022/11/inside-boostunorderedflatmap.html[external article].
-For more information on implementation rationale, read the
-xref:#rationale_boostunordered_flat_set_and_boostunordered_flat_map[corresponding section].
+For more information on implementation rationale, read the <<Implementation Rationale, corresponding section>>.

doc/unordered/changes.adoc

@@ -6,30 +6,10 @@
 :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`
   based on open addressing.
-* Added CTAD deduction guides for all containers.
-* Added missing constructors as specified in https://cplusplus.github.io/LWG/issue2713[LWG issue 2713].
 
 == Release 1.80.0 - Major update
 

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>>. +
-**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.
+**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.
 
 |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
+== Closed-addressing containers: unordered_[multi]set, unordered_[multi]map
 
-`unordered_[multi]set` and `unordered_[multi]map` are intended to provide a conformant
+The intent of Boost.Unordered is 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,31 +117,27 @@ 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
+== Open-addressing containers: unordered_flat_set, unordered_flat_map
 
 The C++ standard does not currently provide any open-addressing container
-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
+specification to adhere to, so `boost::unordered_flat_set` and
+`boost::unordered_flat_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).
+radically different from that imposed by the standard (closed addressing, node based).
 
-Open-addressing containers provided by Boost.Unordered only work with reasonably
+`unordered_flat_set` and `unordered_flat_map` 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. 
-The containers are fully https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer[AllocatorAware^].
+`unordered_flat_set` and `unordered_flat_map` are fully https://en.cppreference.com/w/cpp/named_req/AllocatorAwareContainer[AllocatorAware^].
 
 The main differences with C++ unordered associative containers are:
 
-* 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.
+* `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.
 
-//-

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-2023 Christian Mazakas
+Copyright (C) 2022 Christian Mazakas
 
-Copyright (C) 2022-2023 Joaquín M López Muñoz
+Copyright (C) 2022 Joaquín M López Muñoz
 
-Copyright (C) 2022-2023 Peter Dimov
+Copyright (C) 2022 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,69 +106,8 @@ namespace boost {
 }
 ----
 
-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_flat_set` and `boost::unordered_flat_map` require a
+reasonably compliant C++11 compiler.
 
 Boost.Unordered containers are used in a similar manner to the normal associative
 containers:

doc/unordered/rationale.adoc

@@ -4,10 +4,9 @@
 
 = Implementation Rationale
 
-== Closed-addressing containers 
+== boost::unordered_[multi]set and boost::unordered_[multi]map
 
-`boost::unordered_[multi]set` and `boost::unordered_[multi]map`
-adhere to the standard requirements for unordered associative
+These containers 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.
@@ -65,8 +64,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 `2^w` divided
-by the golden ratio, `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 the golden
+ratio multiplied by `2^w`, `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.
 
@@ -74,7 +73,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.
 
-== Open-addresing containers 
+== boost::unordered_flat_set and boost::unordered_flat_map
 
 The C++ standard specification of unordered associative containers impose
 severe limitations on permissible implementations, the most important being
@@ -82,32 +81,29 @@ 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`/`unordered_node_set` and `boost::unordered_flat_map`/`unordered_node_map` has been
+The design of `boost::unordered_flat_set` and `boost::unordered_flat_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 open-addressing containers.
+`boost::hash` remains the default hash function of `boost::unordered_flat_set` and `boost::unordered_flat_map`.
 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:
 
-{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)^].
+*  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.
 
 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`/`unordered_node_set` and `boost::unordered_flat_map`/`unordered_node_map` is deterministically
+The observable behavior of `boost::unordered_flat_set` and `boost::unordered_flat_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,5 +8,3 @@ 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,8 +98,9 @@ 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::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+               boost::is_nothrow_move_assignable_v<Hash> &&
+               boost::is_nothrow_move_assignable_v<Pred>);
     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;
 
@@ -134,35 +135,28 @@ 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_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_flat_map_transparent_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::allocator_traits<Allocator>::propagate_on_container_swap::value);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+               boost::is_nothrow_swappable_v<Hash> &&
+               boost::is_nothrow_swappable_v<Pred>);
     void      xref:#unordered_flat_map_clear[clear]() noexcept;
 
     template<class H2, class P2>
@@ -197,11 +191,8 @@ 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;
@@ -615,10 +606,11 @@ 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::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+           boost::is_nothrow_move_assignable_v<Hash> &&
+           boost::is_nothrow_move_assignable_v<Pred>);
 ```
-The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`,
+The move assignment operator. Destroys previously existing elements, move-assigns 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`.
@@ -871,8 +863,6 @@ 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.
@@ -889,23 +879,15 @@ 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.
-
 --
 
 ---
@@ -916,8 +898,6 @@ 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.
@@ -934,23 +914,15 @@ 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.
-
 --
 
 ---
@@ -961,8 +933,6 @@ 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.
@@ -971,15 +941,9 @@ 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]
@@ -987,9 +951,7 @@ 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.  +
-+
-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.
+Notes:;; Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load. +
 
 ---
 
@@ -999,8 +961,6 @@ 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.
@@ -1009,15 +969,9 @@ 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.
@@ -1025,9 +979,7 @@ 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. +
-+
-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.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load.
 
 ---
 
@@ -1049,7 +1001,6 @@ Throws:;; Nothing.
 ==== Erase by Key
 ```c++
 size_type erase(const key_type& k);
-template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
@@ -1057,7 +1008,21 @@ 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`.
-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.
+
+---
+
+==== 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`.
 
 ---
 
@@ -1078,8 +1043,9 @@ 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::allocator_traits<Allocator>::propagate_on_container_swap::value);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+           boost::is_nothrow_swappable_v<Hash> &&
+           boost::is_nothrow_swappable_v<Pred>);
 ```
 
 Swaps the contents of the container with the parameter.
@@ -1210,16 +1176,13 @@ 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. +
-+
-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.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load.
 
 ---
 
@@ -1227,14 +1190,11 @@ The `template<class K>` overload only participates in overload resolution if `Ha
 ```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,8 +93,9 @@ 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::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+               boost::is_nothrow_move_assignable_v<Hash> &&
+               boost::is_nothrow_move_assignable_v<Pred>);
     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;
 
@@ -116,21 +117,20 @@ 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);
-    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);
+    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 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_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_flat_set_transparent_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::allocator_traits<Allocator>::propagate_on_container_swap::value);
+      noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+               boost::is_nothrow_swappable_v<Hash> &&
+               boost::is_nothrow_swappable_v<Pred>);
     void      xref:#unordered_flat_set_clear[clear]() noexcept;
 
     template<class H2, class P2>
@@ -565,10 +565,11 @@ 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::allocator_traits<Allocator>::propagate_on_container_move_assignment::value);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+           boost::is_nothrow_move_assignable_v<Hash> &&
+           boost::is_nothrow_move_assignable_v<Pred>);
 ```
-The move assignment operator. Destroys previously existing elements, swaps the hash function and predicate from `other`,
+The move assignment operator. Destroys previously existing elements, move-assigns 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`.
@@ -738,25 +739,6 @@ 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);
@@ -794,27 +776,6 @@ 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);
@@ -860,7 +821,6 @@ Throws:;; Nothing.
 ==== Erase by Key
 ```c++
 size_type erase(const key_type& k);
-template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
@@ -868,7 +828,21 @@ 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`.
-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.
+
+---
+
+==== 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`.
 
 ---
 
@@ -889,8 +863,9 @@ 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::allocator_traits<Allocator>::propagate_on_container_swap::value);
+  noexcept(boost::allocator_traits<Allocator>::is_always_equal::value &&
+           boost::is_nothrow_swappable_v<Hash> &&
+           boost::is_nothrow_swappable_v<Pred>);
 ```
 
 Swaps the contents of the container with the parameter.

doc/unordered/unordered_map.adoc

@@ -113,37 +113,29 @@ 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_extract_by_key[extract](K&& k);
+    template<class K> node_type xref:#unordered_map_transparent_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_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_map_transparent_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);
@@ -195,18 +187,14 @@ 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);
@@ -1009,8 +997,6 @@ 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.
@@ -1026,15 +1012,9 @@ 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.
@@ -1043,8 +1023,6 @@ 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`.
@@ -1058,8 +1036,6 @@ 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.
@@ -1075,15 +1051,9 @@ 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.
@@ -1094,8 +1064,6 @@ 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`.
@@ -1109,8 +1077,6 @@ 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.
@@ -1119,15 +1085,9 @@ 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]
@@ -1137,9 +1097,7 @@ 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. +
-+
-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.
+Pointers and references to elements are never invalidated.
 
 ---
 
@@ -1149,8 +1107,6 @@ 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.
@@ -1159,15 +1115,9 @@ 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.
@@ -1179,9 +1129,7 @@ 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. +
-+
-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.
+Pointers and references to elements are never invalidated.
 
 ---
 
@@ -1201,7 +1149,6 @@ 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);
-template<class K> node_type extract(K&& k);
 ```
 
 Removes an element with key equivalent to `k`.
@@ -1209,9 +1156,23 @@ 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`. +
-+
-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.
+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`.
 
 ---
 
@@ -1290,7 +1251,6 @@ 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);
-template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
@@ -1298,7 +1258,21 @@ 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`.
-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.
+
+---
+
+==== 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`.
 
 ---
 
@@ -1516,7 +1490,6 @@ 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]
@@ -1525,9 +1498,7 @@ 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. +
-+
-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.
+Pointers and references to elements are never invalidated.
 
 ---
 
@@ -1535,14 +1506,11 @@ The `template<class K>` overload only participates in overload resolution if `Ha
 ```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.
 
 ---
 
@@ -1582,13 +1550,11 @@ 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_extract_by_key[extract](K&& k);
+    template<class K> node_type xref:#unordered_multimap_transparent_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_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_multimap_transparent_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,7 +172,6 @@ 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);
@@ -965,7 +964,6 @@ 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);
-template<class K> node_type extract(K&& k);
 ```
 
 Removes an element with key equivalent to `k`.
@@ -973,9 +971,23 @@ 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`. +
-+
-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.
+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`.
 
 ---
 
@@ -1048,7 +1060,6 @@ 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);
-template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
@@ -1056,7 +1067,21 @@ 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`.
-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.
+
+---
+
+==== 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`.
 
 ---
 
@@ -1305,13 +1330,11 @@ 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_extract_by_value[extract](K&& k);
+    template<class K> node_type xref:#unordered_multiset_transparent_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_erase_by_value[erase](K&& x);
+    template<class K> size_type xref:#unordered_multiset_transparent_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,7 +168,6 @@ 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);
@@ -923,7 +922,6 @@ 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`.
@@ -931,9 +929,23 @@ 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`. +
-+
-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.
+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`.
 
 ---
 
@@ -1006,7 +1018,6 @@ 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);
-template<class K> size_type erase(K&& x);
 ```
 
 Erase all elements with key equivalent to `k`.
@@ -1014,7 +1025,21 @@ 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`.
-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.
+
+---
+
+==== 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`.
 
 ---
 
@@ -1263,13 +1288,11 @@ 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,23 +100,21 @@ 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_extract_by_value[extract](K&& k);
+    template<class K> node_type xref:#unordered_set_transparent_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_erase_by_value[erase](K&& k);
+    template<class K> size_type xref:#unordered_set_transparent_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);
@@ -170,7 +168,6 @@ 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);
@@ -850,27 +847,6 @@ 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);
@@ -912,29 +888,6 @@ 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);
@@ -983,7 +936,6 @@ 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);
-template<class K> node_type extract(K&& k);
 ```
 
 Removes an element with key equivalent to `k`.
@@ -991,9 +943,23 @@ 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. +
-+
-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.
+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.
 
 ---
 
@@ -1072,7 +1038,6 @@ 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);
-template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
@@ -1080,7 +1045,21 @@ 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`.
-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.
+
+---
+
+==== 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`.
 
 ---
 
@@ -1330,13 +1309,11 @@ 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/detail/foa/element_type.hpp

@@ -1,60 +0,0 @@
-/* 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/node_handle.hpp

@@ -1,210 +0,0 @@
-/* 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/implementation.hpp

@@ -1477,22 +1477,7 @@ 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
+      }
     }
   }
 }
@@ -2655,10 +2640,8 @@ namespace boost {
           } else {
             node_allocator_type alloc = node_alloc();
 
-            value_type* dispatch = BOOST_NULLPTR;
-
-            node_tmp tmp(detail::func::construct_node_from_key(
-                           dispatch, alloc, boost::forward<Key>(k)),
+            node_tmp tmp(
+              detail::func::construct_node_pair(alloc, boost::forward<Key>(k)),
               alloc);
 
             if (size_ + 1 > max_load_) {
@@ -2677,7 +2660,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()(extractor::extract(*hint), k)) {
+          if (hint.p && this->key_eq()(hint->first, k)) {
             return iterator(hint.p, hint.itb);
           } else {
             return try_emplace_unique(k).first;

include/boost/unordered/detail/mulx.hpp

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

@@ -1,44 +0,0 @@
-/* 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,7 +11,6 @@
 #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>
 
@@ -119,7 +118,7 @@ namespace boost {
           std::size_t sizes_under_32bit = inv_sizes32_len;
           if (BOOST_LIKELY(size_index < sizes_under_32bit)) {
             return fast_modulo(
-              narrow_cast<boost::uint32_t>(hash) + narrow_cast<boost::uint32_t>(hash >> 32),
+              boost::uint32_t(hash) + boost::uint32_t(hash >> 32),
               inv_sizes32[size_index], boost::uint32_t(sizes[size_index]));
           } else {
             return positions[size_index - sizes_under_32bit](hash);

include/boost/unordered/detail/requires_cxx11.hpp

@@ -1,21 +0,0 @@
-#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 Hash, class KeyEqual> struct are_transparent
+      template <class, class A, class B> struct are_transparent
       {
         static bool const value =
-          is_transparent<Hash>::value && is_transparent<KeyEqual>::value;
+          is_transparent<A>::value && is_transparent<B>::value;
       };
 
       template <class Key, class UnorderedMap> struct transparent_non_iterable

include/boost/unordered/unordered_flat_map.hpp

@@ -32,8 +32,10 @@ namespace boost {
 #pragma warning(disable : 4714) /* marked as __forceinline not inlined */
 #endif
 
-    namespace detail {
-      template <class Key, class T> struct flat_map_types
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    class unordered_flat_map
+    {
+      struct map_types
       {
         using key_type = Key;
         using raw_key_type = typename std::remove_const<Key>::type;
@@ -43,56 +45,19 @@ 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(init_type& x)
-        {
-          return {std::move(x.first), std::move(x.second)};
-        }
-
-        static moved_type move(element_type& x)
+        static moved_type move(value_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,
@@ -313,37 +278,24 @@ namespace boost {
       template <class M>
       std::pair<iterator, bool> insert_or_assign(key_type const& key, M&& obj)
       {
-        auto ibp = table_.try_emplace(key, std::forward<M>(obj));
-        if (ibp.second) {
-          return ibp;
+        auto iter_bool_pair = table_.try_emplace(key, std::forward<M>(obj));
+        if (iter_bool_pair.second) {
+          return iter_bool_pair;
         }
-        ibp.first->second = std::forward<M>(obj);
-        return ibp;
+        iter_bool_pair.first->second = std::forward<M>(obj);
+        return iter_bool_pair;
       }
 
       template <class M>
       std::pair<iterator, bool> insert_or_assign(key_type&& key, M&& obj)
       {
-        auto ibp = table_.try_emplace(std::move(key), std::forward<M>(obj));
-        if (ibp.second) {
-          return ibp;
+        auto iter_bool_pair =
+          table_.try_emplace(std::move(key), std::forward<M>(obj));
+        if (iter_bool_pair.second) {
+          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;
+        iter_bool_pair.first->second = std::forward<M>(obj);
+        return iter_bool_pair;
       }
 
       template <class M>
@@ -359,16 +311,6 @@ 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)
       {
@@ -395,17 +337,6 @@ 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)
@@ -421,18 +352,6 @@ 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)
       {
@@ -508,61 +427,24 @@ 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)
+      mapped_type& operator[](key_type const& key)
       {
         return table_.try_emplace(key).first->second;
       }
 
-      BOOST_FORCEINLINE mapped_type& operator[](key_type&& key)
+      mapped_type& operator[](key_type&& key)
       {
         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
+      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<
+      typename std::enable_if<
         detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
       count(K const& key) const
       {
@@ -598,13 +480,13 @@ namespace boost {
         return table_.find(key);
       }
 
-      BOOST_FORCEINLINE bool contains(key_type const& key) const
+      bool contains(key_type const& key) const
       {
         return this->find(key) != this->end();
       }
 
       template <class K>
-      BOOST_FORCEINLINE typename std::enable_if<
+      typename std::enable_if<
         boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
         bool>::type
       contains(K const& key) const

include/boost/unordered/unordered_flat_set.hpp

@@ -30,38 +30,17 @@ namespace boost {
 #pragma warning(disable : 4714) /* marked as __forceinline not inlined */
 #endif
 
-    namespace detail {
-      template <class Key> struct flat_set_types
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    class unordered_flat_set
+    {
+      struct 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 = 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);
-        }
+        static Key&& move(value_type& x) { return std::move(x); }
       };
-    } // 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,
@@ -252,15 +231,6 @@ 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;
@@ -271,15 +241,6 @@ 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)
       {
@@ -352,14 +313,14 @@ namespace boost {
       /// Lookup
       ///
 
-      BOOST_FORCEINLINE size_type count(key_type const& key) const
+      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<
+      typename std::enable_if<
         detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
       count(K const& key) const
       {
@@ -395,13 +356,13 @@ namespace boost {
         return table_.find(key);
       }
 
-      BOOST_FORCEINLINE bool contains(key_type const& key) const
+      bool contains(key_type const& key) const
       {
         return this->find(key) != this->end();
       }
 
       template <class K>
-      BOOST_FORCEINLINE typename std::enable_if<
+      typename std::enable_if<
         boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
         bool>::type
       contains(K const& key) const

include/boost/unordered/unordered_map.hpp

@@ -15,7 +15,6 @@
 #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>
@@ -487,16 +486,6 @@ 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)
@@ -513,16 +502,6 @@ 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:
@@ -603,43 +582,6 @@ 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>
@@ -698,44 +640,6 @@ 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)>                          \
@@ -802,15 +706,6 @@ 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)
@@ -827,18 +722,6 @@ 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&);
@@ -973,23 +856,9 @@ 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
@@ -1009,14 +878,6 @@ 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);
@@ -1723,14 +1584,6 @@ 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));
@@ -2245,15 +2098,6 @@ 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)
@@ -2286,42 +2130,6 @@ 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

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

@@ -1,764 +0,0 @@
-// 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.hpp>
-#include <boost/unordered/detail/foa/element_type.hpp>
-#include <boost/unordered/detail/foa/node_handle.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

@@ -1,49 +0,0 @@
-
-// 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,7 +15,6 @@
 #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>
@@ -391,15 +390,6 @@ 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);
@@ -410,15 +400,6 @@ 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)
@@ -590,14 +571,6 @@ 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));
@@ -1239,14 +1212,6 @@ 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-2023 Christian Mazakas
+# Copyright 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)
 
@@ -26,7 +26,6 @@ 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
@@ -95,9 +94,7 @@ 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 ;
@@ -142,9 +139,6 @@ build_foa erase_if ;
 build_foa scary_tests ;
 build_foa init_type_insert_tests ;
 build_foa max_load_tests ;
-build_foa extract_tests ;
-build_foa node_handle_tests ;
-build_foa uses_allocator ;
 
 run unordered/hash_is_avalanching_test.cpp ;
 

test/cmake_subdir_test/CMakeLists.txt

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

test/exception/assign_exception_tests.cpp

@@ -60,9 +60,6 @@ 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;
@@ -70,10 +67,7 @@ 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)),
-        t1(tag1),
-        t2(tag2)
-
+        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
   {
     x.max_load_factor(mlf1);
     y.max_load_factor(mlf2);
@@ -95,22 +89,6 @@ 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,24 +25,8 @@ typedef boost::unordered_flat_set<
   test::exception::allocator<test::exception::object> >
   test_pair_set;
 
-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)
+#define CONTAINER_SEQ (test_set)(test_map)
+#define CONTAINER_PAIR_SEQ (test_pair_set)(test_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-2023 Christian Mazakas.
+// Copyright 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)
 #include "./containers.hpp"
@@ -229,12 +229,10 @@ 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_node_set_)(test_node_map_))
+    ((test_set_)(test_map_))
     ((insert_lvalue)(insert_lvalue_begin)(insert_lvalue_end)
      (insert_lvalue_pos)(insert_single_item_range)
      (emplace_lvalue)(emplace_lvalue_begin)(emplace_lvalue_end)
@@ -244,7 +242,7 @@ UNORDERED_TEST(insert_exception_test,
 )
 
 UNORDERED_TEST(insert_rehash_exception_test,
-    ((test_set_)(test_map_)(test_node_set_)(test_node_map_))
+    ((test_set_)(test_map_))
     ((insert_lvalue)(insert_lvalue_begin)(insert_lvalue_end)
      (insert_lvalue_pos)(insert_single_item_range)
      (emplace_lvalue)(emplace_lvalue_begin)(emplace_lvalue_end)
@@ -316,16 +314,15 @@ 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_node_set_)(test_node_map_))
+    ((test_pair_set_)(test_map_))
     ((pair_emplace)(pair_emplace2))
     ((default_generator)(limited_range)(generate_collisions))
 )
 UNORDERED_TEST(insert_rehash_exception_test,
-    ((test_pair_set_)(test_map_)(test_pair_node_set_)(test_node_map_))
+    ((test_pair_set_)(test_map_))
     ((pair_emplace)(pair_emplace2))
     ((default_generator)(limited_range)(generate_collisions))
 )
@@ -402,20 +399,6 @@ 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_))
@@ -428,7 +411,6 @@ UNORDERED_TEST(insert_rehash_exception_test,
     ((default_generator)(limited_range)(generate_collisions))
 )
 // clang-format on
-#endif
 
 // Range insert tests
 
@@ -477,12 +459,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_node_set_)(test_node_map_))
+    ((test_set_)(test_map_))
     ((default_generator)(limited_range)(generate_collisions))
 )
 
 UNORDERED_TEST(insert_range_rehash_exception_test,
-    ((test_set_)(test_map_)(test_node_set_)(test_node_map_))
+    ((test_set_)(test_map_))
     ((default_generator)(limited_range)(generate_collisions))
 )
 // clang-format on

test/exception/less_tests.cpp

@@ -1,50 +0,0 @@
-
-// 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-2023 Christian Mazakas.
+// Copyright 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)
 
@@ -64,12 +64,6 @@ 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,
@@ -105,40 +99,6 @@ 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,7 +20,6 @@ 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;
@@ -29,9 +28,7 @@ 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)),
-        t1(tag1),
-        t2(tag2)
+        y(0, hasher(tag2), key_equal(tag2), allocator_type(tag2))
   {
     x.max_load_factor(mlf1);
     y.max_load_factor(mlf2);
@@ -55,22 +52,6 @@ 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,40 +4,15 @@
 // 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)
 
-#define BOOST_ENABLE_ASSERT_HANDLER
-#include <boost/assert.hpp>
-
 #include "./containers.hpp"
 
+#if defined(BOOST_UNORDERED_FOA_TESTS)
+#define BOOST_UNORDERED_FOA_WEAK_GUARANTEE_SWAP_EXCEPTIONS_TESTS
+#endif
+
 #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
@@ -64,10 +39,15 @@ template <class T> struct self_swap_base : public test::exception_base
 
   void check BOOST_PREVENT_MACRO_SUBSTITUTION(T const& x) const
   {
-    (void)x;
+    std::string scope(test::scope);
 
-    BOOST_ERROR("An exception leaked when it should not have. Allocator "
-                "equality assertion must precede all other ops");
+    // 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);
   }
 };
 
@@ -160,139 +140,11 @@ 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,10 +54,20 @@ 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/tracker.hpp

@@ -42,8 +42,9 @@ namespace test {
     value_list values2(x2.begin(), x2.end());
     values1.sort();
     values2.sort();
-    BOOST_TEST_ALL_WITH(values1.begin(), values1.end(), values2.begin(),
-      values2.end(), test::equivalent);
+    BOOST_TEST(values1.size() == values2.size() &&
+               test::equal(values1.begin(), values1.end(), values2.begin(),
+                 test::equivalent));
   }
 
   template <class X1, class X2, class T>

test/helpers/unordered.hpp

@@ -11,8 +11,6 @@
 #ifdef BOOST_UNORDERED_FOA_TESTS
 #include <boost/unordered/unordered_flat_set.hpp>
 #include <boost/unordered/unordered_flat_map.hpp>
-#include <boost/unordered/unordered_node_map.hpp>
-#include <boost/unordered/unordered_node_set.hpp>
 #include <boost/unordered/detail/implementation.hpp>
 #else
 #include <boost/unordered_set.hpp>

test/objects/exception.hpp

@@ -227,21 +227,8 @@ namespace test {
         }
         return x1.tag_ != x2.tag_;
       }
-
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      friend void swap(hash&, hash&) noexcept;
-#endif
     };
 
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      void swap(hash& lhs, hash& rhs) noexcept
-      {
-        int tag = lhs.tag_;
-        lhs.tag_ = rhs.tag_;
-        rhs.tag_ = tag;
-      }
-#endif
-
     class less
     {
       int tag_;
@@ -262,7 +249,7 @@ namespace test {
         if (less_impl(x1.first, x2.first)) {
           return true;
         }
-        if (less_impl(x2.first, x1.first)) {
+        if (!less_impl(x1.first, x2.first)) {
           return false;
         }
         return less_impl(x1.second, x2.second);
@@ -377,20 +364,8 @@ namespace test {
       }
 
       friend less create_compare(equal_to x) { return less(x.tag_); }
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      friend void swap(equal_to&, equal_to&) noexcept;
-#endif
     };
 
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-    void swap(equal_to& lhs, equal_to& rhs) noexcept
-    {
-      int tag = lhs.tag_;
-      lhs.tag_ = rhs.tag_;
-      rhs.tag_ = tag;
-    }
-#endif
-
     template <class T> class allocator
     {
     public:

test/objects/minimal.hpp

@@ -206,11 +206,6 @@ namespace test {
       hash& operator=(hash const&) { return *this; }
       ~hash() {}
 
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      hash(hash&&) = default;
-      hash& operator=(hash&&) = default;
-#endif
-
       std::size_t operator()(T const&) const { return 0; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
       ampersand_operator_used operator&() const
@@ -229,11 +224,6 @@ namespace test {
       equal_to& operator=(equal_to const&) { return *this; }
       ~equal_to() {}
 
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-      equal_to(equal_to&&) = default;
-      equal_to& operator=(equal_to&&) = default;
-#endif
-
       bool operator()(T const&, T const&) const { return true; }
 #if BOOST_UNORDERED_CHECK_ADDR_OPERATOR_NOT_USED
       ampersand_operator_used operator&() const

test/objects/test.hpp

@@ -230,18 +230,18 @@ namespace test {
 
     std::size_t operator()(int x) const
     {
-      unsigned result;
+      int result;
       switch (type_) {
       case 1:
-        result = static_cast<unsigned>(x);
+        result = x;
         break;
       case 2:
-        result = static_cast<unsigned>(x) * 7;
+        result = x * 7;
         break;
       default:
-        result = static_cast<unsigned>(x) * 256;
+        result = x * 256;
       }
-      return result;
+      return static_cast<std::size_t>(result);
     }
 
     friend bool operator==(hash const& x1, hash const& x2)

test/unordered/assign_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 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)
 
@@ -209,75 +209,40 @@ namespace assign_tests {
 #ifdef BOOST_UNORDERED_FOA_TESTS
   boost::unordered_flat_map<test::object, test::object, test::hash,
     test::equal_to, std::allocator<test::object> >* test_map_std_alloc;
-  boost::unordered_node_map<test::object, test::object, test::hash,
-    test::equal_to, std::allocator<test::object> >* test_node_map_std_alloc;
 
   boost::unordered_flat_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-  boost::unordered_node_set<test::object, test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_node_set;
   boost::unordered_flat_map<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_map;
-  boost::unordered_node_map<test::object, test::object, test::hash,
-    test::equal_to, test::allocator2<test::object> >* test_node_map;
 
   boost::unordered_flat_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_set_prop_assign;
-  boost::unordered_node_set<test::object, test::hash, test::equal_to,
-    test::cxx11_allocator<test::object, test::propagate_assign> >*
-    test_node_set_prop_assign;
   boost::unordered_flat_map<test::object, test::object, test::hash,
     test::equal_to,
     test::cxx11_allocator<test::object, test::propagate_assign> >*
     test_map_prop_assign;
-  boost::unordered_node_map<test::object, test::object, test::hash,
-    test::equal_to,
-    test::cxx11_allocator<test::object, test::propagate_assign> >*
-    test_node_map_prop_assign;
 
   boost::unordered_flat_set<test::object, test::hash, test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_set_no_prop_assign;
-  boost::unordered_node_set<test::object, test::hash, test::equal_to,
-    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
-    test_node_set_no_prop_assign;
   boost::unordered_flat_map<test::object, test::object, test::hash,
     test::equal_to,
     test::cxx11_allocator<test::object, test::no_propagate_assign> >*
     test_map_no_prop_assign;
-  boost::unordered_node_map<test::object, test::object, test::hash,
-    test::equal_to,
-    test::cxx11_allocator<test::object, test::no_propagate_assign> >*
-    test_node_map_no_prop_assign;
 
   UNORDERED_AUTO_TEST (check_traits) {
     BOOST_TEST(!is_propagate(test_set));
     BOOST_TEST(is_propagate(test_set_prop_assign));
     BOOST_TEST(!is_propagate(test_set_no_prop_assign));
-
-    BOOST_TEST(!is_propagate(test_node_set));
-    BOOST_TEST(is_propagate(test_node_set_prop_assign));
-    BOOST_TEST(!is_propagate(test_node_set_no_prop_assign));
   }
 
   UNORDERED_TEST(assign_tests1,
-    ((test_map_std_alloc)(test_node_map_std_alloc)
-     (test_set)(test_node_set)
-     (test_map)(test_node_map)
-     (test_set_prop_assign)(test_node_set_prop_assign)
-     (test_map_prop_assign)(test_node_map_prop_assign)
-     (test_set_no_prop_assign)(test_node_set_no_prop_assign)
-     (test_map_no_prop_assign)(test_node_map_no_prop_assign))(
+    ((test_map_std_alloc)(test_set)(test_map)(test_set_prop_assign)(test_map_prop_assign)(test_set_no_prop_assign)(test_map_no_prop_assign))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(assign_tests2,
-    ((test_set)(test_node_set)
-     (test_map)(test_node_map)
-     (test_set_prop_assign)(test_node_set_prop_assign)
-     (test_map_prop_assign)(test_node_map_prop_assign)
-     (test_set_no_prop_assign)(test_node_set_no_prop_assign)
-     (test_map_no_prop_assign)(test_node_map_no_prop_assign))(
+    ((test_set)(test_map)(test_set_prop_assign)(test_map_prop_assign)(test_set_no_prop_assign)(test_map_no_prop_assign))(
       (default_generator)(generate_collisions)(limited_range)))
 #else
   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
@@ -350,12 +315,6 @@ namespace assign_tests {
     std::initializer_list<std::pair<int const, int> > init;
 #ifdef BOOST_UNORDERED_FOA_TESTS
     boost::unordered_flat_map<int, int> x1;
-    boost::unordered_node_map<int, int> x2;
-    x2[25] = 3;
-    x2[16] = 10;
-    BOOST_TEST(!x2.empty());
-    x2 = init;
-    BOOST_TEST(x2.empty());
 #else
     boost::unordered_map<int, int> x1;
 #endif
@@ -374,12 +333,6 @@ namespace assign_tests {
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
     boost::unordered_flat_set<int> x;
-    boost::unordered_node_set<int> y;
-    y.insert(10);
-    y.insert(20);
-    y = {1, 2, -10};
-    BOOST_TEST(y.find(10) == y.end());
-    BOOST_TEST(y.find(-10) != y.end());
 #else
     boost::unordered_set<int> x;
 #endif

test/unordered/at_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2007-2009 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 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)
 
@@ -11,12 +11,16 @@
 
 namespace at_tests {
 
-  template <class X> static void at_tests(X*)
-  {
+  UNORDERED_AUTO_TEST (at_tests) {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Create Map" << std::endl;
 
-    X x;
-    X const& x_const(x);
+#ifdef BOOST_UNORDERED_FOA_TESTS
+    boost::unordered_flat_map<std::string, int> x;
+    boost::unordered_flat_map<std::string, int> const& x_const(x);
+#else
+    boost::unordered_map<std::string, int> x;
+    boost::unordered_map<std::string, int> const& x_const(x);
+#endif
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check empty container" << std::endl;
 
@@ -60,21 +64,6 @@ namespace at_tests {
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Finished" << std::endl;
   }
-
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  static boost::unordered_flat_map<std::string, int>* test_map;
-  static boost::unordered_node_map<std::string, int>* test_node_map;
-
-  // clang-format off
-  UNORDERED_TEST(at_tests, ((test_map)(test_node_map)))
-  // clang-format on
-#else
-  static boost::unordered_map<std::string, int>* test_map;
-
-  // clang-format off
-  UNORDERED_TEST(at_tests, ((test_map)))
-  // clang-format on
-#endif
-} // namespace at_tests
+}
 
 RUN_TESTS()

test/unordered/compile_map.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 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)
 
@@ -35,22 +35,6 @@ template class instantiate_flat_map<test::minimal::assignable const,
   test::minimal::equal_to<test::minimal::assignable>,
   test::minimal::allocator<int> >;
 
-template <typename K, typename T, typename H, typename P, typename A>
-class instantiate_node_map
-{
-  typedef boost::unordered_node_map<K, T, H, P, A> container;
-  container x;
-};
-
-template class instantiate_node_map<int, int, boost::hash<int>,
-  std::equal_to<int>, test::minimal::allocator<int> >;
-
-template class instantiate_node_map<test::minimal::assignable const,
-  test::minimal::default_assignable const,
-  test::minimal::hash<test::minimal::assignable>,
-  test::minimal::equal_to<test::minimal::assignable>,
-  test::minimal::allocator<int> >;
-
 #else
 #define INSTANTIATE(type)                                                      \
   template class boost::unordered::detail::instantiate_##type
@@ -71,101 +55,149 @@ INSTANTIATE(multimap)<test::minimal::assignable, test::minimal::assignable,
   test::minimal::allocator<int> >;
 #endif
 
-template <template <class Key, class T, class H = boost::hash<Key>,
-  class P = std::equal_to<Key>,
-  class Allocator = std::allocator<std::pair<Key const, T> > >
-  class Map>
-static void test0_impl()
-{
+UNORDERED_AUTO_TEST (test0) {
   test::minimal::constructor_param x;
 
   typedef std::pair<test::minimal::assignable const, test::minimal::assignable>
     value_type;
   value_type value(x, x);
 
-  Map<int, int> int_map;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
 
-  Map<int, int, boost::hash<int>, std::equal_to<int>,
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_map<int, int> int_map;
+
+  boost::unordered_flat_map<int, int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<std::pair<int const, int> > >
     int_map2;
 
-  Map<test::minimal::assignable, test::minimal::assignable,
+  boost::unordered_flat_map<test::minimal::assignable,
+    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<value_type> >
+    map;
+#else
+  boost::unordered_map<int, int> int_map;
+
+  boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    int_map2;
+
+  boost::unordered_map<test::minimal::assignable, test::minimal::assignable,
     test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<value_type> >
     map;
+#endif
 
   container_test(int_map, std::pair<int const, int>(0, 0));
   container_test(int_map2, std::pair<int const, int>(0, 0));
   container_test(map, value);
-}
 
-UNORDERED_AUTO_TEST (test0) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  test0_impl<boost::unordered_flat_map>();
-  test0_impl<boost::unordered_node_map>();
-#else
-  test0_impl<boost::unordered_map>();
-  test0_impl<boost::unordered_multimap>();
+#ifndef BOOST_UNORDERED_FOA_TESTS
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+
+  boost::unordered_multimap<int, int> int_multimap;
+
+  boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    int_multimap2;
+
+  boost::unordered_multimap<test::minimal::assignable,
+    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<value_type> >
+    multimap;
+
+  container_test(int_multimap, std::pair<int const, int>(0, 0));
+  container_test(int_multimap2, std::pair<int const, int>(0, 0));
+  container_test(multimap, value);
 #endif
 }
 
-template <template <class Key, class T, class H = boost::hash<Key>,
-  class P = std::equal_to<Key>,
-  class Allocator = std::allocator<std::pair<Key const, T> > >
-  class Map>
-static void equality_tests_impl()
-{
+UNORDERED_AUTO_TEST (equality_tests) {
   typedef std::pair<test::minimal::copy_constructible_equality_comparable const,
     test::minimal::copy_constructible_equality_comparable>
     value_type;
 
-  Map<int, int> int_map;
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_map<int, int> int_map;
 
-  Map<int, int, boost::hash<int>, std::equal_to<int>,
+  boost::unordered_flat_map<int, int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<std::pair<int const, int> > >
     int_map2;
 
-  Map<test::minimal::copy_constructible_equality_comparable,
+  boost::unordered_flat_map<
+    test::minimal::copy_constructible_equality_comparable,
     test::minimal::copy_constructible_equality_comparable,
     test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
     test::minimal::equal_to<
       test::minimal::copy_constructible_equality_comparable>,
     test::minimal::allocator<value_type> >
     map;
+#else
+  boost::unordered_map<int, int> int_map;
+
+  boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    int_map2;
+
+  boost::unordered_map<test::minimal::copy_constructible_equality_comparable,
+    test::minimal::copy_constructible_equality_comparable,
+    test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+    test::minimal::equal_to<
+      test::minimal::copy_constructible_equality_comparable>,
+    test::minimal::allocator<value_type> >
+    map;
+#endif
 
   equality_test(int_map);
   equality_test(int_map2);
   equality_test(map);
-}
 
-UNORDERED_AUTO_TEST (equality_tests) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  equality_tests_impl<boost::unordered_flat_map>();
-  equality_tests_impl<boost::unordered_node_map>();
-#else
-  equality_tests_impl<boost::unordered_map>();
-  equality_tests_impl<boost::unordered_multimap>();
+#ifndef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_multimap<int, int> int_multimap;
+
+  boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    int_multimap2;
+
+  boost::unordered_multimap<
+    test::minimal::copy_constructible_equality_comparable,
+    test::minimal::copy_constructible_equality_comparable,
+    test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+    test::minimal::equal_to<
+      test::minimal::copy_constructible_equality_comparable>,
+    test::minimal::allocator<value_type> >
+    multimap;
+
+  equality_test(int_multimap);
+  equality_test(int_multimap2);
+  equality_test(multimap);
 #endif
 }
 
-template <template <class Key, class T, class H = boost::hash<Key>,
-  class P = std::equal_to<Key>,
-  class Allocator = std::allocator<std::pair<Key const, T> > >
-  class Map>
-static void test1_unique_impl()
-{
-
+UNORDERED_AUTO_TEST (test1) {
   boost::hash<int> hash;
   std::equal_to<int> equal_to;
   int value = 0;
   std::pair<int const, int> map_value(0, 0);
 
-  Map<int, int> map;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
 
-  Map<int, int, boost::hash<int>, std::equal_to<int>,
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_map<int, int> map;
+
+  boost::unordered_flat_map<int, int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<std::pair<int const, int> > >
     map2;
+#else
+  boost::unordered_map<int, int> map;
+
+  boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<std::pair<int const, int> > >
+    map2;
+#endif
 
   unordered_unique_test(map, map_value);
   unordered_map_test(map, value, value);
@@ -176,53 +208,27 @@ static void test1_unique_impl()
   unordered_map_test(map2, value, value);
   unordered_copyable_test(map2, value, map_value, hash, equal_to);
   unordered_map_functions(map2, value, value);
-}
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
-template <template <class Key, class T, class H = boost::hash<Key>,
-  class P = std::equal_to<Key>,
-  class Allocator = std::allocator<std::pair<Key const, T> > >
-  class Map>
-static void test1_equivalent_impl()
-{
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
 
-  boost::hash<int> hash;
-  std::equal_to<int> equal_to;
-  int value = 0;
-  std::pair<int const, int> map_value(0, 0);
+  boost::unordered_multimap<int, int> multimap;
 
-  Map<int, int> map;
-
-  Map<int, int, boost::hash<int>, std::equal_to<int>,
+  boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<std::pair<int const, int> > >
-    map2;
+    multimap2;
 
-  unordered_equivalent_test(map, map_value);
-  unordered_map_test(map, value, value);
-  unordered_copyable_test(map, value, map_value, hash, equal_to);
+  unordered_equivalent_test(multimap, map_value);
+  unordered_map_test(multimap, value, value);
+  unordered_copyable_test(multimap, value, map_value, hash, equal_to);
 
-  unordered_equivalent_test(map2, map_value);
-  unordered_map_test(map2, value, value);
-  unordered_copyable_test(map2, value, map_value, hash, equal_to);
-}
-#endif
-
-UNORDERED_AUTO_TEST (test1) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  test1_unique_impl<boost::unordered_flat_map>();
-  test1_unique_impl<boost::unordered_node_map>();
-#else
-  test1_unique_impl<boost::unordered_map>();
-  test1_equivalent_impl<boost::unordered_multimap>();
+  unordered_equivalent_test(multimap2, map_value);
+  unordered_map_test(multimap2, value, value);
+  unordered_copyable_test(multimap2, value, map_value, hash, equal_to);
 #endif
 }
 
-template <template <class Key, class T, class H = boost::hash<Key>,
-  class P = std::equal_to<Key>,
-  class Allocator = std::allocator<std::pair<Key const, T> > >
-  class Map>
-static void test2_unique_impl()
-{
+UNORDERED_AUTO_TEST (test2) {
   test::minimal::constructor_param x;
 
   test::minimal::assignable assignable(x);
@@ -234,66 +240,60 @@ static void test2_unique_impl()
     map_value_type;
   map_value_type map_value(assignable, assignable);
 
-  Map<test::minimal::assignable, test::minimal::assignable,
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_map<test::minimal::assignable,
+    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<map_value_type> >
+    map;
+#else
+  boost::unordered_map<test::minimal::assignable, test::minimal::assignable,
     test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<map_value_type> >
     map;
+#endif
 
   unordered_unique_test(map, map_value);
   unordered_map_test(map, assignable, assignable);
   unordered_copyable_test(map, assignable, map_value, hash, equal_to);
   unordered_map_member_test(map, map_value);
 
-  Map<test::minimal::assignable, test::minimal::default_assignable,
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_map<test::minimal::assignable,
+    test::minimal::default_assignable,
     test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<map_value_type> >
     map2;
+#else
+  boost::unordered_map<test::minimal::assignable,
+    test::minimal::default_assignable,
+    test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<map_value_type> >
+    map2;
+#endif
 
   test::minimal::default_assignable default_assignable;
 
   unordered_map_functions(map2, assignable, default_assignable);
-}
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
-template <template <class Key, class T, class H = boost::hash<Key>,
-  class P = std::equal_to<Key>,
-  class Allocator = std::allocator<std::pair<Key const, T> > >
-  class Map>
-static void test2_equivalent_impl()
-{
-  test::minimal::constructor_param x;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
 
-  test::minimal::assignable assignable(x);
-  test::minimal::copy_constructible copy_constructible(x);
-  test::minimal::hash<test::minimal::assignable> hash(x);
-  test::minimal::equal_to<test::minimal::assignable> equal_to(x);
-
-  typedef std::pair<test::minimal::assignable const, test::minimal::assignable>
-    map_value_type;
-  map_value_type map_value(assignable, assignable);
-
-  Map<test::minimal::assignable, test::minimal::assignable,
-    test::minimal::hash<test::minimal::assignable>,
+  boost::unordered_multimap<test::minimal::assignable,
+    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<map_value_type> >
-    map;
+    multimap;
 
-  unordered_equivalent_test(map, map_value);
-  unordered_map_test(map, assignable, assignable);
-  unordered_copyable_test(map, assignable, map_value, hash, equal_to);
-  unordered_map_member_test(map, map_value);
-}
-#endif
-
-UNORDERED_AUTO_TEST (test2) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  test2_unique_impl<boost::unordered_flat_map>();
-  test2_unique_impl<boost::unordered_node_map>();
-#else
-  test2_unique_impl<boost::unordered_map>();
-  test2_equivalent_impl<boost::unordered_multimap>();
+  unordered_equivalent_test(multimap, map_value);
+  unordered_map_test(multimap, assignable, assignable);
+  unordered_copyable_test(multimap, assignable, map_value, hash, equal_to);
+  unordered_map_member_test(multimap, map_value);
 #endif
 }
 
@@ -316,17 +316,9 @@ bool operator==(lwg2059_key x, lwg2059_key y) { return x.value == y.value; }
 
 UNORDERED_AUTO_TEST (lwg2059) {
 #ifdef BOOST_UNORDERED_FOA_TESTS
-  {
-    boost::unordered_flat_map<lwg2059_key, int> x;
-    x.emplace(lwg2059_key(10), 5);
-    x.erase(x.begin());
-  }
-
-  {
-    boost::unordered_node_map<lwg2059_key, int> x;
-    x.emplace(lwg2059_key(10), 5);
-    x.erase(x.begin());
-  }
+  boost::unordered_flat_map<lwg2059_key, int> x;
+  x.emplace(lwg2059_key(10), 5);
+  x.erase(x.begin());
 #else
   {
     boost::unordered_map<lwg2059_key, int> x;

test/unordered/compile_set.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 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)
 
@@ -35,21 +35,6 @@ template class instantiate_flat_set<test::minimal::assignable const,
   test::minimal::equal_to<test::minimal::assignable>,
   test::minimal::allocator<int> >;
 
-template <typename T, typename H, typename P, typename A>
-class instantiate_node_set
-{
-  typedef boost::unordered_node_set<T, H, P, A> container;
-  container x;
-};
-
-template class instantiate_node_set<int, boost::hash<int>, std::equal_to<int>,
-  test::minimal::allocator<int> >;
-
-template class instantiate_node_set<test::minimal::assignable const,
-  test::minimal::hash<test::minimal::assignable>,
-  test::minimal::equal_to<test::minimal::assignable>,
-  test::minimal::allocator<int> >;
-
 #else
 
 #define INSTANTIATE(type)                                                      \
@@ -71,106 +56,153 @@ INSTANTIATE(multiset)<test::minimal::assignable,
 
 #endif
 
-template <class X> static void type_traits_impl()
-{
-  BOOST_STATIC_ASSERT(boost::is_same<int const&,
-    typename std::iterator_traits<typename X::iterator>::reference>::value);
-}
-
 UNORDERED_AUTO_TEST (type_traits) {
 #ifdef BOOST_UNORDERED_FOA_TESTS
-  type_traits_impl<boost::unordered_flat_set<int> >();
-  type_traits_impl<boost::unordered_node_set<int> >();
+  typedef boost::unordered_flat_set<int> set_type;
 #else
-  type_traits_impl<boost::unordered_set<int> >();
-  type_traits_impl<boost::unordered_multiset<int> >();
+  typedef boost::unordered_set<int> set_type;
 #endif
+
+  typedef set_type::iterator iterator;
+
+  BOOST_STATIC_ASSERT(boost::is_same<int const&,
+    std::iterator_traits<iterator>::reference>::value);
 }
 
-template <template <class T, class H = boost::hash<T>,
-  class P = std::equal_to<T>, class A = std::allocator<T> >
-  class Set>
-static void test0_impl()
-{
+UNORDERED_AUTO_TEST (test0) {
   test::minimal::constructor_param x;
 
   test::minimal::assignable assignable(x);
 
-  Set<int> int_set;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
 
-  Set<int, boost::hash<int>, std::equal_to<int>,
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<int> int_set;
+
+  boost::unordered_flat_set<int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<int> >
     int_set2;
 
-  Set<test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
+  boost::unordered_flat_set<test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >
     set;
+#else
+  boost::unordered_set<int> int_set;
+
+  boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<int> >
+    int_set2;
+
+  boost::unordered_set<test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<test::minimal::assignable> >
+    set;
+#endif
 
   container_test(int_set, 0);
   container_test(int_set2, 0);
   container_test(set, assignable);
-}
 
-UNORDERED_AUTO_TEST (test0) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  test0_impl<boost::unordered_flat_set>();
-  test0_impl<boost::unordered_node_set>();
-#else
-  test0_impl<boost::unordered_set>();
-  test0_impl<boost::unordered_multiset>();
+#ifndef BOOST_UNORDERED_FOA_TESTS
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+
+  boost::unordered_multiset<int> int_multiset;
+
+  boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<int> >
+    int_multiset2;
+
+  boost::unordered_multiset<test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<test::minimal::assignable> >
+    multiset;
+
+  container_test(int_multiset, 0);
+  container_test(int_multiset2, 0);
+  container_test(multiset, assignable);
 #endif
 }
 
-template <template <class T, class H = boost::hash<T>,
-  class P = std::equal_to<T>, class A = std::allocator<T> >
-  class Set>
-static void equality_tests_impl()
-{
+UNORDERED_AUTO_TEST (equality_tests) {
   typedef test::minimal::copy_constructible_equality_comparable value_type;
 
-  Set<int> int_set;
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<int> int_set;
 
-  Set<int, boost::hash<int>, std::equal_to<int>,
+  boost::unordered_flat_set<int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<int> >
     int_set2;
 
-  Set<test::minimal::copy_constructible_equality_comparable,
+  boost::unordered_flat_set<
+    test::minimal::copy_constructible_equality_comparable,
     test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
     test::minimal::equal_to<
       test::minimal::copy_constructible_equality_comparable>,
     test::minimal::allocator<value_type> >
     set;
+#else
+  boost::unordered_set<int> int_set;
+
+  boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<int> >
+    int_set2;
+
+  boost::unordered_set<test::minimal::copy_constructible_equality_comparable,
+    test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+    test::minimal::equal_to<
+      test::minimal::copy_constructible_equality_comparable>,
+    test::minimal::allocator<value_type> >
+    set;
+#endif
 
   equality_test(int_set);
   equality_test(int_set2);
   equality_test(set);
-}
 
-UNORDERED_AUTO_TEST (equality_tests) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  equality_tests_impl<boost::unordered_flat_set>();
-  equality_tests_impl<boost::unordered_node_set>();
-#else
-  equality_tests_impl<boost::unordered_set>();
-  equality_tests_impl<boost::unordered_multiset>();
+#ifndef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_multiset<int> int_multiset;
+
+  boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<int> >
+    int_multiset2;
+
+  boost::unordered_multiset<
+    test::minimal::copy_constructible_equality_comparable,
+    test::minimal::hash<test::minimal::copy_constructible_equality_comparable>,
+    test::minimal::equal_to<
+      test::minimal::copy_constructible_equality_comparable>,
+    test::minimal::allocator<value_type> >
+    multiset;
+
+  equality_test(int_multiset);
+  equality_test(int_multiset2);
+  equality_test(multiset);
 #endif
 }
 
-template <template <class T, class H = boost::hash<T>,
-  class P = std::equal_to<T>, class A = std::allocator<T> >
-  class Set>
-static void test1_unique_impl()
-{
-
+UNORDERED_AUTO_TEST (test1) {
   boost::hash<int> hash;
   std::equal_to<int> equal_to;
   int value = 0;
-  Set<int> set;
 
-  Set<int, boost::hash<int>, std::equal_to<int>,
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set." << std::endl;
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<int> set;
+
+  boost::unordered_flat_set<int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<int> >
     set2;
+#else
+  boost::unordered_set<int> set;
+
+  boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
+    test::minimal::cxx11_allocator<int> >
+    set2;
+#endif
 
   unordered_unique_test(set, value);
   unordered_set_test(set, value);
@@ -179,49 +211,27 @@ static void test1_unique_impl()
   unordered_unique_test(set2, value);
   unordered_set_test(set2, value);
   unordered_copyable_test(set2, value, value, hash, equal_to);
-}
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
-template <template <class T, class H = boost::hash<T>,
-  class P = std::equal_to<T>, class A = std::allocator<T> >
-  class Set>
-static void test1_equivalent_impl()
-{
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset." << std::endl;
 
-  boost::hash<int> hash;
-  std::equal_to<int> equal_to;
-  int value = 0;
-  Set<int> set;
+  boost::unordered_multiset<int> multiset;
 
-  Set<int, boost::hash<int>, std::equal_to<int>,
+  boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<int> >
-    set2;
+    multiset2;
 
-  unordered_equivalent_test(set, value);
-  unordered_set_test(set, value);
-  unordered_copyable_test(set, value, value, hash, equal_to);
+  unordered_equivalent_test(multiset, value);
+  unordered_set_test(multiset, value);
+  unordered_copyable_test(multiset, value, value, hash, equal_to);
 
-  unordered_equivalent_test(set2, value);
-  unordered_set_test(set2, value);
-  unordered_copyable_test(set2, value, value, hash, equal_to);
-}
-#endif
-
-UNORDERED_AUTO_TEST (test1) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  test1_unique_impl<boost::unordered_flat_set>();
-  test1_unique_impl<boost::unordered_node_set>();
-#else
-  test1_unique_impl<boost::unordered_set>();
-  test1_equivalent_impl<boost::unordered_multiset>();
+  unordered_equivalent_test(multiset2, value);
+  unordered_set_test(multiset2, value);
+  unordered_copyable_test(multiset2, value, value, hash, equal_to);
 #endif
 }
 
-template <template <class T, class H = boost::hash<T>,
-  class P = std::equal_to<T>, class A = std::allocator<T> >
-  class Set>
-static void test2_unique_impl()
-{
+UNORDERED_AUTO_TEST (test2) {
   test::minimal::constructor_param x;
 
   test::minimal::assignable assignable(x);
@@ -229,144 +239,155 @@ static void test2_unique_impl()
   test::minimal::hash<test::minimal::assignable> hash(x);
   test::minimal::equal_to<test::minimal::assignable> equal_to(x);
 
-  Set<test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >
     set;
+#else
+  boost::unordered_set<test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
+    test::minimal::equal_to<test::minimal::assignable>,
+    test::minimal::allocator<test::minimal::assignable> >
+    set;
+#endif
 
   unordered_unique_test(set, assignable);
   unordered_set_test(set, assignable);
   unordered_copyable_test(set, assignable, assignable, hash, equal_to);
   unordered_set_member_test(set, assignable);
-}
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
-template <template <class T, class H = boost::hash<T>,
-  class P = std::equal_to<T>, class A = std::allocator<T> >
-  class Set>
-static void test2_equivalent_impl()
-{
-  test::minimal::constructor_param x;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
-  test::minimal::assignable assignable(x);
-  test::minimal::copy_constructible copy_constructible(x);
-  test::minimal::hash<test::minimal::assignable> hash(x);
-  test::minimal::equal_to<test::minimal::assignable> equal_to(x);
-
-  Set<test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
+  boost::unordered_multiset<test::minimal::assignable,
+    test::minimal::hash<test::minimal::assignable>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >
-    set;
+    multiset;
 
-  unordered_equivalent_test(set, assignable);
-  unordered_set_test(set, assignable);
-  unordered_copyable_test(set, assignable, assignable, hash, equal_to);
-  unordered_set_member_test(set, assignable);
-}
-#endif
-
-UNORDERED_AUTO_TEST (test2) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  test2_unique_impl<boost::unordered_flat_set>();
-  test2_unique_impl<boost::unordered_node_set>();
-#else
-  test2_unique_impl<boost::unordered_set>();
-  test2_equivalent_impl<boost::unordered_multiset>();
+  unordered_equivalent_test(multiset, assignable);
+  unordered_set_test(multiset, assignable);
+  unordered_copyable_test(multiset, assignable, assignable, hash, equal_to);
+  unordered_set_member_test(multiset, assignable);
 #endif
 }
 
-template <template <class T, class H = boost::hash<T>,
-  class P = std::equal_to<T>, class A = std::allocator<T> >
-  class Set>
-static void movable1_tests_impl()
-{
+UNORDERED_AUTO_TEST (movable1_tests) {
   test::minimal::constructor_param x;
 
   test::minimal::movable1 movable1(x);
   test::minimal::hash<test::minimal::movable1> hash(x);
   test::minimal::equal_to<test::minimal::movable1> equal_to(x);
 
-  Set<test::minimal::movable1, test::minimal::hash<test::minimal::movable1>,
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<test::minimal::movable1,
+    test::minimal::hash<test::minimal::movable1>,
     test::minimal::equal_to<test::minimal::movable1>,
     test::minimal::allocator<test::minimal::movable1> >
     set;
+#else
+  boost::unordered_set<test::minimal::movable1,
+    test::minimal::hash<test::minimal::movable1>,
+    test::minimal::equal_to<test::minimal::movable1>,
+    test::minimal::allocator<test::minimal::movable1> >
+    set;
+#endif
 
-  // TODO: find out why Daniel had this commented out and if we need it and the
-  // corresponding equivalent impl
-  //
   // unordered_unique_test(set, movable1);
   unordered_set_test(set, movable1);
   unordered_movable_test(set, movable1, movable1, hash, equal_to);
-}
 
-UNORDERED_AUTO_TEST (movable1_tests) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  movable1_tests_impl<boost::unordered_flat_set>();
-  movable1_tests_impl<boost::unordered_node_set>();
-#else
-  movable1_tests_impl<boost::unordered_set>();
-  movable1_tests_impl<boost::unordered_multiset>();
+#ifndef BOOST_UNORDERED_FOA_TESTS
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+
+  boost::unordered_multiset<test::minimal::movable1,
+    test::minimal::hash<test::minimal::movable1>,
+    test::minimal::equal_to<test::minimal::movable1>,
+    test::minimal::allocator<test::minimal::movable1> >
+    multiset;
+
+  // unordered_equivalent_test(multiset, movable1);
+  unordered_set_test(multiset, movable1);
+  unordered_movable_test(multiset, movable1, movable1, hash, equal_to);
 #endif
 }
 
-template <template <class T, class H = boost::hash<T>,
-  class P = std::equal_to<T>, class A = std::allocator<T> >
-  class Set>
-static void movable2_tests_impl()
-{
+UNORDERED_AUTO_TEST (movable2_tests) {
   test::minimal::constructor_param x;
 
   test::minimal::movable2 movable2(x);
   test::minimal::hash<test::minimal::movable2> hash(x);
   test::minimal::equal_to<test::minimal::movable2> equal_to(x);
 
-  Set<test::minimal::movable2, test::minimal::hash<test::minimal::movable2>,
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<test::minimal::movable2,
+    test::minimal::hash<test::minimal::movable2>,
     test::minimal::equal_to<test::minimal::movable2>,
     test::minimal::allocator<test::minimal::movable2> >
     set;
+#else
+  boost::unordered_set<test::minimal::movable2,
+    test::minimal::hash<test::minimal::movable2>,
+    test::minimal::equal_to<test::minimal::movable2>,
+    test::minimal::allocator<test::minimal::movable2> >
+    set;
+#endif
 
   // unordered_unique_test(set, movable2);
   unordered_set_test(set, movable2);
   unordered_movable_test(set, movable2, movable2, hash, equal_to);
-}
 
-UNORDERED_AUTO_TEST (movable2_tests) {
+#ifndef BOOST_UNORDERED_FOA_TESTS
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  movable2_tests_impl<boost::unordered_flat_set>();
-  movable2_tests_impl<boost::unordered_node_set>();
-#else
-  movable2_tests_impl<boost::unordered_set>();
-  movable2_tests_impl<boost::unordered_multiset>();
+  boost::unordered_multiset<test::minimal::movable2,
+    test::minimal::hash<test::minimal::movable2>,
+    test::minimal::equal_to<test::minimal::movable2>,
+    test::minimal::allocator<test::minimal::movable2> >
+    multiset;
+
+  // unordered_equivalent_test(multiset, movable2);
+  unordered_set_test(multiset, movable2);
+  unordered_movable_test(multiset, movable2, movable2, hash, equal_to);
 #endif
 }
 
-template <template <class T, class H = boost::hash<T>,
-  class P = std::equal_to<T>, class A = std::allocator<T> >
-  class Set>
-static void destructible_tests_impl()
-{
+UNORDERED_AUTO_TEST (destructible_tests) {
   test::minimal::constructor_param x;
 
   test::minimal::destructible destructible(x);
   test::minimal::hash<test::minimal::destructible> hash(x);
   test::minimal::equal_to<test::minimal::destructible> equal_to(x);
 
-  Set<test::minimal::destructible,
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<test::minimal::destructible,
     test::minimal::hash<test::minimal::destructible>,
     test::minimal::equal_to<test::minimal::destructible> >
     set;
+#else
+  boost::unordered_set<test::minimal::destructible,
+    test::minimal::hash<test::minimal::destructible>,
+    test::minimal::equal_to<test::minimal::destructible> >
+    set;
+#endif
 
   unordered_destructible_test(set);
-}
 
-UNORDERED_AUTO_TEST (destructible_tests) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  destructible_tests_impl<boost::unordered_flat_set>();
-  destructible_tests_impl<boost::unordered_node_set>();
-#else
-  destructible_tests_impl<boost::unordered_set>();
-  destructible_tests_impl<boost::unordered_multiset>();
+#ifndef BOOST_UNORDERED_FOA_TESTS
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+
+  boost::unordered_multiset<test::minimal::destructible,
+    test::minimal::hash<test::minimal::destructible>,
+    test::minimal::equal_to<test::minimal::destructible> >
+    multiset;
+
+  unordered_destructible_test(multiset);
 #endif
 }
 
@@ -389,17 +410,9 @@ bool operator==(lwg2059_key x, lwg2059_key y) { return x.value == y.value; }
 
 UNORDERED_AUTO_TEST (lwg2059) {
 #ifdef BOOST_UNORDERED_FOA_TESTS
-  {
-    boost::unordered_flat_set<lwg2059_key> x;
-    x.emplace(lwg2059_key(10));
-    x.erase(x.begin());
-  }
-
-  {
-    boost::unordered_node_set<lwg2059_key> x;
-    x.emplace(lwg2059_key(10));
-    x.erase(x.begin());
-  }
+  boost::unordered_flat_set<lwg2059_key> x;
+  x.emplace(lwg2059_key(10));
+  x.erase(x.begin());
 #else
   {
     boost::unordered_set<lwg2059_key> x;

test/unordered/constructor_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2010 Daniel James.
-// Copyright (C) 2022-2023 Christian Mazakas
+// 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)
 
@@ -655,27 +655,23 @@ namespace constructor_tests {
 
   boost::unordered_flat_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-  boost::unordered_node_set<test::object, test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_node_set;
   boost::unordered_flat_map<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_map;
-  boost::unordered_node_map<test::object, test::object, test::hash,
-    test::equal_to, test::allocator2<test::object> >* test_node_map;
 
   UNORDERED_TEST(constructor_tests1,
-    ((test_map_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_map_std_alloc)(test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(constructor_tests2,
-    ((test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(map_constructor_test,
-    ((test_map_std_alloc)(test_map)(test_node_map))(
+    ((test_map_std_alloc)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(no_alloc_default_construct_test,
-    ((test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 #else
   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
@@ -713,8 +709,6 @@ namespace constructor_tests {
     std::initializer_list<int> init;
 #ifdef BOOST_UNORDERED_FOA_TESTS
     boost::unordered_flat_set<int> x1 = init;
-    boost::unordered_node_set<int> x2 = init;
-    BOOST_TEST(x2.empty());
 #else
     boost::unordered_set<int> x1 = init;
 #endif
@@ -728,9 +722,6 @@ namespace constructor_tests {
   UNORDERED_AUTO_TEST (test_initializer_list) {
 #ifdef BOOST_UNORDERED_FOA_TESTS
     boost::unordered_flat_set<int> x1 = {2, 10, 45, -5};
-    boost::unordered_node_set<int> x2 = {2, 10, 45, -5};
-    BOOST_TEST(x2.find(10) != x2.end());
-    BOOST_TEST(x2.find(46) == x2.end());
 #else
     boost::unordered_set<int> x1 = {2, 10, 45, -5};
 #endif

test/unordered/contains_tests.cpp

@@ -1,4 +1,4 @@
-// Copyright 2021-2023 Christian Mazakas.
+// Copyright 2021-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)
 
@@ -137,24 +137,6 @@ void test_map()
 
   typedef boost::unordered_flat_map<key, int, hasher, key_equal>
     non_transparent_map3;
-
-  typedef boost::unordered_node_map<key, int, transparent_hasher,
-    transparent_key_equal>
-    transparent_node_map;
-
-  typedef boost::unordered_node_map<key, int, transparent_hasher, key_equal>
-    non_transparent_node_map1;
-
-  typedef boost::unordered_node_map<key, int, hasher, transparent_key_equal>
-    non_transparent_node_map2;
-
-  typedef boost::unordered_node_map<key, int, hasher, key_equal>
-    non_transparent_node_map3;
-
-  test_map_transparent_contains<transparent_node_map>();
-  test_map_non_transparent_contains<non_transparent_node_map1>();
-  test_map_non_transparent_contains<non_transparent_node_map2>();
-  test_map_non_transparent_contains<non_transparent_node_map3>();
 #else
   typedef boost::unordered_map<key, int, transparent_hasher,
     transparent_key_equal>
@@ -272,22 +254,6 @@ void test_set()
     non_transparent_set2;
   typedef boost::unordered_flat_set<key, hasher, key_equal>
     non_transparent_set3;
-
-  typedef boost::unordered_node_set<key, transparent_hasher,
-    transparent_key_equal>
-    transparent_node_set;
-
-  typedef boost::unordered_node_set<key, transparent_hasher, key_equal>
-    non_transparent_node_set1;
-  typedef boost::unordered_node_set<key, hasher, transparent_key_equal>
-    non_transparent_node_set2;
-  typedef boost::unordered_node_set<key, hasher, key_equal>
-    non_transparent_node_set3;
-
-  test_set_transparent_contains<transparent_node_set>();
-  test_set_non_transparent_contains<non_transparent_node_set1>();
-  test_set_non_transparent_contains<non_transparent_node_set2>();
-  test_set_non_transparent_contains<non_transparent_node_set3>();
 #else
   typedef boost::unordered_set<key, transparent_hasher, transparent_key_equal>
     transparent_set;

test/unordered/copy_tests.cpp

@@ -1,18 +1,18 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright (C) 2022-2023 Christian Mazakas
+// 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)
 
 #include "../helpers/unordered.hpp"
 
+#include "../helpers/test.hpp"
+#include "../objects/test.hpp"
+#include "../objects/cxx11_allocator.hpp"
+#include "../helpers/random_values.hpp"
+#include "../helpers/tracker.hpp"
 #include "../helpers/equivalent.hpp"
 #include "../helpers/invariants.hpp"
-#include "../helpers/random_values.hpp"
-#include "../helpers/test.hpp"
-#include "../helpers/tracker.hpp"
-#include "../objects/cxx11_allocator.hpp"
-#include "../objects/test.hpp"
 
 test::seed_t initialize_seed(9063);
 
@@ -225,227 +225,11 @@ namespace copy_tests {
     }
   }
 
-  template <class T>
-  void copy_construct_tests_std_allocator1(
-    T*, test::random_generator const& generator)
-  {
-    typename T::hasher hf;
-    typename T::key_equal eq;
-    typename T::allocator_type al;
-
-    {
-      test::check_instances check_;
-
-      T x;
-      T y(x);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      T x(0);
-      T y(x);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v(1000, generator);
-
-      T x(v.begin(), v.end());
-      T y(x);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      // In this test I drop the original containers max load factor, so it
-      // is much lower than the load factor. The hash table is not allowed
-      // to rehash, but the destination container should probably allocate
-      // enough buckets to decrease the load factor appropriately.
-      test::random_values<T> v(1000, generator);
-      T x(v.begin(), v.end());
-      x.max_load_factor(x.load_factor() / 4);
-      T y(x);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      // This isn't guaranteed:
-      BOOST_TEST(y.load_factor() < y.max_load_factor());
-      test::check_equivalent_keys(y);
-    }
-  }
-
-  template <class T>
-  void copy_construct_tests_std_allocator2(
-    T*, test::random_generator const& generator)
-  {
-    typename T::hasher hf(1);
-    typename T::key_equal eq(1);
-    typename T::allocator_type al;
-
-    {
-      test::check_instances check_;
-
-      T x(0, hf, eq, al);
-      T y(x);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      T x(10000, hf, eq, al);
-      T y(x);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      T x(0, hf, eq, al);
-      T y(x, al);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      T x(1000, hf, eq, al);
-      T y(x, al);
-      BOOST_TEST(y.empty());
-      BOOST_TEST(test::equivalent(y.hash_function(), hf));
-      BOOST_TEST(test::equivalent(y.key_eq(), eq));
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(x.max_load_factor() == y.max_load_factor());
-      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-      test::check_equivalent_keys(y);
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v;
-
-      T x(v.begin(), v.end(), 0, hf, eq, al);
-      T y(x);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v(1000, generator);
-
-      T x(v.begin(), v.end(), 0, hf, eq, al);
-      T y(x);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v;
-
-      T x(v.begin(), v.end(), 0, hf, eq, al);
-      T y(x, al);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-      BOOST_TEST(test::detail::tracker.count_allocations == 0);
-    }
-
-    {
-      test::check_instances check_;
-
-      test::random_values<T> v(500, generator);
-
-      T x(v.begin(), v.end(), 0, hf, eq, al);
-      T y(x, al);
-      test::unordered_equivalence_tester<T> equivalent(x);
-      BOOST_TEST(equivalent(y));
-      test::check_equivalent_keys(y);
-      BOOST_TEST(test::selected_count(y.get_allocator()) == 0);
-      BOOST_TEST(test::equivalent(y.get_allocator(), al));
-    }
-  }
-
   using test::default_generator;
   using test::generate_collisions;
   using test::limited_range;
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
-  template <class T> struct allocator
-  {
-    using value_type = T;
-
-    allocator() = default;
-    allocator(allocator const&) = default;
-    allocator(allocator&&) = default;
-
-    template <class U> allocator(allocator<U> const&) {}
-
-    T* allocate(std::size_t n)
-    {
-      return static_cast<T*>(::operator new(sizeof(value_type) * n));
-    }
-
-    void deallocate(T* p, std::size_t) { ::operator delete(p); }
-
-    friend inline bool operator==(allocator const&, allocator const&)
-    {
-      return true;
-    }
-
-    friend inline bool operator!=(allocator const&, allocator const&)
-    {
-      return false;
-    }
-  };
-
   boost::unordered_flat_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
   boost::unordered_flat_map<test::object, test::object, test::hash,
@@ -465,101 +249,13 @@ namespace copy_tests {
     test::equal_to, test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_map_no_select_copy;
 
-  boost::unordered_flat_set<int, test::hash, test::equal_to,
-    test::allocator1<int> >* test_set_trivially_copyable;
-  boost::unordered_flat_map<int, int, test::hash, test::equal_to,
-    test::allocator1<std::pair<int const, int> > >* test_map_trivially_copyable;
-
-  boost::unordered_flat_set<int, test::hash, test::equal_to,
-    std::allocator<int> >* test_set_trivially_copyable_std_allocator;
-  boost::unordered_flat_map<int, int, test::hash, test::equal_to,
-    std::allocator<std::pair<int const, int> > >*
-    test_map_trivially_copyable_std_allocator;
-
-  boost::unordered_flat_set<int, test::hash, test::equal_to, allocator<int> >*
-    test_set_trivially_copyable_no_construct;
-  boost::unordered_flat_map<int, int, test::hash, test::equal_to,
-    allocator<std::pair<int const, int> > >*
-    test_map_trivially_copyable_no_construct;
-
-  boost::unordered_node_set<test::object, test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_node_set;
-  boost::unordered_node_map<test::object, test::object, test::hash,
-    test::equal_to, test::allocator1<test::object> >* test_node_map;
-
-  boost::unordered_node_set<test::object, test::hash, test::equal_to,
-    test::cxx11_allocator<test::object, test::select_copy> >*
-    test_node_set_select_copy;
-  boost::unordered_node_map<test::object, test::object, test::hash,
-    test::equal_to, test::cxx11_allocator<test::object, test::select_copy> >*
-    test_node_map_select_copy;
-
-  boost::unordered_node_set<test::object, test::hash, test::equal_to,
-    test::cxx11_allocator<test::object, test::no_select_copy> >*
-    test_node_set_no_select_copy;
-  boost::unordered_node_map<test::object, test::object, test::hash,
-    test::equal_to, test::cxx11_allocator<test::object, test::no_select_copy> >*
-    test_node_map_no_select_copy;
-
-  boost::unordered_node_set<int, test::hash, test::equal_to,
-    test::allocator1<int> >* test_node_set_trivially_copyable;
-  boost::unordered_node_map<int, int, test::hash, test::equal_to,
-    test::allocator1<std::pair<int const, int> > >*
-    test_node_map_trivially_copyable;
-
-  boost::unordered_node_set<int, test::hash, test::equal_to,
-    std::allocator<int> >* test_node_set_trivially_copyable_std_allocator;
-  boost::unordered_node_map<int, int, test::hash, test::equal_to,
-    std::allocator<std::pair<int const, int> > >*
-    test_node_map_trivially_copyable_std_allocator;
-
-  boost::unordered_node_set<int, test::hash, test::equal_to, allocator<int> >*
-    test_node_set_trivially_copyable_no_construct;
-  boost::unordered_node_map<int, int, test::hash, test::equal_to,
-    allocator<std::pair<int const, int> > >*
-    test_node_map_trivially_copyable_no_construct;
-
-  // clang-format off
   UNORDERED_TEST(copy_construct_tests1,
-    ((test_set)(test_map)(test_set_select_copy)(test_map_select_copy)
-     (test_set_no_select_copy)(test_map_no_select_copy)
-     (test_set_trivially_copyable)(test_map_trivially_copyable)
-     (test_node_set)(test_node_map)(test_node_set_select_copy)(test_node_map_select_copy)
-     (test_node_set_no_select_copy)(test_node_map_no_select_copy)
-     (test_node_set_trivially_copyable)(test_node_map_trivially_copyable))
-    ((default_generator)(generate_collisions)(limited_range)))
+    ((test_set)(test_map)(test_set_select_copy)(test_map_select_copy)(test_set_no_select_copy)(test_map_no_select_copy))(
+      (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(copy_construct_tests2,
-    ((test_set)(test_map)(test_set_select_copy)(test_map_select_copy)
-     (test_set_no_select_copy)(test_map_no_select_copy)
-     (test_set_trivially_copyable)(test_map_trivially_copyable)
-     (test_node_set)(test_node_map)(test_node_set_select_copy)(test_node_map_select_copy)
-     (test_node_set_no_select_copy)(test_node_map_no_select_copy)
-     (test_node_set_trivially_copyable)(test_node_map_trivially_copyable))
-    ((default_generator)(generate_collisions)(limited_range)))
-
-  UNORDERED_TEST(copy_construct_tests_std_allocator1,
-    ((test_set_trivially_copyable_std_allocator)
-     (test_map_trivially_copyable_std_allocator)
-     (test_set_trivially_copyable_no_construct)
-     (test_map_trivially_copyable_no_construct)
-     (test_node_set_trivially_copyable_std_allocator)
-     (test_node_map_trivially_copyable_std_allocator)
-     (test_node_set_trivially_copyable_no_construct)
-     (test_node_map_trivially_copyable_no_construct))
-    ((default_generator)(generate_collisions)(limited_range)))
-
-  UNORDERED_TEST(copy_construct_tests_std_allocator2,
-    ((test_set_trivially_copyable_std_allocator)
-     (test_map_trivially_copyable_std_allocator)
-     (test_set_trivially_copyable_no_construct)
-     (test_map_trivially_copyable_no_construct)
-     (test_node_set_trivially_copyable_std_allocator)
-     (test_node_map_trivially_copyable_std_allocator)
-     (test_node_set_trivially_copyable_no_construct)
-     (test_node_map_trivially_copyable_no_construct))
-    ((default_generator)(generate_collisions)(limited_range)))
-  // clang-format on
+    ((test_set)(test_map)(test_set_select_copy)(test_map_select_copy)(test_set_no_select_copy)(test_map_no_select_copy))(
+      (default_generator)(generate_collisions)(limited_range)))
 #else
   boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
@@ -596,23 +292,13 @@ namespace copy_tests {
     test::equal_to, test::cxx11_allocator<test::object, test::no_select_copy> >*
     test_multimap_no_select_copy;
 
-  // clang-format off
   UNORDERED_TEST(copy_construct_tests1,
-    ((test_set)(test_multiset)(test_map)(test_multimap)
-     (test_set_select_copy)(test_multiset_select_copy)
-     (test_map_select_copy)(test_multimap_select_copy)
-     (test_set_no_select_copy)(test_multiset_no_select_copy)
-     (test_map_no_select_copy)(test_multimap_no_select_copy))(
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_select_copy)(test_multiset_select_copy)(test_map_select_copy)(test_multimap_select_copy)(test_set_no_select_copy)(test_multiset_no_select_copy)(test_map_no_select_copy)(test_multimap_no_select_copy))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(copy_construct_tests2,
-    ((test_set)(test_multiset)(test_map)(test_multimap)
-     (test_set_select_copy)(test_multiset_select_copy)
-     (test_map_select_copy)(test_multimap_select_copy)
-     (test_set_no_select_copy)(test_multiset_no_select_copy)
-     (test_map_no_select_copy)(test_multimap_no_select_copy))(
+    ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_select_copy)(test_multiset_select_copy)(test_map_select_copy)(test_multimap_select_copy)(test_set_no_select_copy)(test_multiset_no_select_copy)(test_map_no_select_copy)(test_multimap_no_select_copy))(
       (default_generator)(generate_collisions)(limited_range)))
-  // clang-format on
 #endif
 } // namespace copy_tests
 

test/unordered/emplace_tests.cpp

@@ -179,13 +179,18 @@ namespace emplace_tests {
 
   };
 
-  template <class X> static void emplace_set(X*)
-  {
+  UNORDERED_AUTO_TEST (emplace_set) {
     test::check_instances check_;
 
-    typedef X container;
-
-    typedef typename container::iterator iterator;
+#ifdef BOOST_UNORDERED_FOA_TESTS
+    typedef boost::unordered_flat_set<emplace_value,
+      boost::hash<emplace_value> >
+      container;
+#else
+    typedef boost::unordered_set<emplace_value, boost::hash<emplace_value> >
+      container;
+#endif
+    typedef container::iterator iterator;
     typedef std::pair<iterator, bool> return_type;
     container x(10);
     iterator i1;
@@ -220,7 +225,7 @@ namespace emplace_tests {
     BOOST_TEST(r1.first == x.find(v2));
     BOOST_TEST_EQ(check_.instances(), 4);
 #ifdef BOOST_UNORDERED_FOA_TESTS
-    BOOST_TEST_EQ(check_.constructions(), 6);
+  BOOST_TEST_EQ(check_.constructions(), 6);
 #else
     BOOST_TEST_EQ(check_.constructions(), 4);
 #endif
@@ -289,21 +294,6 @@ namespace emplace_tests {
     BOOST_TEST(x.count(v4) == 1);
   }
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  static boost::unordered_flat_set<emplace_value, boost::hash<emplace_value> >*
-    test_set;
-
-  static boost::unordered_node_set<emplace_value, boost::hash<emplace_value> >*
-    test_node_set;
-
-  UNORDERED_TEST(emplace_set, ((test_set)(test_node_set)))
-#else
-  static boost::unordered_set<emplace_value, boost::hash<emplace_value> >*
-    test_set;
-
-  UNORDERED_TEST(emplace_set, ((test_set)))
-#endif
-
 #ifndef BOOST_UNORDERED_FOA_TESTS
   UNORDERED_AUTO_TEST (emplace_multiset) {
     test::check_instances check_;
@@ -384,12 +374,18 @@ namespace emplace_tests {
   }
 #endif
 
-  template <class X> static void emplace_map(X*)
-  {
+  UNORDERED_AUTO_TEST (emplace_map) {
     test::check_instances check_;
-
-    typedef X container;
-    typedef typename container::iterator iterator;
+#ifdef BOOST_UNORDERED_FOA_TESTS
+    typedef boost::unordered_flat_map<emplace_value, emplace_value,
+      boost::hash<emplace_value> >
+      container;
+#else
+    typedef boost::unordered_map<emplace_value, emplace_value,
+      boost::hash<emplace_value> >
+      container;
+#endif
+    typedef container::iterator iterator;
     typedef std::pair<iterator, bool> return_type;
     container x(10);
     return_type r1, r2;
@@ -397,9 +393,7 @@ namespace emplace_tests {
 #ifdef BOOST_UNORDERED_FOA_TESTS
     // 5/8 args + duplicate
     emplace_value k1(5, "", 'b', 4, 5);
-    BOOST_TEST_EQ(check_.constructions(), 1);
     emplace_value m1(8, "xxx", 'z', 4, 5, 6, 7, 8);
-    BOOST_TEST_EQ(check_.constructions(), 2);
     r1 = x.emplace(std::piecewise_construct, std::make_tuple(5, "", 'b', 4, 5),
       std::make_tuple(8, "xxx", 'z', 4, 5, 6, 7, 8));
     BOOST_TEST_EQ(x.size(), 1u);
@@ -491,18 +485,18 @@ namespace emplace_tests {
     BOOST_TEST_EQ(check_.instances(), 8);
     BOOST_TEST_EQ(check_.constructions(), 10);
 
-    BOOST_TEST(r1.first == x.emplace_hint(r1.first,
-                             boost::unordered::piecewise_construct,
-                             boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                             boost::make_tuple(15, "jkjk")));
-    BOOST_TEST(r1.first == x.emplace_hint(r2.first,
-                             boost::unordered::piecewise_construct,
-                             boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                             boost::make_tuple(275, "xxx", 'm', 6)));
-    BOOST_TEST(
-      r1.first == x.emplace_hint(x.end(), boost::unordered::piecewise_construct,
-                    boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
-                    boost::make_tuple(-10, "blah blah", '\0')));
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(r1.first, boost::unordered::piecewise_construct,
+                 boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+                 boost::make_tuple(15, "jkjk")));
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(r2.first, boost::unordered::piecewise_construct,
+                 boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+                 boost::make_tuple(275, "xxx", 'm', 6)));
+    BOOST_TEST(r1.first ==
+               x.emplace_hint(x.end(), boost::unordered::piecewise_construct,
+                 boost::make_tuple(9, "", 'b', 4, 5, 6, 7, 8, 9),
+                 boost::make_tuple(-10, "blah blah", '\0')));
     BOOST_TEST_EQ(x.size(), 2u);
     BOOST_TEST(x.find(k2)->second == m2);
     BOOST_TEST_EQ(check_.instances(), 8);
@@ -510,21 +504,6 @@ namespace emplace_tests {
 #endif
   }
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  static boost::unordered_flat_map<emplace_value, emplace_value,
-    boost::hash<emplace_value> >* test_map;
-
-  static boost::unordered_node_map<emplace_value, emplace_value,
-    boost::hash<emplace_value> >* test_node_map;
-
-  UNORDERED_TEST(emplace_map, ((test_map)(test_node_map)))
-#else
-  static boost::unordered_map<emplace_value, emplace_value,
-    boost::hash<emplace_value> >* test_map;
-
-  UNORDERED_TEST(emplace_map, ((test_map)))
-#endif
-
 #ifndef BOOST_UNORDERED_FOA_TESTS
   UNORDERED_AUTO_TEST (emplace_multimap) {
     test::check_instances check_;
@@ -592,13 +571,14 @@ namespace emplace_tests {
   }
 #endif
 
-  template <class X> static void try_emplace(X*)
-  {
+  UNORDERED_AUTO_TEST (try_emplace) {
     test::check_instances check_;
-
-    typedef X container;
-
-    typedef typename container::iterator iterator;
+#ifdef BOOST_UNORDERED_FOA_TESTS
+    typedef boost::unordered_flat_map<int, emplace_value> container;
+#else
+    typedef boost::unordered_map<int, emplace_value> container;
+#endif
+    typedef container::iterator iterator;
     typedef std::pair<iterator, bool> return_type;
     container x(10);
     return_type r1, r2, r3;
@@ -635,22 +615,12 @@ namespace emplace_tests {
     BOOST_TEST_EQ(check_.constructions(), 4);
 
     BOOST_TEST(r2.first == x.try_emplace(r2.first, k2, 808709, "what"));
-    BOOST_TEST(r2.first == x.try_emplace(r2.first, k2, 10, "xxx", 'a', 4, 5, 6,
-                             7, 8, 9, 10));
+    BOOST_TEST(
+      r2.first ==
+      x.try_emplace(r2.first, k2, 10, "xxx", 'a', 4, 5, 6, 7, 8, 9, 10));
     BOOST_TEST(r2.first->second == m2);
     BOOST_TEST_EQ(x.size(), 2u);
   }
-
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  static boost::unordered_flat_map<int, emplace_value>* test_int_map;
-  static boost::unordered_node_map<int, emplace_value>* test_int_node_map;
-
-  UNORDERED_TEST(try_emplace, ((test_int_map)(test_int_node_map)))
-#else
-  static boost::unordered_map<int, emplace_value>* test_int_map;
-
-  UNORDERED_TEST(try_emplace, ((test_int_map)))
-#endif
 }
 
 RUN_TESTS()

test/unordered/equality_tests.cpp

@@ -1,18 +1,14 @@
 
 // Copyright 2008-2009 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 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)
 
 #include "../helpers/unordered.hpp"
 
-#include "../helpers/test.hpp"
 #include <boost/preprocessor/seq.hpp>
 #include <list>
-
-// TODO: this test needs to be someday cleaned up to not be so heavily
-// macro-generated
-//
+#include "../helpers/test.hpp"
 
 namespace equality_tests {
   struct mod_compare
@@ -37,12 +33,6 @@ namespace equality_tests {
   using boost_unordered_map =
     boost::unordered_flat_map<int, int, mod_compare, mod_compare>;
 
-  using boost_unordered_node_set =
-    boost::unordered_node_set<int, mod_compare, mod_compare>;
-
-  using boost_unordered_node_map =
-    boost::unordered_node_map<int, int, mod_compare, mod_compare>;
-
 #define UNORDERED_EQUALITY_MULTISET_TEST(seq1, op, seq2)                       \
   {                                                                            \
   }
@@ -74,46 +64,14 @@ namespace equality_tests {
   }
 #endif
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
 #define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                            \
   {                                                                            \
-    boost_unordered_set set1, set2;                                            \
-    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)                    \
-    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)                    \
-    BOOST_TEST(set1 op set2);                                                  \
-  }                                                                            \
-  {                                                                            \
-    boost_unordered_node_set set1, set2;                                       \
+    boost_unordered_set set1, set2;            \
     BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)                    \
     BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)                    \
     BOOST_TEST(set1 op set2);                                                  \
   }
-#else
-#define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                            \
-  {                                                                            \
-    boost_unordered_set set1, set2;                                            \
-    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set1, seq1)                    \
-    BOOST_PP_SEQ_FOR_EACH(UNORDERED_SET_INSERT, set2, seq2)                    \
-    BOOST_TEST(set1 op set2);                                                  \
-  }
-#endif
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-#define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                            \
-  {                                                                            \
-    boost_unordered_map map1, map2;                                            \
-    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)                    \
-    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                    \
-    BOOST_TEST(map1 op map2);                                                  \
-  }                                                                            \
-                                                                               \
-  {                                                                            \
-    boost_unordered_node_map map1, map2;                                       \
-    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map1, seq1)                    \
-    BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                    \
-    BOOST_TEST(map1 op map2);                                                  \
-  }
-#else
 #define UNORDERED_EQUALITY_MAP_TEST(seq1, op, seq2)                            \
   {                                                                            \
     boost_unordered_map map1, map2;                                            \
@@ -121,7 +79,6 @@ namespace equality_tests {
     BOOST_PP_SEQ_FOR_EACH(UNORDERED_MAP_INSERT, map2, seq2)                    \
     BOOST_TEST(map1 op map2);                                                  \
   }
-#endif
 
 #define UNORDERED_SET_INSERT(r, set, item) set.insert(item);
 #define UNORDERED_MAP_INSERT(r, map, item)                                     \
@@ -129,51 +86,10 @@ namespace equality_tests {
 
   UNORDERED_AUTO_TEST (equality_size_tests) {
 #ifdef BOOST_UNORDERED_FOA_TESTS
-    {
-      boost::unordered_flat_set<int> x1, x2;
-      BOOST_TEST(x1 == x2);
-      BOOST_TEST(!(x1 != x2));
-
-      x1.insert(1);
-      BOOST_TEST(x1 != x2);
-      BOOST_TEST(!(x1 == x2));
-      BOOST_TEST(x2 != x1);
-      BOOST_TEST(!(x2 == x1));
-
-      x2.insert(1);
-      BOOST_TEST(x1 == x2);
-      BOOST_TEST(!(x1 != x2));
-
-      x2.insert(2);
-      BOOST_TEST(x1 != x2);
-      BOOST_TEST(!(x1 == x2));
-      BOOST_TEST(x2 != x1);
-      BOOST_TEST(!(x2 == x1));
-    }
-
-    {
-      boost::unordered_node_set<int> x1, x2;
-      BOOST_TEST(x1 == x2);
-      BOOST_TEST(!(x1 != x2));
-
-      x1.insert(1);
-      BOOST_TEST(x1 != x2);
-      BOOST_TEST(!(x1 == x2));
-      BOOST_TEST(x2 != x1);
-      BOOST_TEST(!(x2 == x1));
-
-      x2.insert(1);
-      BOOST_TEST(x1 == x2);
-      BOOST_TEST(!(x1 != x2));
-
-      x2.insert(2);
-      BOOST_TEST(x1 != x2);
-      BOOST_TEST(!(x1 == x2));
-      BOOST_TEST(x2 != x1);
-      BOOST_TEST(!(x2 == x1));
-    }
+    boost::unordered_flat_set<int> x1, x2;
 #else
     boost::unordered_set<int> x1, x2;
+#endif
     BOOST_TEST(x1 == x2);
     BOOST_TEST(!(x1 != x2));
 
@@ -192,7 +108,6 @@ namespace equality_tests {
     BOOST_TEST(!(x1 == x2));
     BOOST_TEST(x2 != x1);
     BOOST_TEST(!(x2 == x1));
-#endif
   }
 
   UNORDERED_AUTO_TEST (equality_key_value_tests) {
@@ -241,45 +156,6 @@ namespace equality_tests {
   // different hash functions but the same equality predicate.
 
   UNORDERED_AUTO_TEST (equality_different_hash_test) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-    {
-      typedef boost_unordered_set set;
-      set set1(0, mod_compare(false), mod_compare(false));
-      set set2(0, mod_compare(true), mod_compare(true));
-      BOOST_TEST(set1 == set2);
-      set1.insert(1);
-      set2.insert(2);
-      BOOST_TEST(set1 != set2);
-      set1.insert(2);
-      set2.insert(1);
-      BOOST_TEST(set1 == set2);
-      set1.insert(10);
-      set2.insert(20);
-      BOOST_TEST(set1 != set2);
-      set1.insert(20);
-      set2.insert(10);
-      BOOST_TEST(set1 == set2);
-    }
-
-    {
-      typedef boost_unordered_node_set set;
-      set set1(0, mod_compare(false), mod_compare(false));
-      set set2(0, mod_compare(true), mod_compare(true));
-      BOOST_TEST(set1 == set2);
-      set1.insert(1);
-      set2.insert(2);
-      BOOST_TEST(set1 != set2);
-      set1.insert(2);
-      set2.insert(1);
-      BOOST_TEST(set1 == set2);
-      set1.insert(10);
-      set2.insert(20);
-      BOOST_TEST(set1 != set2);
-      set1.insert(20);
-      set2.insert(10);
-      BOOST_TEST(set1 == set2);
-    }
-#else
     typedef boost_unordered_set set;
     set set1(0, mod_compare(false), mod_compare(false));
     set set2(0, mod_compare(true), mod_compare(true));
@@ -296,8 +172,7 @@ namespace equality_tests {
     set1.insert(20);
     set2.insert(10);
     BOOST_TEST(set1 == set2);
-#endif
   }
-} // namespace equality_tests
+}
 
 RUN_TESTS()