Make typedef private and rename it so older versions of msvc don't erroneously treat the typedef like it's in scope when doing template instantiation

This reverts commit 9bc471310e.

.drone.jsonnet

@@ -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",
+        xcode_version = "13.4.1", osx_version = "monterey", arch = "arm64",
     ),
 
     windows_pipeline(

.github/workflows/ci.yml

@@ -72,7 +72,8 @@ 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, sanitize: yes }
+          - { compiler: clang,     cxxstd: '03,11,14,17,2a',    os: macos-11, }
+          - { compiler: clang,     cxxstd: '03,11,14,17,2a',    os: macos-12, sanitize: yes }
 
     timeout-minutes: 120
     runs-on: ${{matrix.os}}

.gitignore

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

benchmark/uint32.cpp

@@ -289,20 +289,8 @@ 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_flat_map_xmx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx2_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx3 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx3_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx2_mix>;
+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
 
@@ -327,12 +315,7 @@ int main()
 
     test<std_unordered_map>( "std::unordered_map" );
     test<boost_unordered_map>( "boost::unordered_map" );
-
-    test<boost_unordered_flat_map_xmx>( "boost::unordered_flat_map, xmx" );
-    test<boost_unordered_flat_map_xmx2>( "boost::unordered_flat_map, xmx2" );
-    test<boost_unordered_flat_map_xmx3>( "boost::unordered_flat_map, xmx3" );
-    test<boost_unordered_flat_map_mulx>( "boost::unordered_flat_map, mulx" );
-    test<boost_unordered_flat_map_mulx2>( "boost::unordered_flat_map, mulx2" );
+    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE
 
@@ -351,7 +334,7 @@ int main()
 
     for( auto const& x: times )
     {
-        std::cout << std::setw( 34 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
     }
 }
 

benchmark/uint64.cpp

@@ -289,20 +289,8 @@ 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_flat_map_xmx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx2_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx3 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx3_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx2_mix>;
+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
 
@@ -337,12 +325,7 @@ int main()
 #endif
 
     test<boost_unordered_map>( "boost::unordered_map" );
-
-    test<boost_unordered_flat_map_xmx>( "boost::unordered_flat_map, xmx" );
-    test<boost_unordered_flat_map_xmx2>( "boost::unordered_flat_map, xmx2" );
-    test<boost_unordered_flat_map_xmx3>( "boost::unordered_flat_map, xmx3" );
-    test<boost_unordered_flat_map_mulx>( "boost::unordered_flat_map, mulx" );
-    test<boost_unordered_flat_map_mulx2>( "boost::unordered_flat_map, mulx2" );
+    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE
 
@@ -361,7 +344,7 @@ int main()
 
     for( auto const& x: times )
     {
-        std::cout << std::setw( 34 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
     }
 }
 

benchmark/uuid.cpp

@@ -340,20 +340,8 @@ 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_flat_map_xmx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx2_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx3 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx3_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx2_mix>;
+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
 
@@ -378,12 +366,7 @@ int main()
 
     test<std_unordered_map>( "std::unordered_map" );
     test<boost_unordered_map>( "boost::unordered_map" );
-
-    test<boost_unordered_flat_map_xmx>( "boost::unordered_flat_map, xmx" );
-    test<boost_unordered_flat_map_xmx2>( "boost::unordered_flat_map, xmx2" );
-    test<boost_unordered_flat_map_xmx3>( "boost::unordered_flat_map, xmx3" );
-    test<boost_unordered_flat_map_mulx>( "boost::unordered_flat_map, mulx" );
-    test<boost_unordered_flat_map_mulx2>( "boost::unordered_flat_map, mulx2" );
+    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE
 
@@ -402,7 +385,7 @@ int main()
 
     for( auto const& x: times )
     {
-        std::cout << std::setw( 34 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
     }
 }
 

benchmark/word_size.cpp

@@ -181,20 +181,8 @@ 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_flat_map_xmx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx2_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_xmx3 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::xmx3_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx_mix>;
-
-template<class K, class V> using boost_unordered_flat_map_mulx2 =
-    boost::unordered_flat_map<K, V, boost::hash<K>, std::equal_to<K>, allocator_for<K, V>, boost::unordered::detail::foa::mulx2_mix>;
+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
 
@@ -219,12 +207,7 @@ int main()
 
     test<std_unordered_map>( "std::unordered_map" );
     test<boost_unordered_map>( "boost::unordered_map" );
-
-    test<boost_unordered_flat_map_xmx>( "boost::unordered_flat_map, xmx" );
-    test<boost_unordered_flat_map_xmx2>( "boost::unordered_flat_map, xmx2" );
-    test<boost_unordered_flat_map_xmx3>( "boost::unordered_flat_map, xmx3" );
-    test<boost_unordered_flat_map_mulx>( "boost::unordered_flat_map, mulx" );
-    test<boost_unordered_flat_map_mulx2>( "boost::unordered_flat_map, mulx2" );
+    test<boost_unordered_flat_map>( "boost::unordered_flat_map" );
 
 #ifdef HAVE_ANKERL_UNORDERED_DENSE
 
@@ -243,7 +226,7 @@ int main()
 
     for( auto const& x: times )
     {
-        std::cout << std::setw( 34 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
+        std::cout << std::setw( 30 ) << ( x.label_ + ": " ) << std::setw( 5 ) << x.time_ << " ms, " << std::setw( 9 ) << x.bytes_ << " bytes in " << x.count_ << " allocations\n";
     }
 }
 

doc/unordered/changes.adoc

@@ -6,6 +6,11 @@
 :github-pr-url: https://github.com/boostorg/unordered/pull
 :cpp: C++
 
+== Release 1.82.0
+
+* Extended heterogeneous lookup to more member functions as specified in
+  https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2363r3.html[P2363].
+
 == Release 1.81.0 - Major update
 
 * Added fast containers `boost::unordered_flat_map` and `boost::unordered_flat_set`

doc/unordered/unordered_flat_map.adoc

@@ -134,23 +134,31 @@ namespace boost {
       std::pair<iterator, bool> xref:#unordered_flat_map_try_emplace[try_emplace](const key_type& k, Args&&... args);
     template<class... Args>
       std::pair<iterator, bool> xref:#unordered_flat_map_try_emplace[try_emplace](key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      std::pair<iterator, bool> xref:#unordered_flat_map_try_emplace[try_emplace](K&& k, Args&&... args);
     template<class... Args>
       iterator xref:#unordered_flat_map_try_emplace_with_hint[try_emplace](const_iterator hint, const key_type& k, Args&&... args);
     template<class... Args>
       iterator xref:#unordered_flat_map_try_emplace_with_hint[try_emplace](const_iterator hint, key_type&& k, Args&&... args);
+    template<class K, class... Args>
+      iterator xref:#unordered_flat_map_try_emplace_with_hint[try_emplace](const_iterator hint, K&& k, Args&&... args);
     template<class M>
       std::pair<iterator, bool> xref:#unordered_flat_map_insert_or_assign[insert_or_assign](const key_type& k, M&& obj);
     template<class M>
       std::pair<iterator, bool> xref:#unordered_flat_map_insert_or_assign[insert_or_assign](key_type&& k, M&& obj);
+    template<class K, class M>
+      std::pair<iterator, bool> xref:#unordered_flat_map_insert_or_assign[insert_or_assign](K&& k, M&& obj);
     template<class M>
       iterator xref:#unordered_flat_map_insert_or_assign_with_hint[insert_or_assign](const_iterator hint, const key_type& k, M&& obj);
     template<class M>
       iterator xref:#unordered_flat_map_insert_or_assign_with_hint[insert_or_assign](const_iterator hint, key_type&& k, M&& obj);
+    template<class K, class M>
+      iterator xref:#unordered_flat_map_insert_or_assign_with_hint[insert_or_assign](const_iterator hint, K&& k, M&& obj);
 
     void      xref:#unordered_flat_map_erase_by_position[erase](iterator position);
     void      xref:#unordered_flat_map_erase_by_position[erase](const_iterator position);
     size_type xref:#unordered_flat_map_erase_by_key[erase](const key_type& k);
-    template<class K> size_type xref:#unordered_flat_map_transparent_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_flat_map_erase_by_key[erase](K&& k);
     iterator  xref:#unordered_flat_map_erase_range[erase](const_iterator first, const_iterator last);
     void      xref:#unordered_flat_map_swap[swap](unordered_flat_map& other)
       noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
@@ -189,8 +197,11 @@ namespace boost {
     // element access
     mapped_type& xref:#unordered_flat_map_operator[operator[+]+](const key_type& k);
     mapped_type& xref:#unordered_flat_map_operator[operator[+]+](key_type&& k);
+    template<class K> mapped_type& xref:#unordered_flat_map_operator[operator[+]+](K&& k);
     mapped_type& xref:#unordered_flat_map_at[at](const key_type& k);
     const mapped_type& xref:#unordered_flat_map_at[at](const key_type& k) const;
+    template<class K> mapped_type& xref:#unordered_flat_map_at[at](const K& k);
+    template<class K> const mapped_type& xref:#unordered_flat_map_at[at](const K& k) const;
 
     // bucket interface
     size_type xref:#unordered_flat_map_bucket_count[bucket_count]() const noexcept;
@@ -860,6 +871,8 @@ template<class... Args>
   std::pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
 template<class... Args>
   std::pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
+template<class K, class... Args>
+  std::pair<iterator, bool> try_emplace(K&& k, Args&&... args);
 ```
 
 Inserts a new node into the container if there is no existing element with key `k` contained within it.
@@ -876,15 +889,23 @@ if there is an element with an equivalent key; otherwise, the construction is of
 +
 --
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<Args>(args)...))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<Args>(args)...))
 ```
 
 unlike xref:#unordered_flat_map_emplace[emplace], which simply forwards all arguments to ``value_type``'s constructor.
 
 Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load.
 
+The `template <class K, class... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
 --
 
 ---
@@ -895,6 +916,8 @@ template<class... Args>
   iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
 template<class... Args>
   iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
+template<class K, class... Args>
+  iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
 ```
 
 Inserts a new node into the container if there is no existing element with key `k` contained within it.
@@ -911,15 +934,23 @@ if there is an element with an equivalent key; otherwise, the construction is of
 +
 --
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<Args>(args)...))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<Args>(args)...))
 ```
 
 unlike xref:#unordered_flat_map_emplace_hint[emplace_hint], which simply forwards all arguments to ``value_type``'s constructor.
 
 Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load.
 
+The `template <class K, class... Args>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
 --
 
 ---
@@ -930,6 +961,8 @@ template<class M>
   std::pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
 template<class M>
   std::pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
+template<class K, class M>
+  std::pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
 ```
 
 Inserts a new element into the container or updates an existing one by assigning to the contained value.
@@ -938,9 +971,15 @@ If there is an element with key `k`, then it is updated by assigning `boost::for
 
 If there is no such element, it is added to the container as:
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<M>(obj)))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<M>(obj)))
 ```
 
 [horizontal]
@@ -948,7 +987,9 @@ Returns:;; The `bool` component of the return type is `true` if an insert took p
 +
 If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
 Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
-Notes:;; Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load. +
+Notes:;; Can invalidate iterators pointers and references, but only if the insert causes the load to be greater than the maximum load.  +
++
+The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -958,6 +999,8 @@ template<class M>
   iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
 template<class M>
   iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
+template<class K, class M>
+  iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
 ```
 
 Inserts a new element into the container or updates an existing one by assigning to the contained value.
@@ -966,9 +1009,15 @@ If there is an element with key `k`, then it is updated by assigning `boost::for
 
 If there is no such element, it is added to the container as:
 ```c++
+// first two overloads
 value_type(std::piecewise_construct,
            std::forward_as_tuple(boost::forward<Key>(k)),
            std::forward_as_tuple(boost::forward<M>(obj)))
+
+// third overload
+value_type(std::piecewise_construct,
+           std::forward_as_tuple(boost::forward<K>(k)),
+           std::forward_as_tuple(boost::forward<M>(obj)))
 ```
 
 `hint` is a suggestion to where the element should be inserted. This implementation ignores it.
@@ -976,7 +1025,9 @@ value_type(std::piecewise_construct,
 [horizontal]
 Returns:;; If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
 Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
-Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. +
++
+The `template<class K, class M>` only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -998,28 +1049,15 @@ Throws:;; Nothing.
 ==== Erase by Key
 ```c++
 size_type erase(const key_type& k);
-```
-
-Erase all elements with key equivalent to `k`.
-
-[horizontal]
-Returns:;; The number of elements erased.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-
----
-
-==== Transparent Erase by Key
-```c++
 template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; The number of elements erased.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1172,13 +1210,16 @@ Notes:;; The `template <typename K>` overloads only participate in overload reso
 ```c++
 mapped_type& operator[](const key_type& k);
 mapped_type& operator[](key_type&& k);
+template<class K> mapped_type& operator[](K&& k);
 ```
 
 [horizontal]
 Effects:;; If the container does not already contain an element with a key equivalent to `k`, inserts the value `std::pair<key_type const, mapped_type>(k, mapped_type())`.
 Returns:;; A reference to `x.second` where `x` is the element already in the container, or the newly inserted element with a key equivalent to `k`.
 Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
-Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. +
++
+The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 
@@ -1186,11 +1227,14 @@ Notes:;; Can invalidate iterators, pointers and references, but only if the inse
 ```c++
 mapped_type& at(const key_type& k);
 const mapped_type& at(const key_type& k) const;
+template<class K> mapped_type& at(const K& k);
+template<class K> const mapped_type& at(const K& k) const;
 ```
 
 [horizontal]
 Returns:;; A reference to `x.second` where `x` is the (unique) element whose key is equivalent to `k`.
 Throws:;; An exception object of type `std::out_of_range` if no such element is present.
+Notes:;; The `template<class K>` overloads only participate in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 

doc/unordered/unordered_flat_set.adoc

@@ -116,15 +116,17 @@ namespace boost {
     template<class... Args> iterator xref:#unordered_flat_set_emplace_hint[emplace_hint](const_iterator position, Args&&... args);
     std::pair<iterator, bool> xref:#unordered_flat_set_copy_insert[insert](const value_type& obj);
     std::pair<iterator, bool> xref:#unordered_flat_set_move_insert[insert](value_type&& obj);
-    iterator       xref:#unordered_flat_set_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
-    iterator       xref:#unordered_flat_set_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
+    template<class K> std::pair<iterator, bool> xref:#unordered_flat_set_transparent_insert[insert](K&& k);
+    iterator xref:#unordered_flat_set_copy_insert_with_hint[insert](const_iterator hint, const value_type& obj);
+    iterator xref:#unordered_flat_set_move_insert_with_hint[insert](const_iterator hint, value_type&& obj);
+    template<class K> iterator xref:#unordered_flat_set_transparent_insert_with_hint[insert](const_iterator hint, K&& k);
     template<class InputIterator> void xref:#unordered_flat_set_insert_iterator_range[insert](InputIterator first, InputIterator last);
     void xref:#unordered_flat_set_insert_initializer_list[insert](std::initializer_list<value_type>);
 
     void      xref:#unordered_flat_set_erase_by_position[erase](iterator position);
     void      xref:#unordered_flat_set_erase_by_position[erase](const_iterator position);
     size_type xref:#unordered_flat_set_erase_by_key[erase](const key_type& k);
-    template<class K> size_type xref:#unordered_flat_set_transparent_erase_by_key[erase](K&& k);
+    template<class K> size_type xref:#unordered_flat_set_erase_by_key[erase](K&& k);
     iterator  xref:#unordered_flat_set_erase_range[erase](const_iterator first, const_iterator last);
     void      xref:#unordered_flat_set_swap[swap](unordered_flat_set& other)
       noexcept(boost::allocator_traits<Allocator>::is_always_equal::value ||
@@ -736,6 +738,25 @@ Notes:;; Can invalidate iterators, pointers and references, but only if the inse
 
 ---
 
+==== Transparent Insert
+```c++
+template<class K> std::pair<iterator, bool> insert(K&& k);
+```
+
+Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container with an equivalent key.
+
+[horizontal]
+Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`.
+Returns:;; The bool component of the return type is true if an insert took place. +
++
+If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
+Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. +
++
+This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
+---
+
 ==== Copy Insert with Hint
 ```c++
 iterator insert(const_iterator hint, const value_type& obj);
@@ -773,6 +794,27 @@ Notes:;; Can invalidate iterators, pointers and references, but only if the inse
 
 ---
 
+==== Transparent Insert with Hint
+```c++
+template<class K> std::pair<iterator, bool> insert(const_iterator hint, K&& k);
+```
+
+Inserts an element constructed from `std::forward<K>(k)` in the container if and only if there is no element in the container with an equivalent key.
+
+`hint` is a suggestion to where the element should be inserted. This implementation ignores it.
+
+[horizontal]
+Requires:;; `value_type` is https://en.cppreference.com/w/cpp/named_req/EmplaceConstructible[EmplaceConstructible^] from `k`.
+Returns:;; The bool component of the return type is true if an insert took place. +
++
+If an insert took place, then the iterator points to the newly inserted element. Otherwise, it points to the element with equivalent key.
+Throws:;; If an exception is thrown by an operation other than a call to `hasher` the function has no effect.
+Notes:;; Can invalidate iterators, pointers and references, but only if the insert causes the load to be greater than the maximum load. +
++
+This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
+
+---
+
 ==== Insert Iterator Range
 ```c++
 template<class InputIterator> void insert(InputIterator first, InputIterator last);
@@ -818,28 +860,15 @@ Throws:;; Nothing.
 ==== Erase by Key
 ```c++
 size_type erase(const key_type& k);
-```
-
-Erase all elements with key equivalent to `k`.
-
-[horizontal]
-Returns:;; The number of elements erased.
-Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
-
----
-
-==== Transparent Erase by Key
-```c++
 template<class K> size_type erase(K&& k);
 ```
 
 Erase all elements with key equivalent to `k`.
 
-This overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
-
 [horizontal]
 Returns:;; The number of elements erased.
 Throws:;; Only throws an exception if it is thrown by `hasher` or `key_equal`.
+Notes:;; The `template<class K>` overload only participates in overload resolution if `Hash::is_transparent` and `Pred::is_transparent` are valid member typedefs and neither `iterator` nor `const_iterator` are implicitly convertible from `K`. The library assumes that `Hash` is callable with both `K` and `Key` and that `Pred` is transparent. This enables heterogeneous lookup which avoids the cost of instantiating an instance of the `Key` type.
 
 ---
 

doc/unordered/unordered_map.adoc

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

doc/unordered/unordered_multimap.adoc

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

doc/unordered/unordered_multiset.adoc

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

doc/unordered/unordered_set.adoc

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

include/boost/unordered/detail/foa.hpp

@@ -1,6 +1,6 @@
 /* Fast open-addressing hash table.
  *
- * Copyright 2022 Joaquin M Lopez Munoz.
+ * Copyright 2022-2023 Joaquin M Lopez Munoz.
  * Distributed under the Boost Software License, Version 1.0.
  * (See accompanying file LICENSE_1_0.txt or copy at
  * http://www.boost.org/LICENSE_1_0.txt)
@@ -11,6 +11,8 @@
 #ifndef BOOST_UNORDERED_DETAIL_FOA_HPP
 #define BOOST_UNORDERED_DETAIL_FOA_HPP
 
+#include <iostream>
+
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
@@ -23,6 +25,7 @@
 #include <boost/predef.h>
 #include <boost/type_traits/has_trivial_copy.hpp>
 #include <boost/type_traits/is_nothrow_swappable.hpp>
+#include <boost/unordered/detail/narrow_cast.hpp>
 #include <boost/unordered/detail/xmx.hpp>
 #include <boost/unordered/detail/mulx.hpp>
 #include <boost/unordered/hash_traits.hpp>
@@ -270,20 +273,12 @@ private:
       0xF8F8F8F8u,0xF9F9F9F9u,0xFAFAFAFAu,0xFBFBFBFBu,0xFCFCFCFCu,0xFDFDFDFDu,0xFEFEFEFEu,0xFFFFFFFFu,
     };
 
-#if defined(__MSVC_RUNTIME_CHECKS)
-    return (int)word[hash&0xffu];
-#else
-    return (int)word[(unsigned char)hash];
-#endif
+    return (int)word[narrow_cast<unsigned char>(hash)];
   }
 
   inline static unsigned char reduced_hash(std::size_t hash)
   {
-#if defined(__MSVC_RUNTIME_CHECKS)
-    return match_word(hash)&0xffu;
-#else
-    return (unsigned char)match_word(hash);
-#endif
+    return narrow_cast<unsigned char>(match_word(hash));
   }
 
   inline unsigned char& at(std::size_t pos)
@@ -352,8 +347,8 @@ struct group15
 
   inline int match(std::size_t hash)const
   {
-    return simde_mm_movemask_epi8(
-      vceqq_s8(m,vdupq_n_s8(reduced_hash(hash))))&0x7FFF;
+    return simde_mm_movemask_epi8(vceqq_s8(
+      m,vdupq_n_s8(static_cast<signed char>(reduced_hash(hash)))))&0x7FFF;
   }
 
   inline bool is_not_overflowed(std::size_t hash)const
@@ -534,11 +529,7 @@ struct group15
     std::size_t     pos=reinterpret_cast<uintptr_t>(pc)%sizeof(group15);
     group15        *pg=reinterpret_cast<group15*>(pc-pos);
     boost::uint64_t x=((pg->m[0])>>pos)&0x000100010001ull;
-#if defined(__MSVC_RUNTIME_CHECKS)
-    boost::uint32_t y=(x|(x>>15)|(x>>30))&0xffffffffu;
-#else
-    boost::uint32_t y=static_cast<boost::uint32_t>(x|(x>>15)|(x>>30));
-#endif
+    boost::uint32_t y=narrow_cast<boost::uint32_t>(x|(x>>15)|(x>>30));
     return !pg->is_not_overflowed(y);
   };
 
@@ -553,11 +544,7 @@ struct group15
   inline int match_occupied()const
   {
     boost::uint64_t x=m[0]|m[1];
-#if defined(__MSVC_RUNTIME_CHECKS)
-    boost::uint32_t y=(x|(x>>32))&0xffffffffu;
-#else
-    boost::uint32_t y=static_cast<boost::uint32_t>(x|(x>>32));
-#endif
+    boost::uint32_t y=narrow_cast<boost::uint32_t>(x|(x>>32));
     y|=y>>16;
     return y&0x7FFF;
   }
@@ -592,11 +579,7 @@ private:
       240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,
     };
     
-#if defined(__MSVC_RUNTIME_CHECKS)
-  return table[hash&0xffu];
-#else
-    return table[(unsigned char)hash];
-#endif
+    return table[narrow_cast<unsigned char>(hash)];
   }
 
   inline void set_impl(std::size_t pos,std::size_t n)
@@ -745,9 +728,11 @@ private:
   std::size_t pos,step=0;
 };
 
-/* Mixing policies: no_mix is the identity function and xmx_mix uses the
- * xmx function defined in <boost/unordered/detail/xmx.hpp>.
- * foa::table mixes hash results with xmx_mix unless the hash is marked as
+/* Mixing policies: no_mix is the identity function, xmx_mix uses the
+ * xmx function defined in <boost/unordered/detail/xmx.hpp>, and mulx_mix
+ * uses the mulx function from <boost/unordered/detail/mulx.hpp>.
+ *
+ * foa::table mixes hash results with mulx_mix unless the hash is marked as
  * avalanching, i.e. of good quality (see <boost/unordered/hash_traits.hpp>).
  */
 
@@ -769,24 +754,6 @@ struct xmx_mix
   }
 };
 
-struct xmx2_mix
-{
-  template<typename Hash,typename T>
-  static inline std::size_t mix(const Hash& h,const T& x)
-  {
-    return xmx2(h(x));
-  }
-};
-
-struct xmx3_mix
-{
-  template<typename Hash,typename T>
-  static inline std::size_t mix(const Hash& h,const T& x)
-  {
-    return xmx3(h(x));
-  }
-};
-
 struct mulx_mix
 {
   template<typename Hash,typename T>
@@ -796,15 +763,6 @@ struct mulx_mix
   }
 };
 
-struct mulx2_mix
-{
-  template<typename Hash,typename T>
-  static inline std::size_t mix(const Hash& h,const T& x)
-  {
-    return mulx2(h(x));
-  }
-};
-
 /* boost::core::countr_zero has a potentially costly check for
  * the case x==0.
  */
@@ -821,7 +779,7 @@ inline unsigned int unchecked_countr_zero(int x)
 #endif
 }
 
-template<typename,typename,typename,typename,typename>
+template<typename,typename,typename,typename>
 class table;
 
 /* table_iterator keeps two pointers:
@@ -849,12 +807,15 @@ class table;
 /* internal conversion from const_iterator to iterator */
 class const_iterator_cast_tag {}; 
 
-template<typename Value,typename Group,bool Const>
+template<typename TypePolicy,typename Group,bool Const>
 class table_iterator
 {
+  using type_policy=TypePolicy;
+  using table_element_type=typename type_policy::element_type;
+
 public:
   using difference_type=std::ptrdiff_t;
-  using value_type=Value;
+  using value_type=typename type_policy::value_type;
   using pointer=
     typename std::conditional<Const,value_type const*,value_type*>::type;
   using reference=
@@ -865,14 +826,15 @@ public:
 
   table_iterator()=default;
   template<bool Const2,typename std::enable_if<!Const2>::type* =nullptr>
-  table_iterator(const table_iterator<Value,Group,Const2>& x):
+  table_iterator(const table_iterator<TypePolicy,Group,Const2>& x):
     pc{x.pc},p{x.p}{}
   table_iterator(
-    const_iterator_cast_tag, const table_iterator<Value,Group,true>& x):
+    const_iterator_cast_tag, const table_iterator<TypePolicy,Group,true>& x):
     pc{x.pc},p{x.p}{}
 
-  inline reference operator*()const noexcept{return *p;}
-  inline pointer operator->()const noexcept{return p;}
+  inline reference operator*()const noexcept{return type_policy::value_from(*p);}
+  inline pointer operator->()const noexcept
+    {return std::addressof(type_policy::value_from(*p));}
   inline table_iterator& operator++()noexcept{increment();return *this;}
   inline table_iterator operator++(int)noexcept
     {auto x=*this;increment();return x;}
@@ -885,11 +847,11 @@ public:
 
 private:
   template<typename,typename,bool> friend class table_iterator;
-  template<typename,typename,typename,typename,typename> friend class table;
+  template<typename,typename,typename,typename> friend class table;
 
-  table_iterator(Group* pg,std::size_t n,const Value* p_):
+  table_iterator(Group* pg,std::size_t n,const table_element_type* p_):
     pc{reinterpret_cast<unsigned char*>(const_cast<Group*>(pg))+n},
-    p{const_cast<Value*>(p_)}
+    p{const_cast<table_element_type*>(p_)}
     {}
 
   inline std::size_t rebase() noexcept
@@ -923,8 +885,8 @@ private:
     }
   }
 
-  unsigned char *pc=nullptr;
-  Value         *p=nullptr;
+  unsigned char      *pc=nullptr;
+  table_element_type *p=nullptr;
 };
 
 /* table_arrays controls allocation, initialization and deallocation of
@@ -965,7 +927,10 @@ struct table_arrays
   template<typename Allocator>
   static table_arrays new_(Allocator& al,std::size_t n)
   {
-    using alloc_traits=boost::allocator_traits<Allocator>;
+    // using alloc_traits=boost::allocator_traits<Allocator>;
+    using storage_allocator=
+      typename boost::allocator_rebind<Allocator, Value>::type;
+    using storage_traits=boost::allocator_traits<storage_allocator>;
 
     auto         groups_size_index=size_index_for<group_type,size_policy>(n);
     auto         groups_size=size_policy::size(groups_size_index);
@@ -975,8 +940,9 @@ struct table_arrays
       arrays.groups=dummy_groups<group_type,size_policy::min_size()>();
     }
     else{
-      arrays.elements=
-        boost::to_address(alloc_traits::allocate(al,buffer_size(groups_size)));
+      auto sal=storage_allocator(al);
+      arrays.elements=boost::to_address(
+        storage_traits::allocate(sal,buffer_size(groups_size)));
       
       /* Align arrays.groups to sizeof(group_type). table_iterator critically
        * depends on such alignment for its increment operation.
@@ -1000,13 +966,15 @@ struct table_arrays
   template<typename Allocator>
   static void delete_(Allocator& al,table_arrays& arrays)noexcept
   {
-    using alloc_traits=boost::allocator_traits<Allocator>;
+    using storage_alloc=typename boost::allocator_rebind<Allocator,Value>::type;
+    using alloc_traits=boost::allocator_traits<storage_alloc>;
     using pointer=typename alloc_traits::pointer;
     using pointer_traits=boost::pointer_traits<pointer>;
 
+    auto sal=storage_alloc(al);
     if(arrays.elements){
       alloc_traits::deallocate(
-        al,pointer_traits::pointer_to(*arrays.elements),
+        sal,pointer_traits::pointer_to(*arrays.elements),
         buffer_size(arrays.groups_size_mask+1));
     }
   }
@@ -1190,7 +1158,7 @@ _STL_RESTORE_DEPRECATED_WARNING
  */
 constexpr static float const mlf = 0.875f;
 
-template<typename TypePolicy,typename Hash,typename Pred,typename Allocator,typename MixPolicy=xmx_mix>
+template<typename TypePolicy,typename Hash,typename Pred,typename Allocator>
 class 
 
 #if defined(_MSC_VER)&&_MSC_FULL_VER>=190023918
@@ -1210,7 +1178,7 @@ table:empty_value<Hash,0>,empty_value<Pred,1>,empty_value<Allocator,2>
   using mix_policy=typename std::conditional<
     hash_is_avalanching<Hash>::value,
     no_mix,
-    MixPolicy
+    mulx_mix
   >::type;
   using alloc_traits=boost::allocator_traits<Allocator>;
 
@@ -1218,6 +1186,7 @@ public:
   using key_type=typename type_policy::key_type;
   using init_type=typename type_policy::init_type;
   using value_type=typename type_policy::value_type;
+  using element_type=typename type_policy::element_type;
 
 private:
   static constexpr bool has_mutable_iterator=
@@ -1233,10 +1202,10 @@ public:
   using const_reference=const value_type&;
   using size_type=std::size_t;
   using difference_type=std::ptrdiff_t;
-  using const_iterator=table_iterator<value_type,group_type,true>;
+  using const_iterator=table_iterator<type_policy,group_type,true>;
   using iterator=typename std::conditional<
     has_mutable_iterator,
-    table_iterator<value_type,group_type,false>,
+    table_iterator<type_policy,group_type,false>,
     const_iterator>::type;
 
   table(
@@ -1287,15 +1256,15 @@ public:
       /* This works because subsequent x.clear() does not depend on the
        * elements' values.
        */
-      x.for_all_elements([this](value_type* p){
-        unchecked_insert(type_policy::move(*p));
+      x.for_all_elements([this](element_type* p){
+        unchecked_insert(type_policy::move(type_policy::value_from(*p)));
       });
     }
   }
 
   ~table()noexcept
   {
-    for_all_elements([this](value_type* p){
+    for_all_elements([this](element_type* p){
       destroy_element(p);
     });
     delete_arrays(arrays);
@@ -1384,8 +1353,8 @@ public:
         /* This works because subsequent x.clear() does not depend on the
          * elements' values.
          */
-        x.for_all_elements([this](value_type* p){
-          unchecked_insert(type_policy::move(*p));
+        x.for_all_elements([this](element_type* p){
+          unchecked_insert(type_policy::move(type_policy::value_from(*p)));
         });
       }
     }
@@ -1419,14 +1388,18 @@ public:
   template<typename... Args>
   BOOST_FORCEINLINE std::pair<iterator,bool> emplace(Args&&... args)
   {
-    using emplace_type = typename std::conditional<
+    /* We dispatch based on whether or not the value_type is constructible from
+     * an rvalue refernce to the deduced emplace_type. We do this specifically
+     * for the csae of the node-based containers. To this end, we're able to
+     * avoid allocating a node when a duplicate element is attempted to be
+     * inserted. For immovable types, we instead dispatch to the routine that
+     * unconditionally allocates via `type_policy::construct()`.
+     */
+    return emplace_dispatch(
       std::is_constructible<
-        init_type, Args...
-      >::value,
-      init_type,
-      value_type
-    >::type;
-    return emplace_impl(emplace_type(std::forward<Args>(args)...));
+        value_type,
+        emplace_type<Args...>&&>{},
+      std::forward<Args>(args)...);
   }
 
   template<typename Key,typename... Args>
@@ -1453,6 +1426,14 @@ public:
   BOOST_FORCEINLINE std::pair<iterator,bool>
   insert(value_type&& x){return emplace_impl(std::move(x));}
 
+  template<typename T=element_type>
+  BOOST_FORCEINLINE
+  typename std::enable_if<
+    !std::is_same<T,value_type>::value,
+    std::pair<iterator,bool>
+  >::type
+  insert(element_type&& x){return emplace_impl(std::move(x));}
+
   template<
     bool dependent_value=false,
     typename std::enable_if<
@@ -1527,14 +1508,21 @@ public:
     }
   }
 
+  element_type extract(const_iterator pos)
+  {
+    BOOST_ASSERT(pos!=end());
+    erase_on_exit e{*this,iterator{const_iterator_cast_tag{},pos}};
+    (void)e;
+    return std::move(*pos.p);
+  }
+
   // TODO: should we accept different allocator too?
   template<typename Hash2,typename Pred2>
   void merge(table<TypePolicy,Hash2,Pred2,Allocator>& x)
   {
-    x.for_all_elements([&,this](group_type* pg,unsigned int n,value_type* p){
-      if(emplace_impl(type_policy::move(*p)).second){
-        x.erase(iterator{pg,n,p});
-      }
+    x.for_all_elements([&,this](group_type* pg,unsigned int n,element_type* p){
+      erase_on_exit e{x,{pg,n,p}};
+      if(!emplace_impl(type_policy::move(*p)).second)e.rollback();
     });
   }
 
@@ -1593,8 +1581,17 @@ public:
   }
 
 private:
-  template<typename,typename,typename,typename,typename> friend class table;
-  using arrays_type=table_arrays<value_type,group_type,size_policy>;
+  template<typename,typename,typename,typename> friend class table;
+  using arrays_type=table_arrays<element_type,group_type,size_policy>;
+
+  template<typename... Args>
+  using emplace_type = typename std::conditional<
+      std::is_constructible<
+        init_type,Args...
+      >::value,
+      init_type,
+      value_type
+    >::type;
 
   struct clear_on_exit
   {
@@ -1602,6 +1599,18 @@ private:
     table& x;
   };
 
+  struct erase_on_exit
+  {
+    erase_on_exit(table& x_,iterator it_):x{x_},it{it_}{}
+    ~erase_on_exit(){if(!rollback_)x.erase(it);}
+
+    void rollback(){rollback_=true;}
+
+    table&   x;
+    iterator it;
+    bool     rollback_=false;
+  };
+
   Hash&            h(){return hash_base::get();}
   const Hash&      h()const{return hash_base::get();}
   Pred&            pred(){return pred_base::get();}
@@ -1620,13 +1629,13 @@ private:
   }
 
   template<typename... Args>
-  void construct_element(value_type* p,Args&&... args)
+  void construct_element(element_type* p,Args&&... args)
   {
-    alloc_traits::construct(al(),p,std::forward<Args>(args)...);
+    type_policy::construct(al(),p,std::forward<Args>(args)...);
   }
 
   template<typename... Args>
-  void construct_element(value_type* p,try_emplace_args_t,Args&&... args)
+  void construct_element(element_type* p,try_emplace_args_t,Args&&... args)
   {
     construct_element_from_try_emplace_args(
       p,
@@ -1636,9 +1645,9 @@ private:
 
   template<typename Key,typename... Args>
   void construct_element_from_try_emplace_args(
-    value_type* p,std::false_type,Key&& x,Args&&... args)
+    element_type* p,std::false_type,Key&& x,Args&&... args)
   {
-    alloc_traits::construct(
+    type_policy::construct(
       al(),p,
       std::piecewise_construct,
       std::forward_as_tuple(std::forward<Key>(x)),
@@ -1651,21 +1660,21 @@ private:
 
   template<typename Key>
   void construct_element_from_try_emplace_args(
-    value_type* p,std::true_type,Key&& x)
+    element_type* p,std::true_type,Key&& x)
   {
-    alloc_traits::construct(al(),p,std::forward<Key>(x));
+    type_policy::construct(al(),p,std::forward<Key>(x));
   }
 
-  void destroy_element(value_type* p)noexcept
+  void destroy_element(element_type* p)noexcept
   {
-    alloc_traits::destroy(al(),p);
+    type_policy::destroy(al(),p);
   }
 
   struct destroy_element_on_exit
   {
     ~destroy_element_on_exit(){this_->destroy_element(p);}
-    table      *this_;
-    value_type *p;
+    table        *this_;
+    element_type *p;
   };
 
   void copy_elements_from(const table& x)
@@ -1676,7 +1685,7 @@ private:
       fast_copy_elements_from(x);
     }
     else{
-      x.for_all_elements([this](const value_type* p){
+      x.for_all_elements([this](const element_type* p){
         unchecked_insert(*p);
       });
     }
@@ -1701,9 +1710,9 @@ private:
         bool,
 #if BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION,<50000)
         /* std::is_trivially_copy_constructible not provided */
-        boost::has_trivial_copy<value_type>::value
+        boost::has_trivial_copy<element_type>::value
 #else
-        std::is_trivially_copy_constructible<value_type>::value
+        std::is_trivially_copy_constructible<element_type>::value
 #endif
         &&(
           is_std_allocator<Allocator>::value||
@@ -1727,14 +1736,14 @@ private:
   {
     std::size_t num_constructed=0;
     BOOST_TRY{
-      x.for_all_elements([&,this](const value_type* p){
+      x.for_all_elements([&,this](const element_type* p){
         construct_element(arrays.elements+(p-x.arrays.elements),*p);
         ++num_constructed;
       });
     }
     BOOST_CATCH(...){
       if(num_constructed){
-        x.for_all_elements_while([&,this](const value_type* p){
+        x.for_all_elements_while([&,this](const element_type* p){
           destroy_element(arrays.elements+(p-x.arrays.elements));
           return --num_constructed!=0;
         });
@@ -1804,7 +1813,7 @@ private:
     return size_policy::position(hash,arrays_.groups_size_index);
   }
 
-  static inline void prefetch_elements(const value_type* p)
+  static inline void prefetch_elements(const element_type* p)
   {
     /* We have experimentally confirmed that ARM architectures get a higher
      * speedup when around the first half of the element slots in a group are
@@ -1842,6 +1851,7 @@ private:
       auto pg=arrays.groups+pos;
       auto mask=pg->match(hash);
       if(mask){
+        BOOST_UNORDERED_ASSUME(arrays.elements != nullptr);
         auto p=arrays.elements+pos*N;
         prefetch_elements(p);
         do{
@@ -1864,6 +1874,29 @@ private:
 #pragma warning(pop) /* C4800 */
 #endif
 
+  template<typename... Args>
+  BOOST_FORCEINLINE std::pair<iterator,bool> emplace_dispatch(
+    std::true_type,Args&&... args
+  ) {
+    using emplace_type_t = emplace_type<Args...>;
+    return emplace_impl(emplace_type_t(std::forward<Args>(args)...));
+  }
+
+  template<typename... Args>
+  BOOST_FORCEINLINE std::pair<iterator,bool> emplace_dispatch(
+    std::false_type,Args&&... args
+  ) {
+    alignas(element_type)
+    unsigned char buf[sizeof(element_type)];
+    element_type* p = reinterpret_cast<element_type*>(buf);
+
+    type_policy::construct(al(),p,std::forward<Args>(args)...);
+    destroy_element_on_exit d{this,p};
+    (void)d;
+
+    return emplace_impl(type_policy::move(*p));
+  }
+
   template<typename... Args>
   BOOST_FORCEINLINE std::pair<iterator,bool> emplace_impl(Args&&... args)
   {
@@ -1939,20 +1972,20 @@ private:
   {
     std::size_t num_destroyed=0;
     BOOST_TRY{
-      for_all_elements([&,this](value_type* p){
+      for_all_elements([&,this](element_type* p){
         nosize_transfer_element(p,new_arrays_,num_destroyed);
       });
     }
     BOOST_CATCH(...){
       if(num_destroyed){
         for_all_elements_while(
-          [&,this](group_type* pg,unsigned int n,value_type*){
+          [&,this](group_type* pg,unsigned int n,element_type*){
             recover_slot(pg,n);
             return --num_destroyed!=0;
           }
         );
       }
-      for_all_elements(new_arrays_,[this](value_type* p){
+      for_all_elements(new_arrays_,[this](element_type* p){
         destroy_element(p);
       });
       delete_arrays(new_arrays_);
@@ -1963,7 +1996,7 @@ private:
     /* either all moved and destroyed or all copied */
     BOOST_ASSERT(num_destroyed==size()||num_destroyed==0);
     if(num_destroyed!=size()){
-      for_all_elements([this](value_type* p){
+      for_all_elements([this](element_type* p){
         destroy_element(p);
       });
     }
@@ -1998,18 +2031,19 @@ private:
   }
 
   void nosize_transfer_element(
-    value_type* p,const arrays_type& arrays_,std::size_t& num_destroyed)
+    element_type* p,const arrays_type& arrays_,std::size_t& num_destroyed)
   {
     nosize_transfer_element(
       p,hash_for(key_from(*p)),arrays_,num_destroyed,
       std::integral_constant< /* std::move_if_noexcept semantics */
         bool,
         std::is_nothrow_move_constructible<init_type>::value||
-        !std::is_copy_constructible<init_type>::value>{});
+        !std::is_same<element_type,value_type>::value||
+        !std::is_copy_constructible<element_type>::value>{});
   }
 
   void nosize_transfer_element(
-    value_type* p,std::size_t hash,const arrays_type& arrays_,
+    element_type* p,std::size_t hash,const arrays_type& arrays_,
     std::size_t& num_destroyed,std::true_type /* ->move */)
   {
     /* Destroy p even if an an exception is thrown in the middle of move
@@ -2023,12 +2057,12 @@ private:
   }
 
   void nosize_transfer_element(
-    value_type* p,std::size_t hash,const arrays_type& arrays_,
+    element_type* p,std::size_t hash,const arrays_type& arrays_,
     std::size_t& /*num_destroyed*/,std::false_type /* ->copy */)
   {
     nosize_unchecked_emplace_at(
       arrays_,position_for(hash,arrays_),hash,
-      const_cast<const value_type&>(*p));
+      const_cast<const element_type&>(*p));
   }
 
   template<typename... Args>
@@ -2065,8 +2099,8 @@ private:
   std::size_t erase_if_impl(Predicate pr)
   {
     std::size_t s=size();
-    for_all_elements([&,this](group_type* pg,unsigned int n,value_type* p){
-      if(pr(*p)) erase(iterator{pg,n,p});
+    for_all_elements([&,this](group_type* pg,unsigned int n,element_type* p){
+      if(pr(type_policy::value_from(*p))) erase(iterator{pg,n,p});
     });
     return std::size_t(s-size());
   }
@@ -2081,7 +2115,7 @@ private:
   static auto for_all_elements(const arrays_type& arrays_,F f)
     ->decltype(f(nullptr),void())
   {
-    for_all_elements_while(arrays_,[&](value_type* p){f(p);return true;});
+    for_all_elements_while(arrays_,[&](element_type* p){f(p);return true;});
   }
 
   template<typename F>
@@ -2089,7 +2123,7 @@ private:
     ->decltype(f(nullptr,0,nullptr),void())
   {
     for_all_elements_while(
-      arrays_,[&](group_type* pg,unsigned int n,value_type* p)
+      arrays_,[&](group_type* pg,unsigned int n,element_type* p)
         {f(pg,n,p);return true;});
   }
 
@@ -2104,7 +2138,7 @@ private:
     ->decltype(f(nullptr),void())
   {
     for_all_elements_while(
-      arrays_,[&](group_type*,unsigned int,value_type* p){return f(p);});
+      arrays_,[&](group_type*,unsigned int,element_type* p){return f(p);});
   }
 
   template<typename F>

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

@@ -0,0 +1,196 @@
+/* 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;
+    node_value_type* p_=nullptr;
+    BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS opt_storage<Allocator> a_;
+
+  protected:
+    node_value_type& element()noexcept
+    {
+      BOOST_ASSERT(!empty());
+      return *p_;
+    }
+
+    node_value_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(node_value_type* p,Allocator a)
+    {
+      BOOST_ASSERT(empty());
+      p_=p;
+      new(&a_.t_)Allocator(a);
+    }
+
+    void emplace(element_type&& x,Allocator a)
+    {
+      emplace(x.p,a);
+      x.p=nullptr;
+    }
+
+    void clear()
+    {
+      al().~Allocator();
+      p_=nullptr;
+    }
+
+  public:
+    constexpr node_handle_base()noexcept{}
+
+    node_handle_base(node_handle_base&& nh) noexcept
+    {
+      if (!nh.empty()){
+        emplace(nh.p_,nh.al());
+        nh.clear();
+      }
+    }
+
+    node_handle_base& operator=(node_handle_base&& nh)noexcept
+    {
+      bool const pocma=
+        boost::allocator_propagate_on_container_move_assignment<
+          Allocator>::type::value;
+
+      BOOST_ASSERT(
+        pocma
+        ||empty()
+        ||nh.empty()
+        ||(al()==nh.al()));
+
+      if(!empty()){
+        type_policy::destroy(al(),p_);
+        if (pocma&&!nh.empty()){al()=std::move(nh.al());}
+      }
+
+      if(!nh.empty()){
+        if(empty()){new(&a_.t_)Allocator(std::move(nh.al()));}
+        p_=nh.p_;
+
+        nh.p_=nullptr;
+        nh.a_.t_.~Allocator();
+      }else if (!empty()){
+        a_.t_.~Allocator();
+        p_=nullptr;
+      }
+
+      return *this;
+    }
+
+    ~node_handle_base()
+    {
+      if(!empty()){
+        type_policy::destroy(al(),p_);
+        a_.t_.~Allocator();
+      }
+    }
+
+    allocator_type get_allocator()const noexcept{return al();}
+    explicit operator bool()const noexcept{ return !empty();}
+    BOOST_ATTRIBUTE_NODISCARD bool empty()const noexcept{return 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)
+    {
+      using std::swap;
+
+      bool const pocs=
+        boost::allocator_propagate_on_container_swap<Allocator>::type::value;
+
+      if (!empty()&&!nh.empty()){
+        BOOST_ASSERT(pocs || al()==nh.al());
+
+        node_value_type *p=p_;
+        p_=nh.p_;
+        nh.p_=p;
+
+        if(pocs){
+          swap(al(),nh.al());
+        }
+
+        return;
+      }
+
+      if (empty()&&nh.empty()){return;}
+
+      if (empty()){
+        emplace(nh.p_,nh.al());
+        nh.clear();
+      }else{
+        nh.emplace(p_,al());
+        clear();
+      }
+    }
+
+    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,7 +1477,22 @@ namespace boost {
         }
 
 #endif
-      }
+
+        template <typename T, typename Alloc, typename Key>
+        inline typename boost::allocator_pointer<Alloc>::type
+        construct_node_from_key(T*, Alloc& alloc, BOOST_FWD_REF(Key) k)
+        {
+          return construct_node(alloc, boost::forward<Key>(k));
+        }
+
+        template <typename T, typename V, typename Alloc, typename Key>
+        inline typename boost::allocator_pointer<Alloc>::type
+        construct_node_from_key(
+          std::pair<T const, V>*, Alloc& alloc, BOOST_FWD_REF(Key) k)
+        {
+          return construct_node_pair(alloc, boost::forward<Key>(k));
+        }
+      } // namespace func
     }
   }
 }
@@ -2640,8 +2655,10 @@ namespace boost {
           } else {
             node_allocator_type alloc = node_alloc();
 
-            node_tmp tmp(
-              detail::func::construct_node_pair(alloc, boost::forward<Key>(k)),
+            value_type* dispatch = BOOST_NULLPTR;
+
+            node_tmp tmp(detail::func::construct_node_from_key(
+                           dispatch, alloc, boost::forward<Key>(k)),
               alloc);
 
             if (size_ + 1 > max_load_) {
@@ -2660,7 +2677,7 @@ namespace boost {
         template <typename Key>
         iterator try_emplace_hint_unique(c_iterator hint, BOOST_FWD_REF(Key) k)
         {
-          if (hint.p && this->key_eq()(hint->first, k)) {
+          if (hint.p && this->key_eq()(extractor::extract(*hint), k)) {
             return iterator(hint.p, hint.itb);
           } else {
             return try_emplace_unique(k).first;

include/boost/unordered/detail/mulx.hpp

@@ -81,7 +81,16 @@ inline boost::uint64_t mulx64( boost::uint64_t x, boost::uint64_t y )
 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)
@@ -94,31 +103,16 @@ inline boost::uint32_t mulx32( boost::uint32_t x, boost::uint32_t y )
 #endif
 #endif
 
-// phi multipliers
-
 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 */
 
-    return mulx32( x, 0x9E3779B9u );
-
-#endif
-}
-
-// multipliers from https://arxiv.org/abs/2001.05304
-
-inline std::size_t mulx2( std::size_t x ) noexcept
-{
-#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
-
-    return (std::size_t)mulx64( (boost::uint64_t)x, 0xDEFBA91144F2B375ull );
-
-#else /* 32 bits assumed */
-
+    // multiplier from https://arxiv.org/abs/2001.05304
     return mulx32( x, 0xE817FB2Du );
 
 #endif

include/boost/unordered/detail/narrow_cast.hpp

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

include/boost/unordered/detail/prime_fmod.hpp

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

include/boost/unordered/detail/type_traits.hpp

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

include/boost/unordered/detail/xmx.hpp

@@ -64,56 +64,6 @@ static inline std::size_t xmx(std::size_t x)noexcept
 #endif
 }
 
-// alternative multipliers (phi)
-
-static inline std::size_t xmx2( std::size_t x ) noexcept
-{
-#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
-
-  boost::uint64_t z=(boost::uint64_t)x;
-
-  z ^= z >> 23;
-  z *= 0x9E3779B97F4A7C15ull;
-  z ^= z >> 23;
-
-  return (std::size_t)z;
-
-#else /* 32 bits assumed */
-
-  x ^= x >> 18;
-  x *= 0x9E3779B9u;
-  x ^= x >> 16;
-
-  return x;
-
-#endif
-}
-
-// alternative multipliers (https://arxiv.org/abs/2001.05304)
-
-static inline std::size_t xmx3( std::size_t x ) noexcept
-{
-#if defined(BOOST_UNORDERED_64B_ARCHITECTURE)
-
-  boost::uint64_t z=(boost::uint64_t)x;
-
-  z ^= z >> 23;
-  z *= 0xF1357AEA2E62A9C5ull;
-  z ^= z >> 23;
-
-  return (std::size_t)z;
-
-#else /* 32 bits assumed */
-
-  x ^= x >> 18;
-  x *= 0x93D765DDu;
-  x ^= x >> 16;
-
-  return x;
-
-#endif
-}
-
 #ifdef BOOST_UNORDERED_64B_ARCHITECTURE
 #undef BOOST_UNORDERED_64B_ARCHITECTURE
 #endif

include/boost/unordered/unordered_flat_map.hpp

@@ -32,10 +32,8 @@ namespace boost {
 #pragma warning(disable : 4714) /* marked as __forceinline not inlined */
 #endif
 
-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
-    class unordered_flat_map
-    {
-      struct map_types
+    namespace detail {
+      template <class Key, class T> struct flat_map_types
       {
         using key_type = Key;
         using raw_key_type = typename std::remove_const<Key>::type;
@@ -45,29 +43,56 @@ namespace boost {
         using moved_type = std::pair<raw_key_type&&, raw_mapped_type&&>;
         using value_type = std::pair<Key const, T>;
 
+        using element_type = value_type;
+
+        static value_type& value_from(element_type& x) { return x; }
+
         template <class K, class V>
         static raw_key_type const& extract(std::pair<K, V> const& kv)
         {
           return kv.first;
         }
 
-        static moved_type move(value_type& x)
+        static moved_type move(element_type& x)
         {
           // TODO: we probably need to launder here
           return {std::move(const_cast<raw_key_type&>(x.first)),
             std::move(const_cast<raw_mapped_type&>(x.second))};
         }
+
+        template <class A>
+        static void construct(A& al, element_type* p, moved_type&& x)
+        {
+          boost::allocator_construct(al, p, std::move(x));
+        }
+
+        template <class A, class... Args>
+        static void construct(A& al, element_type* p, Args&&... args)
+        {
+          boost::allocator_construct(al, p, std::forward<Args>(args)...);
+        }
+
+        template <class A> static void destroy(A& al, element_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,
-          typename map_types::value_type>::type, MixPolicy>;
+          typename map_types::value_type>::type>;
 
       table_type table_;
 
-      template <class K, class V, class H, class KE, class A, class MP, class Pred>
-      typename unordered_flat_map<K, V, H, KE, A, MP>::size_type friend erase_if(
-        unordered_flat_map<K, V, H, KE, A, MP>& set, Pred pred);
+      template <class K, class V, class H, class KE, class A, class Pred>
+      typename unordered_flat_map<K, V, H, KE, A>::size_type friend erase_if(
+        unordered_flat_map<K, V, H, KE, A>& set, Pred pred);
 
     public:
       using key_type = Key;
@@ -278,24 +303,37 @@ namespace boost {
       template <class M>
       std::pair<iterator, bool> insert_or_assign(key_type const& key, M&& obj)
       {
-        auto iter_bool_pair = table_.try_emplace(key, std::forward<M>(obj));
-        if (iter_bool_pair.second) {
-          return iter_bool_pair;
+        auto ibp = table_.try_emplace(key, std::forward<M>(obj));
+        if (ibp.second) {
+          return ibp;
         }
-        iter_bool_pair.first->second = std::forward<M>(obj);
-        return iter_bool_pair;
+        ibp.first->second = std::forward<M>(obj);
+        return ibp;
       }
 
       template <class M>
       std::pair<iterator, bool> insert_or_assign(key_type&& key, M&& obj)
       {
-        auto iter_bool_pair =
-          table_.try_emplace(std::move(key), std::forward<M>(obj));
-        if (iter_bool_pair.second) {
-          return iter_bool_pair;
+        auto ibp = table_.try_emplace(std::move(key), std::forward<M>(obj));
+        if (ibp.second) {
+          return ibp;
         }
-        iter_bool_pair.first->second = std::forward<M>(obj);
-        return iter_bool_pair;
+        ibp.first->second = std::forward<M>(obj);
+        return ibp;
+      }
+
+      template <class K, class M>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        std::pair<iterator, bool> >::type
+      insert_or_assign(K&& k, M&& obj)
+      {
+        auto ibp = table_.try_emplace(std::forward<K>(k), std::forward<M>(obj));
+        if (ibp.second) {
+          return ibp;
+        }
+        ibp.first->second = std::forward<M>(obj);
+        return ibp;
       }
 
       template <class M>
@@ -311,6 +349,16 @@ namespace boost {
           .first;
       }
 
+      template <class K, class M>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        iterator>::type
+      insert_or_assign(const_iterator, K&& k, M&& obj)
+      {
+        return this->insert_or_assign(std::forward<K>(k), std::forward<M>(obj))
+          .first;
+      }
+
       template <class... Args>
       BOOST_FORCEINLINE std::pair<iterator, bool> emplace(Args&&... args)
       {
@@ -337,6 +385,17 @@ namespace boost {
         return table_.try_emplace(std::move(key), std::forward<Args>(args)...);
       }
 
+      template <class K, class... Args>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::transparent_non_iterable<K,
+          unordered_flat_map>::value,
+        std::pair<iterator, bool> >::type
+      try_emplace(K&& key, Args&&... args)
+      {
+        return table_.try_emplace(
+          std::forward<K>(key), std::forward<Args>(args)...);
+      }
+
       template <class... Args>
       BOOST_FORCEINLINE iterator try_emplace(
         const_iterator, key_type const& key, Args&&... args)
@@ -352,6 +411,18 @@ namespace boost {
           .first;
       }
 
+      template <class K, class... Args>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::transparent_non_iterable<K,
+          unordered_flat_map>::value,
+        iterator>::type
+      try_emplace(const_iterator, K&& key, Args&&... args)
+      {
+        return table_
+          .try_emplace(std::forward<K>(key), std::forward<Args>(args)...)
+          .first;
+      }
+
       BOOST_FORCEINLINE void erase(iterator pos) { table_.erase(pos); }
       BOOST_FORCEINLINE void erase(const_iterator pos)
       {
@@ -387,7 +458,7 @@ namespace boost {
 
       template <class H2, class P2>
       void merge(
-        unordered_flat_map<key_type, mapped_type, H2, P2, allocator_type, MixPolicy>&
+        unordered_flat_map<key_type, mapped_type, H2, P2, allocator_type>&
           source)
       {
         table_.merge(source.table_);
@@ -395,7 +466,7 @@ namespace boost {
 
       template <class H2, class P2>
       void merge(
-        unordered_flat_map<key_type, mapped_type, H2, P2, allocator_type, MixPolicy>&&
+        unordered_flat_map<key_type, mapped_type, H2, P2, allocator_type>&&
           source)
       {
         table_.merge(std::move(source.table_));
@@ -427,6 +498,34 @@ namespace boost {
           std::out_of_range("key was not found in unordered_flat_map"));
       }
 
+      template <class K>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        mapped_type&>::type
+      at(K&& key)
+      {
+        auto pos = table_.find(std::forward<K>(key));
+        if (pos != table_.end()) {
+          return pos->second;
+        }
+        boost::throw_exception(
+          std::out_of_range("key was not found in unordered_flat_map"));
+      }
+
+      template <class K>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        mapped_type const&>::type
+      at(K&& key) const
+      {
+        auto pos = table_.find(std::forward<K>(key));
+        if (pos != table_.end()) {
+          return pos->second;
+        }
+        boost::throw_exception(
+          std::out_of_range("key was not found in unordered_flat_map"));
+      }
+
       BOOST_FORCEINLINE mapped_type& operator[](key_type const& key)
       {
         return table_.try_emplace(key).first->second;
@@ -437,6 +536,15 @@ namespace boost {
         return table_.try_emplace(std::move(key)).first->second;
       }
 
+      template <class K>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        mapped_type&>::type
+      operator[](K&& key)
+      {
+        return table_.try_emplace(std::forward<K>(key)).first->second;
+      }
+
       BOOST_FORCEINLINE size_type count(key_type const& key) const
       {
         auto pos = table_.find(key);
@@ -579,10 +687,10 @@ namespace boost {
       key_equal key_eq() const { return table_.key_eq(); }
     };
 
-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
     bool operator==(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& rhs)
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
     {
       if (&lhs == &rhs) {
         return true;
@@ -599,27 +707,27 @@ namespace boost {
       })();
     }
 
-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
     bool operator!=(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& rhs)
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
     {
       return !(lhs == rhs);
     }
 
-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
-    void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& rhs)
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& rhs)
       noexcept(noexcept(lhs.swap(rhs)))
     {
       lhs.swap(rhs);
     }
 
-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy,
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator,
       class Pred>
-    typename unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>::size_type
+    typename unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>::size_type
     erase_if(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& map, Pred pred)
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& map, Pred pred)
     {
       return erase_if(map.table_, pred);
     }

include/boost/unordered/unordered_flat_map_fwd.hpp

@@ -18,28 +18,24 @@
 
 namespace boost {
   namespace unordered {
-
-    namespace detail { namespace foa { struct xmx_mix; } }
-
     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 MixPolicy = detail::foa::xmx_mix >
+      class Allocator = std::allocator<std::pair<const Key, T> > >
     class unordered_flat_map;
 
-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
     bool operator==(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& rhs);
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);
 
-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
     bool operator!=(
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy> const& rhs);
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs);
 
-    template <class Key, class T, class Hash, class KeyEqual, class Allocator, class MixPolicy>
-    void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& lhs,
-      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator, MixPolicy>& rhs)
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& rhs)
       noexcept(noexcept(lhs.swap(rhs)));
   } // namespace unordered
 

include/boost/unordered/unordered_flat_set.hpp

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

include/boost/unordered/unordered_map.hpp

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

include/boost/unordered/unordered_node_map.hpp

@@ -0,0 +1,992 @@
+// Copyright (C) 2022-2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_UNORDERED_UNORDERED_NODE_MAP_HPP_INCLUDED
+#define BOOST_UNORDERED_UNORDERED_NODE_MAP_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/node_handle.hpp>
+#include <boost/unordered/detail/type_traits.hpp>
+#include <boost/unordered/unordered_node_map_fwd.hpp>
+
+#include <boost/core/allocator_access.hpp>
+#include <boost/functional/hash.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <initializer_list>
+#include <iterator>
+#include <stdexcept>
+#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, class T> struct node_map_types
+      {
+        using key_type = Key;
+        using mapped_type = T;
+        using raw_key_type = typename std::remove_const<Key>::type;
+        using raw_mapped_type = typename std::remove_const<T>::type;
+
+        using init_type = std::pair<raw_key_type, raw_mapped_type>;
+        using value_type = std::pair<Key const, T>;
+        using moved_type = std::pair<raw_key_type&&, raw_mapped_type&&>;
+
+        struct element_type
+        {
+          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(element_type const&) = delete;
+          element_type(element_type&& rhs) noexcept
+          {
+            p = rhs.p;
+            rhs.p = nullptr;
+          }
+        };
+
+        static value_type& value_from(element_type const& x) { return *(x.p); }
+
+        template <class K, class V>
+        static raw_key_type const& extract(std::pair<K, V> const& kv)
+        {
+          return kv.first;
+        }
+
+        static raw_key_type const& extract(element_type const& kv)
+        {
+          return kv.p->first;
+        }
+
+        static element_type&& move(element_type& x) { return std::move(x); }
+        static moved_type move(value_type& x)
+        {
+          return {std::move(const_cast<raw_key_type&>(x.first)),
+            std::move(const_cast<raw_mapped_type&>(x.second))};
+        }
+
+        template <class A>
+        static void construct(A&, element_type* p, element_type&& x) noexcept
+        {
+          p->p = x.p;
+          x.p = nullptr;
+        }
+
+        template <class A>
+        static void construct(A& al, element_type* p, element_type const& copy)
+        {
+          construct(al, p, *copy.p);
+        }
+
+        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);
+          boost::allocator_deallocate(al,
+            boost::pointer_traits<
+              typename boost::allocator_pointer<A>::type>::pointer_to(*p),
+            1);
+        }
+
+        template <class A> static void destroy(A& al, element_type* p) noexcept
+        {
+          if (p->p) {
+            destroy(al,p->p);
+          }
+        }
+      };
+
+      template <class NodeMapTypes, class Allocator>
+      struct node_map_handle
+          : public detail::foa::node_handle_base<NodeMapTypes, Allocator>
+      {
+      private:
+        using base_type =
+          detail::foa::node_handle_base<NodeMapTypes, Allocator>;
+
+        using typename base_type::type_policy;
+
+        template <class Key, class T, class Hash, class Pred, class Alloc>
+        friend class boost::unordered::unordered_node_map;
+
+      public:
+        using key_type = typename NodeMapTypes::key_type;
+        using mapped_type = typename NodeMapTypes::mapped_type;
+
+        constexpr node_map_handle() noexcept = default;
+        node_map_handle(node_map_handle&& nh) noexcept = default;
+
+        node_map_handle& operator=(node_map_handle&&) noexcept = default;
+
+        key_type& key() const
+        {
+          BOOST_ASSERT(!this->empty());
+          return const_cast<key_type&>(this->element().first);
+        }
+
+        mapped_type& mapped() const
+        {
+          BOOST_ASSERT(!this->empty());
+          return const_cast<mapped_type&>(this->element().second);
+        }
+      };
+    } // namespace detail
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    class unordered_node_map
+    {
+      using map_types = detail::node_map_types<Key, T>;
+
+      using table_type = detail::foa::table<map_types, Hash, KeyEqual,
+        typename boost::allocator_rebind<Allocator,
+          std::pair<Key const, T> >::type>;
+
+      table_type table_;
+
+      template <class K, class V, class H, class KE, class A, class Pred>
+      typename unordered_node_map<K, V, H, KE, A>::size_type friend erase_if(
+        unordered_node_map<K, V, H, KE, A>& set, Pred pred);
+
+    public:
+      using key_type = Key;
+      using mapped_type = T;
+      using value_type = typename map_types::value_type;
+      using init_type = typename map_types::init_type;
+      using size_type = std::size_t;
+      using difference_type = std::ptrdiff_t;
+      using hasher = typename boost::type_identity<Hash>::type;
+      using key_equal = typename boost::type_identity<KeyEqual>::type;
+      using allocator_type = typename boost::type_identity<Allocator>::type;
+      using reference = value_type&;
+      using const_reference = value_type const&;
+      using pointer = typename boost::allocator_pointer<allocator_type>::type;
+      using const_pointer =
+        typename boost::allocator_const_pointer<allocator_type>::type;
+      using iterator = typename table_type::iterator;
+      using const_iterator = typename table_type::const_iterator;
+      using node_type = detail::node_map_handle<map_types,
+        typename boost::allocator_rebind<Allocator,
+          typename map_types::value_type>::type>;
+      using insert_return_type =
+        detail::foa::insert_return_type<iterator, node_type>;
+
+      unordered_node_map() : unordered_node_map(0) {}
+
+      explicit unordered_node_map(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_map(size_type n, allocator_type const& a)
+          : unordered_node_map(n, hasher(), key_equal(), a)
+      {
+      }
+
+      unordered_node_map(size_type n, hasher const& h, allocator_type const& a)
+          : unordered_node_map(n, h, key_equal(), a)
+      {
+      }
+
+      template <class InputIterator>
+      unordered_node_map(
+        InputIterator f, InputIterator l, allocator_type const& a)
+          : unordered_node_map(f, l, size_type(0), hasher(), key_equal(), a)
+      {
+      }
+
+      explicit unordered_node_map(allocator_type const& a)
+          : unordered_node_map(0, a)
+      {
+      }
+
+      template <class Iterator>
+      unordered_node_map(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_map(n, h, pred, a)
+      {
+        this->insert(first, last);
+      }
+
+      template <class Iterator>
+      unordered_node_map(
+        Iterator first, Iterator last, size_type n, allocator_type const& a)
+          : unordered_node_map(first, last, n, hasher(), key_equal(), a)
+      {
+      }
+
+      template <class Iterator>
+      unordered_node_map(Iterator first, Iterator last, size_type n,
+        hasher const& h, allocator_type const& a)
+          : unordered_node_map(first, last, n, h, key_equal(), a)
+      {
+      }
+
+      unordered_node_map(unordered_node_map const& other) : table_(other.table_)
+      {
+      }
+
+      unordered_node_map(
+        unordered_node_map const& other, allocator_type const& a)
+          : table_(other.table_, a)
+      {
+      }
+
+      unordered_node_map(unordered_node_map&& 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_map(unordered_node_map&& other, allocator_type const& al)
+          : table_(std::move(other.table_), al)
+      {
+      }
+
+      unordered_node_map(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_map(ilist.begin(), ilist.end(), n, h, pred, a)
+      {
+      }
+
+      unordered_node_map(
+        std::initializer_list<value_type> il, allocator_type const& a)
+          : unordered_node_map(il, size_type(0), hasher(), key_equal(), a)
+      {
+      }
+
+      unordered_node_map(std::initializer_list<value_type> init, size_type n,
+        allocator_type const& a)
+          : unordered_node_map(init, n, hasher(), key_equal(), a)
+      {
+      }
+
+      unordered_node_map(std::initializer_list<value_type> init, size_type n,
+        hasher const& h, allocator_type const& a)
+          : unordered_node_map(init, n, h, key_equal(), a)
+      {
+      }
+
+      ~unordered_node_map() = default;
+
+      unordered_node_map& operator=(unordered_node_map const& other)
+      {
+        table_ = other.table_;
+        return *this;
+      }
+
+      unordered_node_map& operator=(unordered_node_map&& 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(); }
+
+      template <class Ty>
+      BOOST_FORCEINLINE auto insert(Ty&& value)
+        -> decltype(table_.insert(std::forward<Ty>(value)))
+      {
+        return table_.insert(std::forward<Ty>(value));
+      }
+
+      BOOST_FORCEINLINE std::pair<iterator, bool> insert(init_type&& value)
+      {
+        return table_.insert(std::move(value));
+      }
+
+      template <class Ty>
+      BOOST_FORCEINLINE auto insert(const_iterator, Ty&& value)
+        -> decltype(table_.insert(std::forward<Ty>(value)).first)
+      {
+        return table_.insert(std::forward<Ty>(value)).first;
+      }
+
+      BOOST_FORCEINLINE iterator insert(const_iterator, init_type&& value)
+      {
+        return table_.insert(std::move(value)).first;
+      }
+
+      template <class InputIterator>
+      BOOST_FORCEINLINE 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());
+
+        typename map_types::element_type x;
+        x.p=std::addressof(nh.element());
+
+        auto itp = table_.insert(std::move(x));
+        if (itp.second) {
+          nh.clear();
+          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(map_types::move(nh.element()));
+        return itp.first;
+      }
+
+      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;
+        }
+        ibp.first->second = std::forward<M>(obj);
+        return ibp;
+      }
+
+      template <class M>
+      std::pair<iterator, bool> insert_or_assign(key_type&& key, M&& obj)
+      {
+        auto ibp = table_.try_emplace(std::move(key), std::forward<M>(obj));
+        if (ibp.second) {
+          return ibp;
+        }
+        ibp.first->second = std::forward<M>(obj);
+        return ibp;
+      }
+
+      template <class K, class M>
+      typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        std::pair<iterator, bool> >::type
+      insert_or_assign(K&& k, M&& obj)
+      {
+        auto ibp = table_.try_emplace(std::forward<K>(k), std::forward<M>(obj));
+        if (ibp.second) {
+          return ibp;
+        }
+        ibp.first->second = std::forward<M>(obj);
+        return ibp;
+      }
+
+      template <class M>
+      iterator insert_or_assign(const_iterator, key_type const& key, M&& obj)
+      {
+        return this->insert_or_assign(key, std::forward<M>(obj)).first;
+      }
+
+      template <class M>
+      iterator insert_or_assign(const_iterator, key_type&& key, M&& obj)
+      {
+        return this->insert_or_assign(std::move(key), std::forward<M>(obj))
+          .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)
+      {
+        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;
+      }
+
+      template <class... Args>
+      BOOST_FORCEINLINE std::pair<iterator, bool> try_emplace(
+        key_type const& key, Args&&... args)
+      {
+        return table_.try_emplace(key, std::forward<Args>(args)...);
+      }
+
+      template <class... Args>
+      BOOST_FORCEINLINE std::pair<iterator, bool> try_emplace(
+        key_type&& key, Args&&... args)
+      {
+        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_node_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)
+      {
+        return table_.try_emplace(key, std::forward<Args>(args)...).first;
+      }
+
+      template <class... Args>
+      BOOST_FORCEINLINE iterator try_emplace(
+        const_iterator, key_type&& key, Args&&... args)
+      {
+        return table_.try_emplace(std::move(key), std::forward<Args>(args)...)
+          .first;
+      }
+
+      template <class K, class... Args>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::transparent_non_iterable<K,
+          unordered_node_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)
+      {
+        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_map>::value,
+        size_type>::type
+      erase(K const& key)
+      {
+        return table_.erase(key);
+      }
+
+      void swap(unordered_node_map& 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_map>::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_map<key_type, mapped_type, H2, P2, allocator_type>&
+          source)
+      {
+        table_.merge(source.table_);
+      }
+
+      template <class H2, class P2>
+      void merge(
+        unordered_node_map<key_type, mapped_type, H2, P2, allocator_type>&&
+          source)
+      {
+        table_.merge(std::move(source.table_));
+      }
+
+      /// Lookup
+      ///
+
+      mapped_type& at(key_type const& key)
+      {
+        auto pos = table_.find(key);
+        if (pos != table_.end()) {
+          return pos->second;
+        }
+        // TODO: someday refactor this to conditionally serialize the key and
+        // include it in the error message
+        //
+        boost::throw_exception(
+          std::out_of_range("key was not found in unordered_node_map"));
+      }
+
+      mapped_type const& at(key_type const& key) const
+      {
+        auto pos = table_.find(key);
+        if (pos != table_.end()) {
+          return pos->second;
+        }
+        boost::throw_exception(
+          std::out_of_range("key was not found in unordered_node_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_node_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_node_map"));
+      }
+
+      BOOST_FORCEINLINE mapped_type& operator[](key_type const& key)
+      {
+        return table_.try_emplace(key).first->second;
+      }
+
+      BOOST_FORCEINLINE 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
+      {
+        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 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)
+    {
+      if (&lhs == &rhs) {
+        return true;
+      }
+
+      return (lhs.size() == rhs.size()) && ([&] {
+        for (auto const& kvp : lhs) {
+          auto pos = rhs.find(kvp.first);
+          if ((pos == rhs.end()) || (*pos != kvp)) {
+            return false;
+          }
+        }
+        return true;
+      })();
+    }
+
+    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)
+    {
+      return !(lhs == 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)))
+    {
+      lhs.swap(rhs);
+    }
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator,
+      class Pred>
+    typename unordered_node_map<Key, T, Hash, KeyEqual, Allocator>::size_type
+    erase_if(
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator>& map, Pred pred)
+    {
+      return erase_if(map.table_, pred);
+    }
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop) /* C4714 */
+#endif
+
+#if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
+
+    namespace detail {
+      template <typename T>
+      using iter_key_t =
+        typename std::iterator_traits<T>::value_type::first_type;
+      template <typename T>
+      using iter_val_t =
+        typename std::iterator_traits<T>::value_type::second_type;
+      template <typename T>
+      using iter_to_alloc_t =
+        typename std::pair<iter_key_t<T> const, iter_val_t<T> >;
+    } // namespace detail
+
+    template <class InputIterator,
+      class Hash =
+        boost::hash<boost::unordered::detail::iter_key_t<InputIterator> >,
+      class Pred =
+        std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
+      class Allocator = std::allocator<
+        boost::unordered::detail::iter_to_alloc_t<InputIterator> >,
+      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_map(InputIterator, InputIterator,
+      std::size_t = boost::unordered::detail::foa::default_bucket_count,
+      Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+      -> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>,
+        boost::unordered::detail::iter_val_t<InputIterator>, Hash, Pred,
+        Allocator>;
+
+    template <class Key, class T,
+      class Hash = boost::hash<boost::remove_const_t<Key> >,
+      class Pred = std::equal_to<boost::remove_const_t<Key> >,
+      class Allocator = std::allocator<std::pair<const Key, 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_map(std::initializer_list<std::pair<Key, T> >,
+      std::size_t = boost::unordered::detail::foa::default_bucket_count,
+      Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+      -> unordered_node_map<boost::remove_const_t<Key>, 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_map(InputIterator, InputIterator, std::size_t, Allocator)
+      -> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>,
+        boost::unordered::detail::iter_val_t<InputIterator>,
+        boost::hash<boost::unordered::detail::iter_key_t<InputIterator> >,
+        std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
+        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_map(InputIterator, InputIterator, Allocator)
+      -> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>,
+        boost::unordered::detail::iter_val_t<InputIterator>,
+        boost::hash<boost::unordered::detail::iter_key_t<InputIterator> >,
+        std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
+        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_map(
+      InputIterator, InputIterator, std::size_t, Hash, Allocator)
+      -> unordered_node_map<boost::unordered::detail::iter_key_t<InputIterator>,
+        boost::unordered::detail::iter_val_t<InputIterator>, Hash,
+        std::equal_to<boost::unordered::detail::iter_key_t<InputIterator> >,
+        Allocator>;
+
+    template <class Key, class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
+      Allocator) -> unordered_node_map<boost::remove_const_t<Key>, T,
+      boost::hash<boost::remove_const_t<Key> >,
+      std::equal_to<boost::remove_const_t<Key> >, Allocator>;
+
+    template <class Key, class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_map(std::initializer_list<std::pair<Key, T> >, Allocator)
+      -> unordered_node_map<boost::remove_const_t<Key>, T,
+        boost::hash<boost::remove_const_t<Key> >,
+        std::equal_to<boost::remove_const_t<Key> >, Allocator>;
+
+    template <class Key, 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_map(std::initializer_list<std::pair<Key, T> >, std::size_t,
+      Hash, Allocator) -> unordered_node_map<boost::remove_const_t<Key>, T,
+      Hash, std::equal_to<boost::remove_const_t<Key> >, Allocator>;
+#endif
+
+  } // namespace unordered
+} // namespace boost
+
+#endif

include/boost/unordered/unordered_node_map_fwd.hpp

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

include/boost/unordered/unordered_node_set.hpp

@@ -0,0 +1,772 @@
+// 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/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; }
+
+        struct element_type
+        {
+          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(element_type const&) = delete;
+          element_type(element_type&& rhs) noexcept
+          {
+            p = rhs.p;
+            rhs.p = nullptr;
+          }
+        };
+
+        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, 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);
+          boost::allocator_deallocate(al,
+            boost::pointer_traits<
+              typename boost::allocator_pointer<A>::type>::pointer_to(*p),
+            1);
+        }
+
+        template <class A> static void destroy(A& al, element_type* p) noexcept
+        {
+          if (p->p) {
+            destroy(al, p->p);
+          }
+        }
+      };
+
+      template <class NodeSetTypes, class Allocator>
+      struct node_set_handle
+          : public detail::foa::node_handle_base<NodeSetTypes, Allocator>
+      {
+      private:
+        using base_type =
+          detail::foa::node_handle_base<NodeSetTypes, 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 NodeSetTypes::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->element());
+        }
+      };
+    } // 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());
+
+        typename set_types::element_type x;
+        x.p=std::addressof(nh.element());
+
+        auto itp = table_.insert(std::move(x));
+        if (itp.second) {
+          nh.clear();
+          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(set_types::move(nh.element()));
+        return itp.first;
+      }
+
+      template <class... Args>
+      BOOST_FORCEINLINE std::pair<iterator, bool> emplace(Args&&... args)
+      {
+        return table_.emplace(std::forward<Args>(args)...);
+      }
+
+      template <class... Args>
+      BOOST_FORCEINLINE iterator emplace_hint(const_iterator, Args&&... args)
+      {
+        return table_.emplace(std::forward<Args>(args)...).first;
+      }
+
+      BOOST_FORCEINLINE void erase(const_iterator pos)
+      {
+        return table_.erase(pos);
+      }
+      iterator erase(const_iterator first, const_iterator last)
+      {
+        while (first != last) {
+          this->erase(first++);
+        }
+        return iterator{detail::foa::const_iterator_cast_tag{}, last};
+      }
+
+      BOOST_FORCEINLINE size_type erase(key_type const& key)
+      {
+        return table_.erase(key);
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::transparent_non_iterable<K, unordered_node_set>::value,
+        size_type>::type
+      erase(K const& key)
+      {
+        return table_.erase(key);
+      }
+
+      void swap(unordered_node_set& rhs) noexcept(
+        noexcept(std::declval<table_type&>().swap(std::declval<table_type&>())))
+      {
+        table_.swap(rhs.table_);
+      }
+
+      node_type extract(const_iterator pos)
+      {
+        BOOST_ASSERT(pos != end());
+        node_type nh;
+        auto elem = table_.extract(pos);
+        nh.emplace(std::move(elem), get_allocator());
+        return nh;
+      }
+
+      node_type extract(key_type const& key)
+      {
+        auto pos = find(key);
+        return pos!=end()?extract(pos):node_type();
+      }
+
+      template <class K>
+      typename std::enable_if<
+        boost::unordered::detail::transparent_non_iterable<K,
+          unordered_node_set>::value,
+        node_type>::type
+      extract(K const& key)
+      {
+        auto pos = find(key);
+        return pos!=end()?extract(pos):node_type();
+      }
+
+      template <class H2, class P2>
+      void merge(unordered_node_set<key_type, H2, P2, allocator_type>& source)
+      {
+        table_.merge(source.table_);
+      }
+
+      template <class H2, class P2>
+      void merge(unordered_node_set<key_type, H2, P2, allocator_type>&& source)
+      {
+        table_.merge(std::move(source.table_));
+      }
+
+      /// Lookup
+      ///
+
+      BOOST_FORCEINLINE size_type count(key_type const& key) const
+      {
+        auto pos = table_.find(key);
+        return pos != table_.end() ? 1 : 0;
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value, size_type>::type
+      count(K const& key) const
+      {
+        auto pos = table_.find(key);
+        return pos != table_.end() ? 1 : 0;
+      }
+
+      BOOST_FORCEINLINE iterator find(key_type const& key)
+      {
+        return table_.find(key);
+      }
+
+      BOOST_FORCEINLINE const_iterator find(key_type const& key) const
+      {
+        return table_.find(key);
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        iterator>::type
+      find(K const& key)
+      {
+        return table_.find(key);
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        const_iterator>::type
+      find(K const& key) const
+      {
+        return table_.find(key);
+      }
+
+      BOOST_FORCEINLINE bool contains(key_type const& key) const
+      {
+        return this->find(key) != this->end();
+      }
+
+      template <class K>
+      BOOST_FORCEINLINE typename std::enable_if<
+        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
+        bool>::type
+      contains(K const& key) const
+      {
+        return this->find(key) != this->end();
+      }
+
+      std::pair<iterator, iterator> equal_range(key_type const& key)
+      {
+        auto pos = table_.find(key);
+        if (pos == table_.end()) {
+          return {pos, pos};
+        }
+
+        auto next = pos;
+        ++next;
+        return {pos, next};
+      }
+
+      std::pair<const_iterator, const_iterator> equal_range(
+        key_type const& key) const
+      {
+        auto pos = table_.find(key);
+        if (pos == table_.end()) {
+          return {pos, pos};
+        }
+
+        auto next = pos;
+        ++next;
+        return {pos, next};
+      }
+
+      template <class K>
+      typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value,
+        std::pair<iterator, iterator> >::type
+      equal_range(K const& key)
+      {
+        auto pos = table_.find(key);
+        if (pos == table_.end()) {
+          return {pos, pos};
+        }
+
+        auto next = pos;
+        ++next;
+        return {pos, next};
+      }
+
+      template <class K>
+      typename std::enable_if<
+        detail::are_transparent<K, hasher, key_equal>::value,
+        std::pair<const_iterator, const_iterator> >::type
+      equal_range(K const& key) const
+      {
+        auto pos = table_.find(key);
+        if (pos == table_.end()) {
+          return {pos, pos};
+        }
+
+        auto next = pos;
+        ++next;
+        return {pos, next};
+      }
+
+      /// Hash Policy
+      ///
+
+      size_type bucket_count() const noexcept { return table_.capacity(); }
+
+      float load_factor() const noexcept { return table_.load_factor(); }
+
+      float max_load_factor() const noexcept
+      {
+        return table_.max_load_factor();
+      }
+
+      void max_load_factor(float) {}
+
+      size_type max_load() const noexcept { return table_.max_load(); }
+
+      void rehash(size_type n) { table_.rehash(n); }
+
+      void reserve(size_type n) { table_.reserve(n); }
+
+      /// Observers
+      ///
+
+      hasher hash_function() const { return table_.hash_function(); }
+
+      key_equal key_eq() const { return table_.key_eq(); }
+    };
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator==(
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      if (&lhs == &rhs) {
+        return true;
+      }
+
+      return (lhs.size() == rhs.size()) && ([&] {
+        for (auto const& key : lhs) {
+          auto pos = rhs.find(key);
+          if ((pos == rhs.end()) || (key != *pos)) {
+            return false;
+          }
+        }
+        return true;
+      })();
+    }
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator!=(
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return !(lhs == rhs);
+    }
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    void swap(unordered_node_set<Key, Hash, KeyEqual, Allocator>& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator>& rhs)
+      noexcept(noexcept(lhs.swap(rhs)))
+    {
+      lhs.swap(rhs);
+    }
+
+    template <class Key, class Hash, class KeyEqual, class Allocator,
+      class Pred>
+    typename unordered_node_set<Key, Hash, KeyEqual, Allocator>::size_type
+    erase_if(unordered_node_set<Key, Hash, KeyEqual, Allocator>& set, Pred pred)
+    {
+      return erase_if(set.table_, pred);
+    }
+
+#if defined(BOOST_MSVC)
+#pragma warning(pop) /* C4714 */
+#endif
+
+#if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
+    template <class InputIterator,
+      class Hash =
+        boost::hash<typename std::iterator_traits<InputIterator>::value_type>,
+      class Pred =
+        std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
+      class Allocator = std::allocator<
+        typename std::iterator_traits<InputIterator>::value_type>,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_pred_v<Pred> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(InputIterator, InputIterator,
+      std::size_t = boost::unordered::detail::foa::default_bucket_count,
+      Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+      -> unordered_node_set<
+        typename std::iterator_traits<InputIterator>::value_type, Hash, Pred,
+        Allocator>;
+
+    template <class T, class Hash = boost::hash<T>,
+      class Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_pred_v<Pred> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(std::initializer_list<T>,
+      std::size_t = boost::unordered::detail::foa::default_bucket_count,
+      Hash = Hash(), Pred = Pred(), Allocator = Allocator())
+      -> unordered_node_set<T, Hash, Pred, Allocator>;
+
+    template <class InputIterator, class Allocator,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(InputIterator, InputIterator, std::size_t, Allocator)
+      -> unordered_node_set<
+        typename std::iterator_traits<InputIterator>::value_type,
+        boost::hash<typename std::iterator_traits<InputIterator>::value_type>,
+        std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
+        Allocator>;
+
+    template <class InputIterator, class Hash, class Allocator,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(
+      InputIterator, InputIterator, std::size_t, Hash, Allocator)
+      -> unordered_node_set<
+        typename std::iterator_traits<InputIterator>::value_type, Hash,
+        std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
+        Allocator>;
+
+    template <class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(std::initializer_list<T>, std::size_t, Allocator)
+      -> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
+
+    template <class T, class Hash, class Allocator,
+      class = boost::enable_if_t<detail::is_hash_v<Hash> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(std::initializer_list<T>, std::size_t, Hash, Allocator)
+      -> unordered_node_set<T, Hash, std::equal_to<T>, Allocator>;
+
+    template <class InputIterator, class Allocator,
+      class = boost::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(InputIterator, InputIterator, Allocator)
+      -> unordered_node_set<
+        typename std::iterator_traits<InputIterator>::value_type,
+        boost::hash<typename std::iterator_traits<InputIterator>::value_type>,
+        std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
+        Allocator>;
+
+    template <class T, class Allocator,
+      class = boost::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_node_set(std::initializer_list<T>, Allocator)
+      -> unordered_node_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
+#endif
+
+  } // namespace unordered
+} // namespace boost
+
+#endif

include/boost/unordered/unordered_node_set_fwd.hpp

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

include/boost/unordered/unordered_set.hpp

@@ -390,6 +390,15 @@ namespace boost {
         return this->emplace(boost::move(x));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_set>::value,
+        std::pair<iterator, bool> >::type
+      insert(BOOST_FWD_REF(Key) k)
+      {
+        return table_.try_emplace_unique(boost::forward<Key>(k));
+      }
+
       iterator insert(const_iterator hint, value_type const& x)
       {
         return this->emplace_hint(hint, x);
@@ -400,6 +409,15 @@ namespace boost {
         return this->emplace_hint(hint, boost::move(x));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_set>::value,
+        iterator>::type
+      insert(const_iterator hint, BOOST_FWD_REF(Key) k)
+      {
+        return table_.try_emplace_hint_unique(hint, boost::forward<Key>(k));
+      }
+
       template <class InputIt> void insert(InputIt, InputIt);
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -571,6 +589,14 @@ namespace boost {
         return table_.hash_to_bucket(table_.hash(k));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        size_type>::type
+      bucket(BOOST_FWD_REF(Key) k) const
+      {
+        return table_.hash_to_bucket(table_.hash(boost::forward<Key>(k)));
+      }
+
       local_iterator begin(size_type n)
       {
         return local_iterator(table_.begin(n));
@@ -1212,6 +1238,14 @@ namespace boost {
         return table_.hash_to_bucket(table_.hash(k));
       }
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        size_type>::type
+      bucket(BOOST_FWD_REF(Key) k) const
+      {
+        return table_.hash_to_bucket(table_.hash(boost::forward<Key>(k)));
+      }
+
       local_iterator begin(size_type n)
       {
         return local_iterator(table_.begin(n));

test/Jamfile.v2

@@ -1,6 +1,6 @@
 
 # Copyright 2006-2008 Daniel James.
-# Copyright 2022 Christian Mazakas
+# Copyright 2022-2023 Christian Mazakas
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -26,6 +26,7 @@ project
 
         <toolset>gcc-4.4:<cxxflags>-Wno-strict-aliasing
         <toolset>gcc-4.4:<cxxflags>-fno-deduce-init-list
+        <toolset>clang-14:<cxxflags>-Wunused-template
 
         <toolset>gcc:<warnings-as-errors>on
         <toolset>clang:<warnings-as-errors>on
@@ -94,7 +95,9 @@ 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 ;
@@ -139,6 +142,8 @@ 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 ;
 
 run unordered/hash_is_avalanching_test.cpp ;
 

test/cmake_subdir_test/CMakeLists.txt

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

test/exception/containers.hpp

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

test/exception/insert_exception_tests.cpp

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

test/exception/less_tests.cpp

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

test/exception/merge_exception_tests.cpp

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

test/exception/swap_exception_tests.cpp

@@ -247,8 +247,14 @@ 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)
+#define SWAP_CONTAINER_SEQ \
+ (unordered_flat_set)(unordered_flat_map) \
+ (unordered_node_set)(unordered_node_map)
 
 #else
 

test/helpers/tracker.hpp

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

test/helpers/unordered.hpp

@@ -11,6 +11,8 @@
 #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

@@ -262,7 +262,7 @@ namespace test {
         if (less_impl(x1.first, x2.first)) {
           return true;
         }
-        if (!less_impl(x1.first, x2.first)) {
+        if (less_impl(x2.first, x1.first)) {
           return false;
         }
         return less_impl(x1.second, x2.second);

test/unordered/assign_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -209,40 +209,75 @@ 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_set)(test_map)(test_set_prop_assign)(test_map_prop_assign)(test_set_no_prop_assign)(test_map_no_prop_assign))(
+    ((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))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(assign_tests2,
-    ((test_set)(test_map)(test_set_prop_assign)(test_map_prop_assign)(test_set_no_prop_assign)(test_map_no_prop_assign))(
+    ((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))(
       (default_generator)(generate_collisions)(limited_range)))
 #else
   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
@@ -315,6 +350,12 @@ 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
@@ -333,6 +374,12 @@ 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 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -11,16 +11,12 @@
 
 namespace at_tests {
 
-  UNORDERED_AUTO_TEST (at_tests) {
+  template <class X> static void at_tests(X*)
+  {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Create Map" << std::endl;
 
-#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
+    X x;
+    X const& x_const(x);
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check empty container" << std::endl;
 
@@ -64,6 +60,21 @@ 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 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -35,6 +35,22 @@ 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
@@ -55,149 +71,101 @@ INSTANTIATE(multimap)<test::minimal::assignable, test::minimal::assignable,
   test::minimal::allocator<int> >;
 #endif
 
-UNORDERED_AUTO_TEST (test0) {
+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()
+{
   test::minimal::constructor_param x;
 
   typedef std::pair<test::minimal::assignable const, test::minimal::assignable>
     value_type;
   value_type value(x, x);
 
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+  Map<int, int> int_map;
 
-#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>,
+  Map<int, int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<std::pair<int const, int> > >
     int_map2;
 
-  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,
+  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);
+}
 
-#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);
+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>();
 #endif
 }
 
-UNORDERED_AUTO_TEST (equality_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 equality_tests_impl()
+{
   typedef std::pair<test::minimal::copy_constructible_equality_comparable const,
     test::minimal::copy_constructible_equality_comparable>
     value_type;
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_map<int, int> int_map;
+  Map<int, int> int_map;
 
-  boost::unordered_flat_map<int, int, boost::hash<int>, std::equal_to<int>,
+  Map<int, int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<std::pair<int const, int> > >
     int_map2;
 
-  boost::unordered_flat_map<
-    test::minimal::copy_constructible_equality_comparable,
+  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);
+}
 
-#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);
+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>();
 #endif
 }
 
-UNORDERED_AUTO_TEST (test1) {
+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()
+{
+
   boost::hash<int> hash;
   std::equal_to<int> equal_to;
   int value = 0;
   std::pair<int const, int> map_value(0, 0);
 
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
+  Map<int, int> map;
 
-#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>,
+  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);
@@ -208,27 +176,53 @@ UNORDERED_AUTO_TEST (test1) {
   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
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+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::unordered_multimap<int, int> multimap;
+  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, boost::hash<int>, std::equal_to<int>,
+  Map<int, int> map;
+
+  Map<int, int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<std::pair<int const, int> > >
-    multimap2;
+    map2;
 
-  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(map, map_value);
+  unordered_map_test(map, value, value);
+  unordered_copyable_test(map, value, map_value, hash, equal_to);
 
-  unordered_equivalent_test(multimap2, map_value);
-  unordered_map_test(multimap2, value, value);
-  unordered_copyable_test(multimap2, 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>();
 #endif
 }
 
-UNORDERED_AUTO_TEST (test2) {
+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()
+{
   test::minimal::constructor_param x;
 
   test::minimal::assignable assignable(x);
@@ -240,60 +234,66 @@ UNORDERED_AUTO_TEST (test2) {
     map_value_type;
   map_value_type map_value(assignable, 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,
+  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);
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_map<test::minimal::assignable,
-    test::minimal::default_assignable,
+  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
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+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::unordered_multimap<test::minimal::assignable,
-    test::minimal::assignable, test::minimal::hash<test::minimal::assignable>,
+  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>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<map_value_type> >
-    multimap;
+    map;
 
-  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);
+  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>();
 #endif
 }
 
@@ -316,9 +316,17 @@ 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_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());
+  }
 #else
   {
     boost::unordered_map<lwg2059_key, int> x;

test/unordered/compile_set.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -35,6 +35,21 @@ 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)                                                      \
@@ -56,153 +71,106 @@ INSTANTIATE(multiset)<test::minimal::assignable,
 
 #endif
 
-UNORDERED_AUTO_TEST (type_traits) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  typedef boost::unordered_flat_set<int> set_type;
-#else
-  typedef boost::unordered_set<int> set_type;
-#endif
-
-  typedef set_type::iterator iterator;
-
+template <class X> static void type_traits_impl()
+{
   BOOST_STATIC_ASSERT(boost::is_same<int const&,
-    std::iterator_traits<iterator>::reference>::value);
+    typename std::iterator_traits<typename X::iterator>::reference>::value);
 }
 
-UNORDERED_AUTO_TEST (test0) {
+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> >();
+#else
+  type_traits_impl<boost::unordered_set<int> >();
+  type_traits_impl<boost::unordered_multiset<int> >();
+#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 test0_impl()
+{
   test::minimal::constructor_param x;
 
   test::minimal::assignable assignable(x);
 
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
+  Set<int> int_set;
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_set<int> int_set;
-
-  boost::unordered_flat_set<int, boost::hash<int>, std::equal_to<int>,
+  Set<int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<int> >
     int_set2;
 
-  boost::unordered_flat_set<test::minimal::assignable,
-    test::minimal::hash<test::minimal::assignable>,
+  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);
+}
 
-#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);
+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>();
 #endif
 }
 
-UNORDERED_AUTO_TEST (equality_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 equality_tests_impl()
+{
   typedef test::minimal::copy_constructible_equality_comparable value_type;
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_set<int> int_set;
+  Set<int> int_set;
 
-  boost::unordered_flat_set<int, boost::hash<int>, std::equal_to<int>,
+  Set<int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<int> >
     int_set2;
 
-  boost::unordered_flat_set<
-    test::minimal::copy_constructible_equality_comparable,
+  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);
+}
 
-#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);
+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>();
 #endif
 }
 
-UNORDERED_AUTO_TEST (test1) {
+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()
+{
+
   boost::hash<int> hash;
   std::equal_to<int> equal_to;
   int value = 0;
+  Set<int> set;
 
-  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>,
+  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);
@@ -211,27 +179,49 @@ UNORDERED_AUTO_TEST (test1) {
   unordered_unique_test(set2, value);
   unordered_set_test(set2, value);
   unordered_copyable_test(set2, value, value, hash, equal_to);
+}
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset." << std::endl;
+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::unordered_multiset<int> multiset;
+  boost::hash<int> hash;
+  std::equal_to<int> equal_to;
+  int value = 0;
+  Set<int> set;
 
-  boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
+  Set<int, boost::hash<int>, std::equal_to<int>,
     test::minimal::cxx11_allocator<int> >
-    multiset2;
+    set2;
 
-  unordered_equivalent_test(multiset, value);
-  unordered_set_test(multiset, value);
-  unordered_copyable_test(multiset, value, value, hash, equal_to);
+  unordered_equivalent_test(set, value);
+  unordered_set_test(set, value);
+  unordered_copyable_test(set, value, value, hash, equal_to);
 
-  unordered_equivalent_test(multiset2, value);
-  unordered_set_test(multiset2, value);
-  unordered_copyable_test(multiset2, 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>();
 #endif
 }
 
-UNORDERED_AUTO_TEST (test2) {
+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()
+{
   test::minimal::constructor_param x;
 
   test::minimal::assignable assignable(x);
@@ -239,155 +229,144 @@ UNORDERED_AUTO_TEST (test2) {
   test::minimal::hash<test::minimal::assignable> hash(x);
   test::minimal::equal_to<test::minimal::assignable> equal_to(x);
 
-  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>,
+  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
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+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::unordered_multiset<test::minimal::assignable,
-    test::minimal::hash<test::minimal::assignable>,
+  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>,
     test::minimal::equal_to<test::minimal::assignable>,
     test::minimal::allocator<test::minimal::assignable> >
-    multiset;
+    set;
 
-  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);
+  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>();
 #endif
 }
 
-UNORDERED_AUTO_TEST (movable1_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 movable1_tests_impl()
+{
   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);
 
-  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>,
+  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);
+}
 
-#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);
+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>();
 #endif
 }
 
-UNORDERED_AUTO_TEST (movable2_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 movable2_tests_impl()
+{
   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);
 
-  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>,
+  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);
+}
 
-#ifndef BOOST_UNORDERED_FOA_TESTS
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+UNORDERED_AUTO_TEST (movable2_tests) {
 
-  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);
+#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>();
 #endif
 }
 
-UNORDERED_AUTO_TEST (destructible_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 destructible_tests_impl()
+{
   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);
 
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_set<test::minimal::destructible,
+  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);
+}
 
-#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);
+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>();
 #endif
 }
 
@@ -410,9 +389,17 @@ 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_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());
+  }
 #else
   {
     boost::unordered_set<lwg2059_key> x;

test/unordered/constructor_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2010 Daniel James.
-// Copyright (C) 2022 Christian Mazakas
+// Copyright (C) 2022-2023 Christian Mazakas
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -655,23 +655,27 @@ 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_map))(
+    ((test_map_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(constructor_tests2,
-    ((test_set)(test_map))(
+    ((test_set)(test_node_set)(test_map)(test_node_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(map_constructor_test,
-    ((test_map_std_alloc)(test_map))(
+    ((test_map_std_alloc)(test_map)(test_node_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(no_alloc_default_construct_test,
-    ((test_set)(test_map))(
+    ((test_set)(test_node_set)(test_map)(test_node_map))(
       (default_generator)(generate_collisions)(limited_range)))
 #else
   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
@@ -709,6 +713,8 @@ 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
@@ -722,6 +728,9 @@ 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-2022 Christian Mazakas.
+// Copyright 2021-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)
 
@@ -137,6 +137,24 @@ 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>
@@ -254,6 +272,22 @@ 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 Christian Mazakas
+// Copyright (C) 2022-2023 Christian Mazakas
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../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);
 
@@ -482,31 +482,82 @@ namespace copy_tests {
     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_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_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_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_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_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
 #else
@@ -545,13 +596,23 @@ 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,18 +179,13 @@ namespace emplace_tests {
 
   };
 
-  UNORDERED_AUTO_TEST (emplace_set) {
+  template <class X> static void emplace_set(X*)
+  {
     test::check_instances check_;
 
-#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 X container;
+
+    typedef typename container::iterator iterator;
     typedef std::pair<iterator, bool> return_type;
     container x(10);
     iterator i1;
@@ -225,7 +220,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
@@ -294,6 +289,21 @@ 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_;
@@ -374,18 +384,12 @@ namespace emplace_tests {
   }
 #endif
 
-  UNORDERED_AUTO_TEST (emplace_map) {
+  template <class X> static void emplace_map(X*)
+  {
     test::check_instances check_;
-#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 X container;
+    typedef typename container::iterator iterator;
     typedef std::pair<iterator, bool> return_type;
     container x(10);
     return_type r1, r2;
@@ -393,7 +397,9 @@ 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);
@@ -485,18 +491,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);
@@ -504,6 +510,21 @@ 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_;
@@ -571,14 +592,13 @@ namespace emplace_tests {
   }
 #endif
 
-  UNORDERED_AUTO_TEST (try_emplace) {
+  template <class X> static void try_emplace(X*)
+  {
     test::check_instances check_;
-#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 X container;
+
+    typedef typename container::iterator iterator;
     typedef std::pair<iterator, bool> return_type;
     container x(10);
     return_type r1, r2, r3;
@@ -615,12 +635,22 @@ 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,14 +1,18 @@
 
 // Copyright 2008-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/unordered.hpp"
 
+#include "../helpers/test.hpp"
 #include <boost/preprocessor/seq.hpp>
 #include <list>
-#include "../helpers/test.hpp"
+
+// TODO: this test needs to be someday cleaned up to not be so heavily
+// macro-generated
+//
 
 namespace equality_tests {
   struct mod_compare
@@ -33,6 +37,12 @@ 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)                       \
   {                                                                            \
   }
@@ -64,14 +74,46 @@ namespace equality_tests {
   }
 #endif
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
 #define UNORDERED_EQUALITY_SET_TEST(seq1, op, seq2)                            \
   {                                                                            \
-    boost_unordered_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);                                                  \
+  }                                                                            \
+  {                                                                            \
+    boost_unordered_node_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;                                            \
@@ -79,6 +121,7 @@ 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)                                     \
@@ -86,10 +129,51 @@ namespace equality_tests {
 
   UNORDERED_AUTO_TEST (equality_size_tests) {
 #ifdef BOOST_UNORDERED_FOA_TESTS
-    boost::unordered_flat_set<int> x1, x2;
+    {
+      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));
+    }
 #else
     boost::unordered_set<int> x1, x2;
-#endif
     BOOST_TEST(x1 == x2);
     BOOST_TEST(!(x1 != x2));
 
@@ -108,6 +192,7 @@ namespace equality_tests {
     BOOST_TEST(!(x1 == x2));
     BOOST_TEST(x2 != x1);
     BOOST_TEST(!(x2 == x1));
+#endif
   }
 
   UNORDERED_AUTO_TEST (equality_key_value_tests) {
@@ -156,6 +241,45 @@ 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));
@@ -172,7 +296,8 @@ namespace equality_tests {
     set1.insert(20);
     set2.insert(10);
     BOOST_TEST(set1 == set2);
+#endif
   }
-}
+} // namespace equality_tests
 
 RUN_TESTS()

test/unordered/equivalent_keys_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -36,9 +36,21 @@ UNORDERED_AUTO_TEST (set_tests) {
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
   typedef boost::unordered_flat_set<int> set;
+
+  test_equal_insertion<set>(values[0], values[0] + 1);
+  test_equal_insertion<set>(values[1], values[1] + 2);
+  test_equal_insertion<set>(values[2], values[2] + 2);
+  test_equal_insertion<set>(values[3], values[3] + 2);
+  test_equal_insertion<set>(values[4], values[4] + 3);
+
+  typedef boost::unordered_node_set<int> node_set;
+  test_equal_insertion<node_set>(values[0], values[0] + 1);
+  test_equal_insertion<node_set>(values[1], values[1] + 2);
+  test_equal_insertion<node_set>(values[2], values[2] + 2);
+  test_equal_insertion<node_set>(values[3], values[3] + 2);
+  test_equal_insertion<node_set>(values[4], values[4] + 3);
 #else
   typedef boost::unordered_set<int> set;
-#endif
 
   test_equal_insertion<set>(values[0], values[0] + 1);
   test_equal_insertion<set>(values[1], values[1] + 2);
@@ -52,6 +64,8 @@ UNORDERED_AUTO_TEST (set_tests) {
   test_equal_insertion<multiset>(values[2], values[2] + 2);
   test_equal_insertion<multiset>(values[3], values[3] + 2);
   test_equal_insertion<multiset>(values[4], values[4] + 3);
+#endif
+
 }
 
 UNORDERED_AUTO_TEST (map_tests) {
@@ -65,11 +79,16 @@ UNORDERED_AUTO_TEST (map_tests) {
   v[2].push_back(std::pair<int const, int>(9, 13));
   v[2].push_back(std::pair<int const, int>(432, 24));
 
-  for (int i = 0; i < 5; ++i)
 #ifdef BOOST_UNORDERED_FOA_TESTS
+  for (int i = 0; i < 5; ++i)
     test_equal_insertion<boost::unordered_flat_map<int, int> >(
       v[i].begin(), v[i].end());
+
+  for (int i2 = 0; i2 < 5; ++i2)
+    test_equal_insertion<boost::unordered_node_map<int, int> >(
+      v[i2].begin(), v[i2].end());
 #else
+  for (int i = 0; i < 5; ++i)
     test_equal_insertion<boost::unordered_map<int, int> >(
       v[i].begin(), v[i].end());
 

test/unordered/erase_if.cpp

@@ -110,6 +110,8 @@ UNORDERED_AUTO_TEST (unordered_erase_if) {
 #ifdef BOOST_UNORDERED_FOA_TESTS
   test_map_erase_if<boost::unordered_flat_map<std::string, int> >();
   test_set_erase_if<boost::unordered_flat_set<int> >();
+  test_map_erase_if<boost::unordered_node_map<std::string, int> >();
+  test_set_erase_if<boost::unordered_node_set<int> >();
 #else
   test_map_erase_if<boost::unordered_map<std::string, int> >();
   test_map_erase_if<boost::unordered_multimap<std::string, int> >();

test/unordered/erase_tests.cpp

@@ -270,10 +270,16 @@ namespace erase_tests {
     test::allocator1<test::object> >* test_set;
   boost::unordered_flat_map<test::object, test::object, test::hash,
     test::equal_to, test::allocator1<test::object> >* test_map;
+  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;
 
+  // clang-format off
   UNORDERED_TEST(
-    erase_tests1, ((test_set)(test_map))(
+    erase_tests1, ((test_set)(test_map)(test_node_set)(test_node_map))(
                     (default_generator)(generate_collisions)(limited_range)))
+// clang-format on
 #else
   boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
@@ -284,10 +290,11 @@ namespace erase_tests {
   boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-
+  // clang-format off
   UNORDERED_TEST(
     erase_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
                     (default_generator)(generate_collisions)(limited_range)))
+  // clang-format on
 #endif
 }
 

test/unordered/extract_tests.cpp

@@ -1,14 +1,10 @@
 
 // Copyright 2016 Daniel James.
+// 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)
 
-// clang-format off
-#include "../helpers/prefix.hpp"
-#include <boost/unordered_map.hpp>
-#include <boost/unordered_set.hpp>
-#include "../helpers/postfix.hpp"
-// clang-format on
+#include "../helpers/unordered.hpp"
 
 #include "../helpers/equivalent.hpp"
 #include "../helpers/helpers.hpp"
@@ -113,6 +109,19 @@ namespace extract_tests {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "\n";
   }
 
+  using test::default_generator;
+  using test::generate_collisions;
+
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  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::allocator1<test::object> >* test_node_set;
+
+  UNORDERED_TEST(extract_tests1,
+    ((test_node_map)(test_node_set))((default_generator)(generate_collisions)))
+#else
   boost::unordered_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
   boost::unordered_multiset<test::object, test::hash, test::equal_to,
@@ -122,12 +131,10 @@ namespace extract_tests {
   boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_multimap;
 
-  using test::default_generator;
-  using test::generate_collisions;
-
   UNORDERED_TEST(
     extract_tests1, ((test_set)(test_multiset)(test_map)(test_multimap))(
                       (default_generator)(generate_collisions)))
-}
+#endif
+} // namespace extract_tests
 
 RUN_TESTS()

test/unordered/find_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright (C) 2022 Christian Mazakas
+// Copyright (C) 2022-2023 Christian Mazakas
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -138,9 +138,13 @@ namespace find_tests {
     test::allocator2<test::object> >* test_set;
   boost::unordered_flat_map<test::object, test::object, test::hash, test::equal_to,
     test::allocator2<test::object> >* test_map;
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_node_set;
+  boost::unordered_node_map<test::object, test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_node_map;
 
   UNORDERED_TEST(
-    find_tests1, ((test_set)(test_map))(
+    find_tests1, ((test_set)(test_map)(test_node_set)(test_node_map))(
                    (default_generator)(generate_collisions)(limited_range)))
 #else
   boost::unordered_set<test::object, test::hash, test::equal_to,

test/unordered/fwd_map_test.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2008-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -8,6 +8,7 @@
 #include "../helpers/prefix.hpp"
 #ifdef BOOST_UNORDERED_FOA_TESTS
 #include <boost/unordered/unordered_flat_map_fwd.hpp>
+#include <boost/unordered/unordered_node_map_fwd.hpp>
 #include <boost/unordered/detail/implementation.hpp>
 #else
 #include <boost/unordered/unordered_map_fwd.hpp>
@@ -23,6 +24,13 @@ void call_swap(
   swap(x, y);
 }
 
+template <typename T>
+void call_swap(
+  boost::unordered_node_map<T, T>& x, boost::unordered_node_map<T, T>& y)
+{
+  swap(x, y);
+}
+
 template <typename T>
 bool call_equals(
   boost::unordered_flat_map<T, T>& x, boost::unordered_flat_map<T, T>& y)
@@ -30,6 +38,13 @@ bool call_equals(
   return x == y;
 }
 
+template <typename T>
+bool call_equals(
+  boost::unordered_node_map<T, T>& x, boost::unordered_node_map<T, T>& y)
+{
+  return x == y;
+}
+
 template <typename T>
 bool call_not_equals(
   boost::unordered_flat_map<T, T>& x, boost::unordered_flat_map<T, T>& y)
@@ -37,7 +52,15 @@ bool call_not_equals(
   return x != y;
 }
 
+template <typename T>
+bool call_not_equals(
+  boost::unordered_node_map<T, T>& x, boost::unordered_node_map<T, T>& y)
+{
+  return x != y;
+}
+
 #include <boost/unordered/unordered_flat_map.hpp>
+#include <boost/unordered/unordered_node_map.hpp>
 #else
 template <typename T>
 void call_swap(boost::unordered_map<T, T>& x, boost::unordered_map<T, T>& y)
@@ -85,6 +108,7 @@ bool call_not_equals(
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
 typedef boost::unordered_flat_map<int, int> int_map;
+typedef boost::unordered_node_map<int, int> int_node_map;
 #else
 typedef boost::unordered_map<int, int> int_map;
 typedef boost::unordered_multimap<int, int> int_multimap;
@@ -106,6 +130,24 @@ UNORDERED_AUTO_TEST (use_map_fwd_declared_function) {
   BOOST_TEST(call_not_equals(x, y));
 }
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+UNORDERED_AUTO_TEST (use_node_map_fwd_declared_function) {
+  int_node_map x, y;
+  x[1] = 2;
+  y[2] = 1;
+  call_swap(x, y);
+
+  BOOST_TEST(y.find(1) != y.end() && y.find(1)->second == 2);
+  BOOST_TEST(y.find(2) == y.end());
+
+  BOOST_TEST(x.find(1) == x.end());
+  BOOST_TEST(x.find(2) != x.end() && x.find(2)->second == 1);
+
+  BOOST_TEST(!call_equals(x, y));
+  BOOST_TEST(call_not_equals(x, y));
+}
+#endif
+
 #ifndef BOOST_UNORDERED_FOA_TESTS
 UNORDERED_AUTO_TEST (use_multimap_fwd_declared_function) {
   int_multimap x, y;

test/unordered/fwd_set_test.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2008-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -8,6 +8,7 @@
 #include "../helpers/prefix.hpp"
 #ifdef BOOST_UNORDERED_FOA_TESTS
 #include <boost/unordered/unordered_flat_set_fwd.hpp>
+#include <boost/unordered/unordered_node_set_fwd.hpp>
 #include <boost/unordered/detail/implementation.hpp>
 #else
 #include <boost/unordered/unordered_set_fwd.hpp>
@@ -31,12 +32,22 @@ template <class Value, class Hash, class Pred, class Alloc>
 true_type is_unordered_set_impl(
   boost::unordered_flat_set<Value, Hash, Pred, Alloc>*);
 
+template <class Value, class Hash, class Pred, class Alloc>
+true_type is_unordered_set_impl(
+  boost::unordered_node_set<Value, Hash, Pred, Alloc>*);
+
 template <typename T>
 void call_swap(boost::unordered_flat_set<T>& x, boost::unordered_flat_set<T>& y)
 {
   swap(x, y);
 }
 
+template <typename T>
+void call_swap(boost::unordered_node_set<T>& x, boost::unordered_node_set<T>& y)
+{
+  swap(x, y);
+}
+
 template <typename T>
 bool call_equals(
   boost::unordered_flat_set<T>& x, boost::unordered_flat_set<T>& y)
@@ -44,12 +55,26 @@ bool call_equals(
   return x == y;
 }
 
+template <typename T>
+bool call_equals(
+  boost::unordered_node_set<T>& x, boost::unordered_node_set<T>& y)
+{
+  return x == y;
+}
+
 template <typename T>
 bool call_not_equals(
   boost::unordered_flat_set<T>& x, boost::unordered_flat_set<T>& y)
 {
   return x != y;
 }
+
+template <typename T>
+bool call_not_equals(
+  boost::unordered_node_set<T>& x, boost::unordered_node_set<T>& y)
+{
+  return x != y;
+}
 #else
 template <class Value, class Hash, class Pred, class Alloc>
 true_type is_unordered_set_impl(
@@ -100,6 +125,7 @@ bool call_not_equals(
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
 typedef boost::unordered_flat_set<int> int_set;
+typedef boost::unordered_node_set<int> int_node_set;
 #else
 typedef boost::unordered_set<int> int_set;
 typedef boost::unordered_multiset<int> int_multiset;
@@ -107,10 +133,15 @@ typedef boost::unordered_multiset<int> int_multiset;
 
 UNORDERED_AUTO_TEST (use_fwd_declared_trait_without_definition) {
   BOOST_TEST(sizeof(is_unordered_set_impl((int_set*)0)) == sizeof(true_type));
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  BOOST_TEST(
+    sizeof(is_unordered_set_impl((int_node_set*)0)) == sizeof(true_type));
+#endif
 }
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
 #include <boost/unordered/unordered_flat_set.hpp>
+#include <boost/unordered/unordered_node_set.hpp>
 #else
 #include <boost/unordered_set.hpp>
 #endif
@@ -118,10 +149,17 @@ UNORDERED_AUTO_TEST (use_fwd_declared_trait_without_definition) {
 UNORDERED_AUTO_TEST (use_fwd_declared_trait) {
   int_set x;
   BOOST_TEST(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));
-
   BOOST_TEST(sizeof(is_unordered_set_impl((int*)0)) == sizeof(false_type));
 }
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+UNORDERED_AUTO_TEST (use_node_fwd_declared_trait) {
+  int_node_set x;
+  BOOST_TEST(sizeof(is_unordered_set_impl(&x)) == sizeof(true_type));
+  BOOST_TEST(sizeof(is_unordered_set_impl((int*)0)) == sizeof(false_type));
+}
+#endif
+
 UNORDERED_AUTO_TEST (use_set_fwd_declared_function) {
   int_set x, y;
   x.insert(1);
@@ -138,6 +176,24 @@ UNORDERED_AUTO_TEST (use_set_fwd_declared_function) {
   BOOST_TEST(call_not_equals(x, y));
 }
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+UNORDERED_AUTO_TEST (use_node_set_fwd_declared_function) {
+  int_node_set x, y;
+  x.insert(1);
+  y.insert(2);
+  call_swap(x, y);
+
+  BOOST_TEST(y.find(1) != y.end());
+  BOOST_TEST(y.find(2) == y.end());
+
+  BOOST_TEST(x.find(1) == x.end());
+  BOOST_TEST(x.find(2) != x.end());
+
+  BOOST_TEST(!call_equals(x, y));
+  BOOST_TEST(call_not_equals(x, y));
+}
+#endif
+
 #ifndef BOOST_UNORDERED_FOA_TESTS
 UNORDERED_AUTO_TEST (use_multiset_fwd_declared_function) {
   int_multiset x, y;

test/unordered/incomplete_test.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -13,11 +13,12 @@ namespace x {
   {
 #ifdef BOOST_UNORDERED_FOA_TESTS
     boost::unordered_flat_map<D, D> x;
+    boost::unordered_node_map<D, D> y;
 #else
     boost::unordered_map<D, D> x;
 #endif
   };
-}
+} // namespace x
 
 namespace incomplete_test {
   // Declare, but don't define some types.
@@ -33,11 +34,11 @@ namespace incomplete_test {
   typedef boost::unordered_flat_map<value, value, hash, equals,
     allocator<std::pair<value const, value> > >
     map;
-  typedef boost::unordered_flat_map<value, value, hash, equals,
+  typedef boost::unordered_flat_set<value, hash, equals, allocator<value> > set;
+  typedef boost::unordered_node_map<value, value, hash, equals,
     allocator<std::pair<value const, value> > >
     multimap;
-  typedef boost::unordered_flat_set<value, hash, equals, allocator<value> > set;
-  typedef boost::unordered_flat_set<value, hash, equals, allocator<value> >
+  typedef boost::unordered_node_set<value, hash, equals, allocator<value> >
     multiset;
 #else
   typedef boost::unordered_map<value, value, hash, equals,
@@ -97,7 +98,7 @@ namespace incomplete_test {
   };
   struct struct2
   {
-    boost::unordered_flat_map<struct2, struct2, hash, equals,
+    boost::unordered_node_map<struct2, struct2, hash, equals,
       allocator<std::pair<struct2 const, struct2> > >
       x;
   };
@@ -107,7 +108,7 @@ namespace incomplete_test {
   };
   struct struct4
   {
-    boost::unordered_flat_set<struct4, hash, equals, allocator<struct4> > x;
+    boost::unordered_node_set<struct4, hash, equals, allocator<struct4> > x;
   };
 #else
   struct struct1
@@ -195,7 +196,7 @@ namespace incomplete_test {
   bool operator==(struct2 const&, struct2 const&) { return true; }
   bool operator==(struct3 const&, struct3 const&) { return true; }
   bool operator==(struct4 const&, struct4 const&) { return true; }
-}
+} // namespace incomplete_test
 
 int main()
 {

test/unordered/init_type_insert_tests.cpp

@@ -7,9 +7,16 @@
 #error "This test is only for the FOA-style conatiners"
 #endif
 
+#include "../helpers/test.hpp"
 #include "../helpers/unordered.hpp"
 
-#include "../helpers/test.hpp"
+#include <boost/config.hpp>
+
+#if defined(BOOST_LIBSTDCXX_VERSION)
+#if BOOST_LIBSTDCXX_VERSION < 60000
+#define BOOST_UNORDERED_NO_INIT_TYPE_TESTS
+#endif
+#endif
 
 struct move_only
 {
@@ -26,18 +33,49 @@ struct move_only
   }
 };
 
-namespace std{
+namespace std {
 
-template <> struct hash<move_only>
-{
-  std::size_t operator()(move_only const& mo) const noexcept
+  template <> struct hash<move_only>
   {
-    return std::hash<int>()(mo.x_);
+    std::size_t operator()(move_only const& mo) const noexcept
+    {
+      return std::hash<int>()(mo.x_);
+    }
+  };
+
+} // namespace std
+
+#ifndef BOOST_UNORDERED_NO_INIT_TYPE_TESTS
+
+struct immovable
+{
+  int x_ = -1;
+
+  immovable() = default;
+  immovable(int x) : x_{x} {}
+  immovable(immovable const&) = delete;
+  immovable(immovable&&) = delete;
+
+  friend bool operator==(immovable const& lhs, immovable const& rhs)
+  {
+    return lhs.x_ == rhs.x_;
   }
 };
 
+namespace std {
+
+  template <> struct hash<immovable>
+  {
+    std::size_t operator()(immovable const& im) const noexcept
+    {
+      return std::hash<int>()(im.x_);
+    }
+  };
+
 } // namespace std
 
+#endif
+
 struct raii_tracker
 {
   static unsigned move_constructs;
@@ -68,15 +106,15 @@ struct raii_tracker
   }
 };
 
-namespace std{
+namespace std {
 
-template <> struct hash<raii_tracker>
-{
-  std::size_t operator()(raii_tracker const& rt) const noexcept
+  template <> struct hash<raii_tracker>
   {
-    return std::hash<int>()(rt.x_);
-  }
-};
+    std::size_t operator()(raii_tracker const& rt) const noexcept
+    {
+      return std::hash<int>()(rt.x_);
+    }
+  };
 
 } // namespace std
 
@@ -90,9 +128,7 @@ static void test_move_only()
   boost::unordered_flat_map<move_only, int, std::hash<move_only> > map;
 
   using init_type = decltype(map)::init_type;
-  static_assert(
-    std::is_same<decltype(std::make_pair(move_only(1), v)), init_type>::value,
-    "");
+  static_assert(std::is_same<std::pair<move_only, int>, init_type>::value, "");
 
   map.insert(std::make_pair(move_only(1), v));
   map.insert({move_only(2), v});
@@ -235,10 +271,167 @@ static void test_insert_hint_tracking()
   BOOST_TEST_EQ(raii_tracker::move_constructs, 7u + 2u * map.size());
 }
 
+static void test_immovable()
+{
+#ifndef BOOST_UNORDERED_NO_INIT_TYPE_TESTS
+  int const v = 128;
+
+  boost::unordered_node_map<immovable, int, std::hash<immovable> > map;
+
+  using init_type = decltype(map)::init_type;
+  static_assert(std::is_same<std::pair<immovable, int>, init_type>::value, "");
+
+  map.emplace(1, v);
+  map.emplace(2, v);
+
+  BOOST_TEST_EQ(map.size(), 2u);
+
+  map.rehash(1024);
+  BOOST_TEST_GE(map.bucket_count(), 1024u);
+#endif
+}
+
+static void test_insert_node_tracking()
+{
+  raii_tracker::reset_counts();
+
+  BOOST_TEST_EQ(raii_tracker::copy_constructs, 0u);
+  BOOST_TEST_EQ(raii_tracker::move_constructs, 0u);
+
+  boost::unordered_node_map<raii_tracker, raii_tracker,
+    std::hash<raii_tracker> >
+    map;
+
+  {
+    std::pair<raii_tracker, raii_tracker> value{1, 2};
+
+    map.insert(value);
+
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 2u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 0u);
+  }
+
+  {
+    std::pair<raii_tracker, raii_tracker> value{2, 3};
+
+    map.insert(std::move(value));
+
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 2u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 2u);
+  }
+
+  {
+    std::pair<raii_tracker const, raii_tracker> value{3, 4};
+
+    map.insert(value);
+
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 4u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 2u);
+  }
+
+  {
+    std::pair<raii_tracker const, raii_tracker> value{4, 5};
+
+    map.insert(std::move(value));
+
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 5u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 3u);
+  }
+
+  {
+    map.insert(std::make_pair(5, 6));
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 5u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 5u);
+  }
+
+  {
+    map.insert({6, 7});
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 5u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 7u);
+  }
+
+  BOOST_TEST_EQ(map.size(), 6u);
+
+  map.rehash(1024);
+  BOOST_TEST_EQ(raii_tracker::copy_constructs, 5u);
+  BOOST_TEST_EQ(raii_tracker::move_constructs, 7u);
+}
+
+static void test_insert_hint_node_tracking()
+{
+  raii_tracker::reset_counts();
+
+  BOOST_TEST_EQ(raii_tracker::copy_constructs, 0u);
+  BOOST_TEST_EQ(raii_tracker::move_constructs, 0u);
+
+  boost::unordered_node_map<raii_tracker, raii_tracker,
+    std::hash<raii_tracker> >
+    map;
+
+  {
+    std::pair<raii_tracker, raii_tracker> value{1, 2};
+
+    map.insert(map.begin(), value);
+
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 2u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 0u);
+  }
+
+  {
+    std::pair<raii_tracker, raii_tracker> value{2, 3};
+
+    map.insert(std::move(value));
+
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 2u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 2u);
+  }
+
+  {
+    std::pair<raii_tracker const, raii_tracker> value{3, 4};
+
+    map.insert(map.begin(), value);
+
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 4u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 2u);
+  }
+
+  {
+    std::pair<raii_tracker const, raii_tracker> value{4, 5};
+
+    map.insert(map.begin(), std::move(value));
+
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 5u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 3u);
+  }
+
+  {
+    map.insert(map.begin(), std::make_pair(5, 6));
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 5u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 5u);
+  }
+
+  {
+    map.insert(map.begin(), {6, 7});
+    BOOST_TEST_EQ(raii_tracker::copy_constructs, 5u);
+    BOOST_TEST_EQ(raii_tracker::move_constructs, 7u);
+  }
+
+  BOOST_TEST_EQ(map.size(), 6u);
+
+  map.rehash(1024);
+  BOOST_TEST_EQ(raii_tracker::copy_constructs, 5u);
+  BOOST_TEST_EQ(raii_tracker::move_constructs, 7u);
+}
+
 int main()
 {
   test_move_only();
   test_insert_tracking();
   test_insert_hint_tracking();
+
+  test_immovable();
+  test_insert_node_tracking();
+  test_insert_hint_node_tracking();
+
   return boost::report_errors();
 }

test/unordered/insert_hint_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2016 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -88,12 +88,11 @@ namespace insert_hint {
     }
   }
 #endif
-  UNORDERED_AUTO_TEST (insert_hint_unique) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-    typedef boost::unordered_flat_set<int> container;
-#else
-    typedef boost::unordered_set<int> container;
-#endif
+
+  template <class X> static void insert_hint_unique(X*)
+  {
+    typedef X container;
+
     container x;
     x.insert(x.cbegin(), 10);
     BOOST_TEST_EQ(x.size(), 1u);
@@ -101,12 +100,10 @@ namespace insert_hint {
     test::check_equivalent_keys(x);
   }
 
-  UNORDERED_AUTO_TEST (insert_hint_unique_single) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-    typedef boost::unordered_flat_set<int> container;
-#else
-    typedef boost::unordered_set<int> container;
-#endif
+  template <class X> static void insert_hint_unique_single(X*)
+  {
+    typedef X container;
+
     container x;
     x.insert(10);
 
@@ -121,6 +118,18 @@ namespace insert_hint {
     BOOST_TEST_EQ(x.count(20), 1u);
     test::check_equivalent_keys(x);
   }
-}
+
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  static boost::unordered_flat_set<int>* test_set;
+  static boost::unordered_node_set<int>* test_node_set;
+
+  UNORDERED_TEST(insert_hint_unique, ((test_set)(test_node_set)))
+  UNORDERED_TEST(insert_hint_unique_single, ((test_set)(test_node_set)))
+#else
+  static boost::unordered_set<int>* test_set;
+  UNORDERED_TEST(insert_hint_unique, ((test_set)))
+  UNORDERED_TEST(insert_hint_unique_single, ((test_set)))
+#endif
+} // namespace insert_hint
 
 RUN_TESTS()

test/unordered/insert_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2010 Daniel James.
-// Copyright (C) 2022 Christian Mazakas
+// Copyright (C) 2022-2023 Christian Mazakas
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -17,6 +17,7 @@
 #include "../helpers/input_iterator.hpp"
 #include "../helpers/helpers.hpp"
 
+#include <boost/move/core.hpp>
 #include <vector>
 
 namespace insert_tests {
@@ -219,7 +220,7 @@ namespace insert_tests {
       test::check_instances check_;
 
       X x;
-      const_iterator pos = x.begin();
+      iterator pos = x.begin();
       tracker_type tracker = test::create_ordered(x);
 
       test::random_values<X> v(1000, generator);
@@ -247,7 +248,7 @@ namespace insert_tests {
       test::check_instances check_;
 
       X x;
-      const_iterator pos = x.begin();
+      iterator pos = x.begin();
       tracker_type tracker = test::create_ordered(x);
 
       test::random_values<X> v(1000, generator);
@@ -693,6 +694,69 @@ namespace insert_tests {
     BOOST_TEST_EQ(x.size(), 1000u);
   }
 
+  struct pointer_constructible
+  {
+    int x;
+
+    pointer_constructible(int x_) : x(x_) {}
+    pointer_constructible(pointer_constructible const& p) : x(p.x) {}
+    pointer_constructible(pointer_constructible* const&) : x(-1) {}
+    pointer_constructible(BOOST_RV_REF(pointer_constructible*)) : x(-1) {}
+  };
+
+  struct pointer_constructible_hash
+  {
+    typedef void is_transparent;
+
+    std::size_t operator()(pointer_constructible const& p) const
+    {
+      return boost::hash<int>()(p.x);
+    }
+  };
+
+  struct pointer_constructible_equal_to
+  {
+    typedef void is_transparent;
+
+    bool operator()(
+      pointer_constructible const& lhs, pointer_constructible const& rhs) const
+    {
+      return lhs.x == rhs.x;
+    }
+  };
+
+  template <class X>
+  static void set_tests2(X*)
+  {
+    X set, set2;
+
+    pointer_constructible pc(1337);
+    pointer_constructible* const addr_pc = &pc;
+
+    set.insert(pc);      // 1337
+    set.insert(&pc);     // -1
+    set.insert(addr_pc); // -1
+
+    BOOST_TEST_EQ(set.size(), 2u);
+    BOOST_TEST(set.find(pc) != set.end());
+    BOOST_TEST(set.find(-1) != set.end());
+    BOOST_TEST(set.find(-2) == set.end());
+
+    set2 = set;
+
+    BOOST_TEST_EQ(set2.size(), 2u);
+    BOOST_TEST(set2.find(pc) != set2.end());
+    BOOST_TEST(set2.find(-1) != set2.end());
+    BOOST_TEST(set2.find(-2) == set2.end());
+
+    set.rehash(set.bucket_count() + 1);
+
+    BOOST_TEST_EQ(set.size(), 2u);
+    BOOST_TEST(set.find(pc) != set.end());
+    BOOST_TEST(set.find(-1) != set.end());
+    BOOST_TEST(set.find(-2) == set.end());
+  }
+
   template <class X>
   void try_emplace_tests(X*, test::random_generator generator)
   {
@@ -892,45 +956,62 @@ namespace insert_tests {
 #ifdef BOOST_UNORDERED_FOA_TESTS
   boost::unordered_flat_set<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_set_std_alloc;
+  boost::unordered_node_set<test::movable, test::hash, test::equal_to,
+    std::allocator<test::movable> >* test_node_set_std_alloc;
   boost::unordered_flat_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
+  boost::unordered_node_set<test::movable, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_node_set;
   boost::unordered_flat_map<test::movable, test::movable, test::hash,
     test::equal_to, test::allocator2<test::movable> >* test_map;
+  boost::unordered_node_map<test::movable, test::movable, test::hash,
+    test::equal_to, test::allocator2<test::movable> >* test_node_map;
+
+  boost::unordered_flat_set<pointer_constructible, pointer_constructible_hash,
+    pointer_constructible_equal_to, test::allocator1<pointer_constructible> >*
+    test_pc_set;
+  boost::unordered_node_set<pointer_constructible, pointer_constructible_hash,
+    pointer_constructible_equal_to, test::allocator1<pointer_constructible> >*
+    test_pc_node_set;
 
   UNORDERED_TEST(unique_insert_tests1,
-    ((test_set_std_alloc)(test_set)(test_map))(
+    ((test_set_std_alloc)(test_node_set_std_alloc)
+     (test_set)(test_node_set)(test_map)(test_node_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(
-    insert_tests2, ((test_set)(test_map))(
+    insert_tests2, ((test_set)(test_node_set)(test_map)(test_node_map))(
                      (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(unique_emplace_tests1,
-    ((test_set_std_alloc)(test_set)(test_map))(
+    ((test_set_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(move_emplace_tests,
-    ((test_set_std_alloc)(test_set)(test_map))(
+    ((test_set_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(default_emplace_tests,
-    ((test_set_std_alloc)(test_set)(test_map))(
+    ((test_set_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(map_tests,
-    ((test_map))((default_generator)(generate_collisions)(limited_range)))
+    ((test_map)(test_node_map))
+    ((default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(
-    map_tests2, ((test_map))((default_generator)(generate_collisions)))
+    map_tests2, ((test_map)(test_node_map))((default_generator)(generate_collisions)))
 
   UNORDERED_TEST(map_insert_range_test1,
-    ((test_map))((default_generator)(generate_collisions)(limited_range)))
+    ((test_map)(test_node_map))((default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(map_insert_range_test2,
-    ((test_map))((default_generator)(generate_collisions)(limited_range)))
+    ((test_map)(test_node_map))((default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(
-    set_tests, ((test_set_std_alloc)(test_set))((default_generator)))
+    set_tests, ((test_set_std_alloc)(test_set)(test_node_set))((default_generator)))
+
+  UNORDERED_TEST(set_tests2, ((test_pc_set)(test_pc_node_set)))
 #else
   boost::unordered_set<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_set_std_alloc;
@@ -946,6 +1027,10 @@ namespace insert_tests {
   boost::unordered_multimap<test::object, test::object, test::hash,
     test::equal_to, test::allocator1<test::object> >* test_multimap;
 
+  boost::unordered_set<pointer_constructible, pointer_constructible_hash,
+    pointer_constructible_equal_to, test::allocator1<pointer_constructible> >*
+    test_pc_set;
+
   UNORDERED_TEST(unique_insert_tests1,
     ((test_set_std_alloc)(test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
@@ -990,6 +1075,8 @@ namespace insert_tests {
 
   UNORDERED_TEST(
     set_tests, ((test_set_std_alloc)(test_set)(test_multiset))((default_generator)))
+
+  UNORDERED_TEST(set_tests2, ((test_pc_set)))
 #endif
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -1009,23 +1096,19 @@ namespace insert_tests {
     }
   };
 
-  UNORDERED_AUTO_TEST (insert_initializer_list_set) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-    boost::unordered_flat_set<int> set;
-#else
-    boost::unordered_set<int> set;
-#endif
+  template <template <class Key, class Hash = boost::hash<Key>,
+    class Pred = std::equal_to<Key>, class Allocator = std::allocator<Key> >
+    class Set>
+  static void insert_initializer_list_set_impl()
+  {
+    Set<int> set;
+
     set.insert({1, 2, 3, 1});
     BOOST_TEST_EQ(set.size(), 3u);
     BOOST_TEST(set.find(1) != set.end());
     BOOST_TEST(set.find(4) == set.end());
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_set<initialize_from_two_ints> set2;
-#else
-    boost::unordered_set<initialize_from_two_ints> set2;
-#endif
-
+    Set<initialize_from_two_ints> set2;
 #if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5))
     set2.insert({{1, 2}});
 #else
@@ -1053,6 +1136,16 @@ namespace insert_tests {
     BOOST_TEST(set2.find({8, 7}) == set2.end());
   }
 
+  UNORDERED_AUTO_TEST (insert_initializer_list_set) {
+#ifdef BOOST_UNORDERED_FOA_TESTS
+    insert_initializer_list_set_impl<boost::unordered_flat_set>();
+    insert_initializer_list_set_impl<boost::unordered_node_set>();
+#else
+    insert_initializer_list_set_impl<boost::unordered_set>();
+    boost::unordered_set<int> set;
+#endif
+  }
+
 #ifndef BOOST_UNORDERED_FOA_TESTS
 #if !BOOST_WORKAROUND(BOOST_MSVC, == 1800)
 
@@ -1074,18 +1167,31 @@ namespace insert_tests {
 #endif
 #endif
 
-  UNORDERED_AUTO_TEST (insert_initializer_list_map) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_map<std::string, std::string> map;
-#else
-    boost::unordered_map<std::string, std::string> map;
-  #endif
-    // map.insert({});
+  template <class X> static void insert_initializer_list_map(X*)
+  {
+    X map;
+
     BOOST_TEST(map.empty());
     map.insert({{"a", "b"}, {"a", "b"}, {"d", ""}});
     BOOST_TEST_EQ(map.size(), 2u);
   }
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  static boost::unordered_flat_map<std::string, std::string>* test_str_map;
+  static boost::unordered_node_map<std::string, std::string>* test_str_node_map;
+
+  // clang-format off
+  UNORDERED_TEST(insert_initializer_list_map,
+    ((test_str_map)(test_str_node_map)))
+  // clang-format on
+#else
+  static boost::unordered_map<std::string, std::string>* test_str_map;
+
+  // clang-format off
+  UNORDERED_TEST(insert_initializer_list_map, ((test_str_map)))
+  // clang-format on
+#endif
+
 #ifndef BOOST_UNORDERED_FOA_TESTS
   UNORDERED_AUTO_TEST (insert_initializer_list_multimap) {
     boost::unordered_multimap<std::string, std::string> multimap;
@@ -1124,65 +1230,72 @@ namespace insert_tests {
     }
   };
 
-  UNORDERED_AUTO_TEST (map_emplace_test) {
-    {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-      boost::unordered_flat_map<int, overloaded_constructor, test::hash,
-        test::equal_to,
-        test::allocator1<std::pair<int const, overloaded_constructor> > >
-        x;
-#else
-
-      boost::unordered_map<int, overloaded_constructor, test::hash,
-        test::equal_to,
-        test::allocator1<std::pair<int const, overloaded_constructor> > >
-        x;
-#endif
-
+  template <class X> static void map_emplace_test(X*)
+  {
+    X x;
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
-      x.emplace();
-      BOOST_TEST(
-        x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
+    x.emplace();
+    BOOST_TEST(
+      x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
 #endif
 
-      x.emplace(2, 3);
-      BOOST_TEST(
-        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
+    x.emplace(2, 3);
+    BOOST_TEST(
+      x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
 
-      x.try_emplace(5);
-      BOOST_TEST(
-        x.find(5) != x.end() && x.find(5)->second == overloaded_constructor());
-    }
-
-#ifndef BOOST_UNORDERED_FOA_TESTS
-    {
-      boost::unordered_multimap<int, overloaded_constructor, test::hash,
-        test::equal_to,
-        test::allocator1<std::pair<int const, overloaded_constructor> > >
-        x;
-
-#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
-      x.emplace();
-      BOOST_TEST(
-        x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
-#endif
-
-      x.emplace(2, 3);
-      BOOST_TEST(
-        x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
-    }
-#endif
+    x.try_emplace(5);
+    BOOST_TEST(
+      x.find(5) != x.end() && x.find(5)->second == overloaded_constructor());
   }
 
-  UNORDERED_AUTO_TEST (set_emplace_test) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-    boost::unordered_flat_set<overloaded_constructor> x;
-    overloaded_constructor check;
-#else
-    boost::unordered_set<overloaded_constructor> x;
-    overloaded_constructor check;
+#ifndef BOOST_UNORDERED_FOA_TESTS
+  template <class X> static void multimap_emplace_test(X*)
+  {
+    X x;
+#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
+    x.emplace();
+    BOOST_TEST(
+      x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
 #endif
 
+    x.emplace(2, 3);
+    BOOST_TEST(
+      x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
+  }
+#endif
+
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  static boost::unordered_flat_map<int, overloaded_constructor, test::hash,
+    test::equal_to,
+    test::allocator1<std::pair<int const, overloaded_constructor> > >*
+    test_oc_map;
+
+  static boost::unordered_node_map<int, overloaded_constructor, test::hash,
+    test::equal_to,
+    test::allocator1<std::pair<int const, overloaded_constructor> > >*
+    test_oc_node_map;
+
+  UNORDERED_TEST(map_emplace_test, ((test_oc_map)(test_oc_node_map)))
+#else
+  static boost::unordered_map<int, overloaded_constructor, test::hash,
+    test::equal_to,
+    test::allocator1<std::pair<int const, overloaded_constructor> > >*
+    test_oc_map;
+
+  static boost::unordered_multimap<int, overloaded_constructor, test::hash,
+    test::equal_to,
+    test::allocator1<std::pair<int const, overloaded_constructor> > >*
+    test_oc_multimap;
+
+  UNORDERED_TEST(map_emplace_test, ((test_oc_map)))
+  UNORDERED_TEST(multimap_emplace_test, ((test_oc_multimap)))
+#endif
+
+  template <class X> static void set_emplace_test(X*)
+  {
+    X x;
+    overloaded_constructor check;
+
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
     x.emplace();
     BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
@@ -1209,6 +1322,18 @@ namespace insert_tests {
     BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
   }
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  static boost::unordered_flat_set<overloaded_constructor>* test_oc_set;
+  static boost::unordered_node_set<overloaded_constructor>* test_oc_node_set;
+
+  UNORDERED_TEST(set_emplace_test, ((test_oc_set)(test_oc_node_set)))
+#else
+  static boost::unordered_set<overloaded_constructor>* test_oc_set;
+  static boost::unordered_multiset<overloaded_constructor>* test_oc_multiset;
+
+  UNORDERED_TEST(set_emplace_test, ((test_oc_set)(test_oc_multiset)))
+#endif
+
   struct derived_from_piecewise_construct_t
     : boost::unordered::piecewise_construct_t
   {
@@ -1358,6 +1483,14 @@ namespace insert_tests {
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
 
+  static boost::unordered_map<overloaded_constructor, overloaded_constructor,
+    boost::hash<overloaded_constructor>, std::equal_to<overloaded_constructor>,
+    test::allocator1<std::pair<overloaded_constructor const,
+      overloaded_constructor> > >* test_pw_oc_map;
+
+  static boost::unordered_set<std::pair<overloaded_constructor,
+    overloaded_constructor> >* test_pair_oc_set;
+
 #define PIECEWISE_TEST_NAME boost_tuple_piecewise_tests
 #define PIECEWISE_NAMESPACE boost::unordered
 #define TUPLE_NAMESPACE boost
@@ -1389,6 +1522,14 @@ namespace insert_tests {
 #if !defined(BOOST_NO_CXX11_HDR_TUPLE) &&                                      \
   BOOST_UNORDERED_HAVE_PIECEWISE_CONSTRUCT
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  static boost::unordered_flat_set<std::pair<overloaded_constructor,
+    overloaded_constructor> >* test_pair_oc_set;
+
+  static boost::unordered_node_set<std::pair<overloaded_constructor,
+    overloaded_constructor> >* test_pair_oc_node_set;
+#endif
+
 #define PIECEWISE_TEST_NAME std_piecewise_tests
 #define PIECEWISE_NAMESPACE std
 #define TUPLE_NAMESPACE std
@@ -1402,27 +1543,17 @@ RUN_TESTS_QUIET()
 
 #else // PIECEWISE_TEST_NAME
 
-UNORDERED_AUTO_TEST (PIECEWISE_TEST_NAME) {
+#define MAP_PIECEWISE_TEST BOOST_PP_CAT(map_, PIECEWISE_TEST_NAME)
+#define SET_PIECEWISE_TEST BOOST_PP_CAT(set_, PIECEWISE_TEST_NAME)
+
+  template <class X>
+  static void MAP_PIECEWISE_TEST(X*)
+  {
 #if EMULATING_PIECEWISE_CONSTRUCTION
   test::detail::disable_construction_tracking _scoped;
 #endif
 
-  {
-#if defined(BOOST_UNORDERED_FOA_TESTS)
-    boost::unordered_flat_map<overloaded_constructor, overloaded_constructor,
-      boost::hash<overloaded_constructor>,
-      std::equal_to<overloaded_constructor>,
-      test::allocator1<
-        std::pair<overloaded_constructor const, overloaded_constructor> > >
-      x;
-#else
-    boost::unordered_map<overloaded_constructor, overloaded_constructor,
-      boost::hash<overloaded_constructor>,
-      std::equal_to<overloaded_constructor>,
-      test::allocator1<
-        std::pair<overloaded_constructor const, overloaded_constructor> > >
-      x;
-#endif
+    X x;
 
     x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
       TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
@@ -1466,70 +1597,102 @@ UNORDERED_AUTO_TEST (PIECEWISE_TEST_NAME) {
                x.find(overloaded_constructor(2, 3))->second ==
                  overloaded_constructor(4, 5, 6));
   }
-#ifndef BOOST_UNORDERED_FOA_TESTS
+
+  template <class X>
+  static void SET_PIECEWISE_TEST(X*)
   {
-    boost::unordered_multimap<overloaded_constructor, overloaded_constructor,
-      boost::hash<overloaded_constructor>,
-      std::equal_to<overloaded_constructor>,
-      test::allocator1<
-        std::pair<overloaded_constructor const, overloaded_constructor> > >
-      x;
+#if EMULATING_PIECEWISE_CONSTRUCTION
+    test::detail::disable_construction_tracking _scoped;
+#endif
+
+    X x;
+    std::pair<overloaded_constructor, overloaded_constructor> check;
 
     x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
       TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
-    BOOST_TEST(
-      x.find(overloaded_constructor()) != x.end() &&
-      x.find(overloaded_constructor())->second == overloaded_constructor());
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
 
-    x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
-      TUPLE_NAMESPACE::make_tuple());
-    BOOST_TEST(
-      x.find(overloaded_constructor(1)) != x.end() &&
-      x.find(overloaded_constructor(1))->second == overloaded_constructor());
-
-    x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
-      TUPLE_NAMESPACE::make_tuple(4, 5, 6));
-    BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
-               x.find(overloaded_constructor(2, 3))->second ==
-                 overloaded_constructor(4, 5, 6));
-
-    derived_from_piecewise_construct_t d;
-    x.emplace(
-      d, TUPLE_NAMESPACE::make_tuple(9, 3, 1), TUPLE_NAMESPACE::make_tuple(10));
-    BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
-               x.find(overloaded_constructor(9, 3, 1))->second ==
-                 overloaded_constructor(10));
+    x.clear();
+    x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+      TUPLE_NAMESPACE::make_tuple(1), TUPLE_NAMESPACE::make_tuple(2, 3));
+    check =
+      std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));
+    BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
   }
-#endif
-}
 
-UNORDERED_AUTO_TEST (BOOST_PP_CAT(PIECEWISE_TEST_NAME, 2)) {
+#if defined(BOOST_UNORDERED_FOA_TESTS)
+  static boost::unordered_flat_map<overloaded_constructor,
+    overloaded_constructor, boost::hash<overloaded_constructor>,
+    std::equal_to<overloaded_constructor>,
+    test::allocator1<std::pair<overloaded_constructor const,
+      overloaded_constructor> > >* test_pw_oc_map;
+
+  static boost::unordered_node_map<overloaded_constructor,
+    overloaded_constructor, boost::hash<overloaded_constructor>,
+    std::equal_to<overloaded_constructor>,
+    test::allocator1<std::pair<overloaded_constructor const,
+      overloaded_constructor> > >* test_pw_oc_node_map;
+
+  // clang-format off
+  UNORDERED_TEST(MAP_PIECEWISE_TEST, ((test_pw_oc_map)(test_pw_oc_node_map)))
+  // clang-format on
+#else
+  // clang-format off
+  UNORDERED_TEST(MAP_PIECEWISE_TEST, ((test_pw_oc_map)))
+  // clang-format on
+#endif
+
+#ifndef BOOST_UNORDERED_FOA_TESTS
+  UNORDERED_AUTO_TEST (BOOST_PP_CAT(multimap_, PIECEWISE_TEST_NAME)) {
+    {
 #if EMULATING_PIECEWISE_CONSTRUCTION
-  test::detail::disable_construction_tracking _scoped;
+      test::detail::disable_construction_tracking _scoped;
+#endif
+      boost::unordered_multimap<overloaded_constructor, overloaded_constructor,
+        boost::hash<overloaded_constructor>,
+        std::equal_to<overloaded_constructor>,
+        test::allocator1<
+          std::pair<overloaded_constructor const, overloaded_constructor> > >
+        x;
+
+      x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
+        TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
+      BOOST_TEST(
+        x.find(overloaded_constructor()) != x.end() &&
+        x.find(overloaded_constructor())->second == overloaded_constructor());
+
+      x.emplace(convertible_to_piecewise(), TUPLE_NAMESPACE::make_tuple(1),
+        TUPLE_NAMESPACE::make_tuple());
+      BOOST_TEST(
+        x.find(overloaded_constructor(1)) != x.end() &&
+        x.find(overloaded_constructor(1))->second == overloaded_constructor());
+
+      x.emplace(piecewise_rvalue(), TUPLE_NAMESPACE::make_tuple(2, 3),
+        TUPLE_NAMESPACE::make_tuple(4, 5, 6));
+      BOOST_TEST(x.find(overloaded_constructor(2, 3)) != x.end() &&
+                 x.find(overloaded_constructor(2, 3))->second ==
+                   overloaded_constructor(4, 5, 6));
+
+      derived_from_piecewise_construct_t d;
+      x.emplace(d, TUPLE_NAMESPACE::make_tuple(9, 3, 1),
+        TUPLE_NAMESPACE::make_tuple(10));
+      BOOST_TEST(x.find(overloaded_constructor(9, 3, 1)) != x.end() &&
+                 x.find(overloaded_constructor(9, 3, 1))->second ==
+                   overloaded_constructor(10));
+    }
+  }
 #endif
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_set<
-    std::pair<overloaded_constructor, overloaded_constructor> >
-    x;
+  // clang-format off
+  UNORDERED_TEST(SET_PIECEWISE_TEST,
+    ((test_pair_oc_set)(test_pair_oc_node_set)))
+  // clang-format on
 #else
-  boost::unordered_set<
-    std::pair<overloaded_constructor, overloaded_constructor> >
-    x;
+  // clang-format off
+  UNORDERED_TEST(SET_PIECEWISE_TEST, ((test_pair_oc_set)))
+  // clang-format on
 #endif
-  std::pair<overloaded_constructor, overloaded_constructor> check;
-
-  x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
-    TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
-  BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-
-  x.clear();
-  x.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
-    TUPLE_NAMESPACE::make_tuple(1), TUPLE_NAMESPACE::make_tuple(2, 3));
-  check =
-    std::make_pair(overloaded_constructor(1), overloaded_constructor(2, 3));
-  BOOST_TEST(x.find(check) != x.end() && *x.find(check) == check);
-}
 
 #undef PIECEWISE_TEST_NAME
 #undef PIECEWISE_NAMESPACE

test/unordered/link_test_1.cpp

@@ -1,20 +1,23 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/unordered.hpp"
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
-void foo(boost::unordered_flat_set<int>&, boost::unordered_flat_map<int, int>&);
+void foo(boost::unordered_flat_set<int>&, boost::unordered_flat_map<int, int>&,
+  boost::unordered_node_set<int>&, boost::unordered_node_map<int, int>&);
 
 int main()
 {
   boost::unordered_flat_set<int> x1;
   boost::unordered_flat_map<int, int> x2;
+  boost::unordered_node_set<int> x3;
+  boost::unordered_node_map<int, int> x4;
 
-  foo(x1, x2);
+  foo(x1, x2, x3, x4);
 
   return 0;
 }

test/unordered/link_test_2.cpp

@@ -1,14 +1,15 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/unordered.hpp"
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
-void foo(
-  boost::unordered_flat_set<int>& x1, boost::unordered_flat_map<int, int>& x2)
+void foo(boost::unordered_flat_set<int>& x1,
+  boost::unordered_flat_map<int, int>& x2, boost::unordered_node_set<int>& x3,
+  boost::unordered_node_map<int, int>& x4)
 {
 #if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x0613))
   struct dummy
@@ -20,6 +21,8 @@ void foo(
 
   x1.insert(1);
   x2[2] = 2;
+  x3.insert(3);
+  x4.insert(std::make_pair(4, 5));
 }
 #else
 void foo(boost::unordered_set<int>& x1, boost::unordered_map<int, int>& x2,

test/unordered/load_factor_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -86,12 +86,17 @@ namespace load_factor_tests {
 #ifdef BOOST_UNORDERED_FOA_TESTS
   boost::unordered_flat_set<int>* int_set_ptr;
   boost::unordered_flat_map<int, int>* int_map_ptr;
+  boost::unordered_node_set<int>* int_node_set_ptr;
+  boost::unordered_node_map<int, int>* int_node_map_ptr;
 
-  UNORDERED_TEST(set_load_factor_tests, ((int_set_ptr)(int_map_ptr)))
+  // clang-format off
+  UNORDERED_TEST(set_load_factor_tests, 
+    ((int_set_ptr)(int_map_ptr)(int_node_set_ptr)(int_node_map_ptr)))
 
   UNORDERED_TEST(load_factor_insert_tests,
-    ((int_set_ptr)(int_map_ptr))(
+    ((int_set_ptr)(int_map_ptr)(int_node_set_ptr)(int_node_map_ptr))(
       (default_generator)(generate_collisions)(limited_range)))
+// clang-format on
 #else
   boost::unordered_set<int>* int_set_ptr;
   boost::unordered_multiset<int>* int_multiset_ptr;

test/unordered/max_load_tests.cpp

@@ -69,9 +69,24 @@ boost::unordered_flat_map<test::object, test::object, test::hash,
   test::allocator1<std::pair<test::object const, test::object> > >*
   test_map_tracking;
 
+boost::unordered_node_set<int>* int_node_set_ptr;
+boost::unordered_node_map<test::movable, test::movable, test::hash,
+  test::equal_to, test::allocator2<test::movable> >* test_node_map_ptr;
+
+boost::unordered_node_set<test::object, test::hash, test::equal_to,
+  test::allocator1<test::object> >* test_node_set_tracking;
+boost::unordered_node_map<test::object, test::object, test::hash,
+  test::equal_to,
+  test::allocator1<std::pair<test::object const, test::object> > >*
+  test_node_map_tracking;
+
+// clang-format off
 UNORDERED_TEST(max_load_tests,
-  ((int_set_ptr)(test_map_ptr)(test_set_tracking)(test_map_tracking))(
+  ((int_set_ptr)(test_map_ptr)(test_set_tracking)(test_map_tracking)
+   (int_node_set_ptr)(test_node_map_ptr)
+   (test_node_set_tracking)(test_node_map_tracking))(
     (sequential)))
+// clang-format on
 #endif
 
 RUN_TESTS()

test/unordered/merge_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2016 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -16,14 +16,9 @@
 
 namespace merge_tests {
 
-  UNORDERED_AUTO_TEST (merge_set) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-    boost::unordered_flat_set<int> x;
-    boost::unordered_flat_set<int> y;
-#else
-    boost::unordered_set<int> x;
-    boost::unordered_set<int> y;
-#endif
+  template <class X> static void merge_set(X*)
+  {
+    X x, y;
 
     x.merge(y);
     BOOST_TEST(x.empty());
@@ -237,22 +232,23 @@ namespace merge_tests {
   using test::generate_collisions;
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<int>* int_set;
+
   boost::unordered_flat_set<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_set_std_alloc;
 
-
-  boost::unordered_flat_map<test::object, test::object, test::hash, test::equal_to,
-    std::allocator<test::object> >* test_map_std_alloc;
-
+  boost::unordered_flat_map<test::object, test::object, test::hash,
+    test::equal_to, std::allocator<test::object> >* test_map_std_alloc;
 
   boost::unordered_flat_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
 
-
-  boost::unordered_flat_map<test::movable, test::movable, test::hash, test::equal_to,
-    test::allocator2<test::movable> >* test_map;
+  boost::unordered_flat_map<test::movable, test::movable, test::hash,
+    test::equal_to, test::allocator2<test::movable> >* test_map;
 
   // clang-format off
+UNORDERED_TEST(merge_set, ((int_set)))
+
 UNORDERED_TEST(merge_empty_test,
     ((test_set_std_alloc))
     ((test_set_std_alloc))
@@ -308,7 +304,82 @@ UNORDERED_TEST(merge_into_unique_keys_test,
     ((0)(1)(2))
     ((default_generator)(generate_collisions)))
   // clang-format on
+
+  boost::unordered_node_set<int>* int_node_set;
+
+  boost::unordered_node_set<test::movable, test::hash, test::equal_to,
+    std::allocator<test::movable> >* test_node_set_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_node_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_node_set;
+
+  boost::unordered_node_map<test::movable, test::movable, test::hash,
+    test::equal_to, test::allocator2<test::movable> >* test_node_map;
+
+  // clang-format off
+UNORDERED_TEST(merge_set, ((int_node_set)))
+
+UNORDERED_TEST(merge_empty_test,
+    ((test_node_set_std_alloc))
+    ((test_node_set_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_empty_test,
+    ((test_node_map_std_alloc))
+    ((test_node_map_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_empty_test,
+    ((test_node_set))
+    ((test_node_set))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_empty_test,
+    ((test_node_map))
+    ((test_node_map))
+    ((default_generator)(generate_collisions)))
+
+UNORDERED_TEST(merge_into_empty_test,
+    ((test_node_set_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_empty_test,
+    ((test_node_map_std_alloc))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_empty_test,
+    ((test_node_set))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_empty_test,
+    ((test_node_map))
+    ((default_generator)(generate_collisions)))
+
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_node_set_std_alloc))
+    ((test_node_set_std_alloc))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_node_map_std_alloc))
+    ((test_node_map_std_alloc))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_node_set))
+    ((test_node_set))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+UNORDERED_TEST(merge_into_unique_keys_test,
+    ((test_node_map))
+    ((test_node_map))
+    ((0)(1)(2))
+    ((0)(1)(2))
+    ((default_generator)(generate_collisions)))
+  // clang-format on
 #else
+  boost::unordered_set<int>* int_set;
+
   boost::unordered_set<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_set_std_alloc;
   boost::unordered_multiset<test::movable, test::hash, test::equal_to,
@@ -330,6 +401,8 @@ UNORDERED_TEST(merge_into_unique_keys_test,
     test::equal_to, test::allocator2<test::movable> >* test_multimap;
 
   // clang-format off
+UNORDERED_TEST(merge_set, ((int_set)))
+
 UNORDERED_TEST(merge_empty_test,
     ((test_set_std_alloc)(test_multiset_std_alloc))
     ((test_set_std_alloc)(test_multiset_std_alloc))
@@ -412,6 +485,6 @@ UNORDERED_TEST(merge_into_equiv_keys_test,
   // clang-format on
 #endif
 
-}
+} // namespace merge_tests
 
 RUN_TESTS()

test/unordered/move_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2008-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or move at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -408,18 +408,68 @@ namespace move_tests {
     test::cxx11_allocator<std::pair<test::object const, test::object>,
       test::no_propagate_move> >* test_map_no_prop_move;
 
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    std::allocator<std::pair<test::object const, test::object> > >*
+    test_node_map_std_alloc;
+
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_node_set;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    test::allocator1<std::pair<test::object const, test::object> > >*
+    test_node_map;
+
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_node_set_prop_move;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<std::pair<test::object const, test::object>,
+      test::propagate_move> >* test_node_map_prop_move;
+
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_node_set_no_prop_move;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<std::pair<test::object const, test::object>,
+      test::no_propagate_move> >* test_node_map_no_prop_move;
+
+  // clang-format off
   UNORDERED_TEST(move_construct_tests1,
-    ((test_map_std_alloc)(test_set)(test_map)(test_set_prop_move)(test_map_prop_move)(test_set_no_prop_move)(test_map_no_prop_move))(
+    ((test_map_std_alloc)(test_set)(test_map)
+     (test_set_prop_move)(test_map_prop_move)
+     (test_set_no_prop_move)(test_map_no_prop_move)
+     (test_node_map_std_alloc)(test_node_set)(test_node_map)
+     (test_node_set_prop_move)(test_node_map_prop_move)
+     (test_node_set_no_prop_move)(test_node_map_no_prop_move))(
       (default_generator)(generate_collisions)(limited_range)))
   UNORDERED_TEST(move_assign_tests1,
-    ((test_map_std_alloc)(test_set)(test_map)(test_set_prop_move)(test_map_prop_move)(test_set_no_prop_move)(test_map_no_prop_move))(
+    ((test_map_std_alloc)(test_set)(test_map)
+     (test_set_prop_move)(test_map_prop_move)
+     (test_set_no_prop_move)(test_map_no_prop_move)
+     (test_node_map_std_alloc)(test_node_set)(test_node_map)
+     (test_node_set_prop_move)(test_node_map_prop_move)
+     (test_node_set_no_prop_move)(test_node_map_no_prop_move))(
       (default_generator)(generate_collisions)(limited_range)))
   UNORDERED_TEST(move_construct_tests2,
-    ((test_set)(test_map)(test_set_prop_move)(test_map_prop_move)(test_set_no_prop_move)(test_map_no_prop_move))(
+    ((test_set)(test_map)
+     (test_set_prop_move)(test_map_prop_move)
+     (test_set_no_prop_move)(test_map_no_prop_move)
+     (test_node_set)(test_node_map)
+     (test_node_set_prop_move)(test_node_map_prop_move)
+     (test_node_set_no_prop_move)(test_node_map_no_prop_move))(
       (default_generator)(generate_collisions)(limited_range)))
   UNORDERED_TEST(move_assign_tests2,
-    ((test_set)(test_map)(test_set_prop_move)(test_map_prop_move)(test_set_no_prop_move)(test_map_no_prop_move))(
+    ((test_set)(test_map)
+     (test_set_prop_move)(test_map_prop_move)
+     (test_set_no_prop_move)(test_map_no_prop_move)
+     (test_node_set)(test_node_map)
+     (test_node_set_prop_move)(test_node_map_prop_move)
+     (test_node_set_no_prop_move)(test_node_map_no_prop_move))(
       (default_generator)(generate_collisions)(limited_range)))
+  // clang-format on
 #else
   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<std::pair<test::object const, test::object> > >*

test/unordered/narrow_cast_tests.cpp

@@ -0,0 +1,107 @@
+// Copyright 2022 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#include <boost/unordered/detail/narrow_cast.hpp>
+
+#include <boost/core/lightweight_test.hpp>
+#include <boost/cstdint.hpp>
+
+// want to prove that for the wider type, the higher bits of the value
+// represenation don't affect the results of the narrowing, which in this case
+// is masking out the high bits when comapred to the narrow type
+
+static void signed_integral_narrowing()
+{
+  // test positive range, fits
+  // [0, 127]
+  for (boost::int32_t i = 0x00; i < 0x80; ++i) {
+    boost::int8_t k = (boost::int8_t)i;
+    BOOST_TEST_GE(k, 0);
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::int8_t>(i), k);
+  }
+
+  // test positive range, doesn't fit
+  // [0xff00, 0xff7f]
+  for (boost::int32_t i = 0x00; i < 0x80; ++i) {
+    boost::int32_t j = i + 0xff00;
+    boost::int8_t k = (boost::int8_t)i;
+    BOOST_TEST_GE(k, 0);
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::int8_t>(j), k);
+  }
+
+  // test negative range, fits
+  // [-128, -1]
+  for (boost::int32_t i = 0x00; i < 0x80; ++i) {
+    boost::int32_t j = i + (boost::int32_t)0xffffff80;
+    boost::int8_t k = (boost::int8_t)j;
+    BOOST_TEST_LT(j, 0);
+    BOOST_TEST_LT(k, 0);
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::int8_t>(j), k);
+  }
+
+  // test negative range, doesn't fit
+  for (boost::int32_t i = 0x00; i < 0x80; ++i) {
+    boost::int32_t j = i + (boost::int32_t)0x80000000;
+    boost::int8_t k = (boost::int8_t)(i);
+    BOOST_TEST_LT(j, 0);
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::int8_t>(j), k);
+  }
+
+  for (boost::int32_t i = 0x00; i < 0x100; ++i) {
+    boost::int32_t j = (boost::int32_t)0x80ff0000 + i;
+    BOOST_TEST_LT(j, 0);
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::int8_t>(j),
+      (boost::int8_t)i);
+  }
+
+  // test special values
+  {
+    boost::int32_t x = 0xff;
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::int8_t>(x), -1);
+  }
+
+  {
+    boost::int32_t x = (boost::int32_t)0xffffff00;
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::int8_t>(x),
+      (boost::int8_t)0x00);
+  }
+
+  {
+    boost::int32_t x = (boost::int32_t)0xffffff7f;
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::int8_t>(x),
+      (boost::int8_t)0x7f);
+  }
+
+  {
+    boost::int32_t x = (boost::int32_t)0xffffffff;
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::int8_t>(x),
+      (boost::int8_t)-1);
+  }
+}
+
+static void unsigned_integral_narrowing()
+{
+  // test range: [0x00, 0xff]
+  for (boost::uint32_t i = 0x00; i < 0x100; ++i) {
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::uint8_t>(i),
+      (boost::uint8_t)(i & 0xff));
+  }
+
+  // test range: [0xffffff00, 0xffffffff]
+  boost::uint32_t i = 0xffffff00;
+  for (; i < 0xffffffff; ++i) {
+    BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::uint8_t>(i),
+      (boost::uint8_t)(i & 0xff));
+  }
+  BOOST_TEST_EQ(boost::unordered::detail::narrow_cast<boost::uint8_t>(i),
+    (boost::uint8_t)(i & 0xff));
+}
+
+int main()
+{
+  signed_integral_narrowing();
+  unsigned_integral_narrowing();
+
+  return boost::report_errors();
+}

test/unordered/node_handle_tests.cpp

@@ -1,12 +1,12 @@
 
 // Copyright 2016 Daniel James.
+// 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 "../helpers/postfix.hpp"
 #include "../helpers/prefix.hpp"
-#include <boost/unordered_map.hpp>
-#include <boost/unordered_set.hpp>
+#include "../helpers/unordered.hpp"
 
 #include "../helpers/helpers.hpp"
 #include "../helpers/metafunctions.hpp"
@@ -17,15 +17,19 @@
 #include <set>
 #include <string>
 
-UNORDERED_AUTO_TEST (example1) {
-  typedef boost::unordered_map<int, std::string>::insert_return_type
-    insert_return_type;
+template <template <class Key, class T, class Hash = boost::hash<Key>,
+  class Pred = std::equal_to<Key>,
+  class Allocator = std::allocator<std::pair<Key const, T> > >
+  class Map>
+static void example1()
+{
+  typedef typename Map<int, std::string>::insert_return_type insert_return_type;
 
-  boost::unordered_map<int, std::string> src;
+  Map<int, std::string> src;
   src.emplace(1, "one");
   src.emplace(2, "two");
   src.emplace(3, "buckle my shoe");
-  boost::unordered_map<int, std::string> dst;
+  Map<int, std::string> dst;
   dst.emplace(3, "three");
 
   dst.insert(src.extract(src.find(1)));
@@ -42,12 +46,16 @@ UNORDERED_AUTO_TEST (example1) {
   BOOST_TEST(r.node.mapped() == "buckle my shoe");
 }
 
-UNORDERED_AUTO_TEST (example2) {
-  boost::unordered_set<int> src;
+template <template <class Key, class Hash = boost::hash<Key>,
+  class Pred = std::equal_to<Key>, class Allocator = std::allocator<Key> >
+  class Set>
+static void example2()
+{
+  Set<int> src;
   src.insert(1);
   src.insert(3);
   src.insert(5);
-  boost::unordered_set<int> dst;
+  Set<int> dst;
   dst.insert(2);
   dst.insert(4);
   dst.insert(5);
@@ -57,14 +65,18 @@ UNORDERED_AUTO_TEST (example2) {
   // dst == {1, 2, 3, 4, 5}
 }
 
-UNORDERED_AUTO_TEST (example3) {
-  typedef boost::unordered_set<int>::iterator iterator;
+template <template <class Key, class Hash = boost::hash<Key>,
+  class Pred = std::equal_to<Key>, class Allocator = std::allocator<Key> >
+  class Set>
+static void example3()
+{
+  typedef typename Set<int>::iterator iterator;
 
-  boost::unordered_set<int> src;
+  Set<int> src;
   src.insert(1);
   src.insert(3);
   src.insert(5);
-  boost::unordered_set<int> dst;
+  Set<int> dst;
   dst.insert(2);
   dst.insert(4);
   dst.insert(5);
@@ -88,16 +100,24 @@ UNORDERED_AUTO_TEST (example3) {
   BOOST_TEST(it == dst2.end());
 }
 
-UNORDERED_AUTO_TEST (failed_insertion_with_hint) {
+template <template <class Key, class T, class Hash = boost::hash<Key>,
+            class Pred = std::equal_to<Key>,
+            class Allocator = std::allocator<std::pair<Key const, T> > >
+          class Map,
+  template <class Key, class Hash = boost::hash<Key>,
+    class Pred = std::equal_to<Key>, class Allocator = std::allocator<Key> >
+  class Set>
+static void failed_insertion_with_hint()
+{
   {
-    boost::unordered_set<int> src;
-    boost::unordered_set<int> dst;
+    Set<int> src;
+    Set<int> dst;
     src.emplace(10);
     src.emplace(20);
     dst.emplace(10);
     dst.emplace(20);
 
-    boost::unordered_set<int>::node_type nh = src.extract(10);
+    typename Set<int>::node_type nh = src.extract(10);
 
     BOOST_TEST(dst.insert(dst.find(10), boost::move(nh)) == dst.find(10));
     BOOST_TEST(nh);
@@ -116,14 +136,14 @@ UNORDERED_AUTO_TEST (failed_insertion_with_hint) {
   }
 
   {
-    boost::unordered_map<int, int> src;
-    boost::unordered_map<int, int> dst;
+    Map<int, int> src;
+    Map<int, int> dst;
     src.emplace(10, 30);
     src.emplace(20, 5);
     dst.emplace(10, 20);
     dst.emplace(20, 2);
 
-    boost::unordered_map<int, int>::node_type nh = src.extract(10);
+    typename Map<int, int>::node_type nh = src.extract(10);
     BOOST_TEST(dst.insert(dst.find(10), boost::move(nh)) == dst.find(10));
     BOOST_TEST(nh);
     BOOST_TEST(!nh.empty());
@@ -231,20 +251,38 @@ template <typename Container> void node_handle_tests_impl(Container& c)
   BOOST_TEST(!n4);
 }
 
-UNORDERED_AUTO_TEST (node_handle_tests) {
-  boost::unordered_set<int> x1;
+template <template <class Key, class T, class Hash = boost::hash<Key>,
+            class Pred = std::equal_to<Key>,
+            class Allocator = std::allocator<std::pair<Key const, T> > >
+          class Map,
+  template <class Key, class Hash = boost::hash<Key>,
+    class Pred = std::equal_to<Key>, class Allocator = std::allocator<Key> >
+  class Set>
+static void node_handle_tests()
+{
+  Set<int> x1;
   x1.emplace(100);
   x1.emplace(140);
   x1.emplace(-55);
   node_handle_tests_impl(x1);
 
-  boost::unordered_map<int, std::string> x2;
+  Map<int, std::string> x2;
   x2.emplace(10, "ten");
   x2.emplace(-23, "twenty");
   x2.emplace(-76, "thirty");
   node_handle_tests_impl(x2);
 }
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+
+template <class X> typename X::iterator insert_empty_node(X& x)
+{
+  typedef typename X::node_type node_type;
+  return x.insert(node_type()).position;
+}
+
+#else
+
 template <class Key, class T, class Hash, class KeyEqual, class Allocator>
 typename boost::unordered_map<Key, T, Hash, KeyEqual, Allocator>::iterator
 insert_empty_node(boost::unordered_map<Key, T, Hash, KeyEqual, Allocator>& c)
@@ -288,8 +326,10 @@ insert_empty_node(boost::unordered_multiset<T, Hash, KeyEqual, Allocator>& c)
   return c.insert(node_type());
 }
 
+#endif
+
 template <typename Container1, typename Container2>
-void insert_node_handle_unique(Container1& c1, Container2& c2)
+static void insert_node_handle_unique(Container1& c1, Container2& c2)
 {
   typedef typename Container1::node_type node_type;
   typedef typename Container1::value_type value_type;
@@ -330,7 +370,7 @@ void insert_node_handle_unique(Container1& c1, Container2& c2)
 }
 
 template <typename Container1, typename Container2>
-void insert_node_handle_unique2(Container1& c1, Container2& c2)
+static void insert_node_handle_unique2(Container1& c1, Container2& c2)
 {
   typedef typename Container1::node_type node_type;
   typedef typename Container1::value_type value_type;
@@ -362,6 +402,130 @@ void insert_node_handle_unique2(Container1& c1, Container2& c2)
   }
 }
 
+struct hash_thing
+{
+  std::size_t operator()(int x) const
+  {
+    return static_cast<std::size_t>(x * 13 + 5);
+  }
+};
+
+#ifdef BOOST_UNORDERED_FOA_TESTS
+
+UNORDERED_AUTO_TEST (examples) {
+  example1<boost::unordered_node_map>();
+  example2<boost::unordered_node_set>();
+  example3<boost::unordered_node_set>();
+  failed_insertion_with_hint<boost::unordered_node_map,
+    boost::unordered_node_set>();
+  node_handle_tests<boost::unordered_node_map, boost::unordered_node_set>();
+}
+
+UNORDERED_AUTO_TEST (insert_node_handle_unique_tests) {
+  {
+    boost::unordered_node_set<int> x1;
+    boost::unordered_node_set<int> x2;
+    x1.emplace(100);
+    x1.emplace(140);
+    x1.emplace(-55);
+    x2.emplace(140);
+    insert_node_handle_unique(x1, x2);
+    BOOST_TEST(x2.size() == 3);
+  }
+
+  {
+    boost::unordered_node_set<int> x1;
+    boost::unordered_node_set<int> x2;
+    x1.emplace(100);
+    x1.emplace(140);
+    x1.emplace(-55);
+    x2.emplace(140);
+    insert_node_handle_unique(x1, x2);
+    BOOST_TEST(x2.size() == 3);
+  }
+
+  {
+    boost::unordered_node_map<int, int, hash_thing> x1;
+    boost::unordered_node_map<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_unique(x1, x2);
+    BOOST_TEST(x2.size() == 4);
+  }
+
+  {
+    boost::unordered_node_map<int, int, hash_thing> x1;
+    boost::unordered_node_map<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_unique(x1, x2);
+    BOOST_TEST(x2.size() == 4);
+  }
+}
+
+UNORDERED_AUTO_TEST (insert_node_handle_unique_tests2) {
+  {
+    boost::unordered_node_set<int> x1;
+    boost::unordered_node_set<int> x2;
+    x1.emplace(100);
+    x1.emplace(140);
+    x1.emplace(-55);
+    x2.emplace(140);
+    insert_node_handle_unique2(x1, x2);
+    BOOST_TEST(x2.size() == 3);
+  }
+
+  {
+    boost::unordered_node_set<int> x1;
+    boost::unordered_node_set<int> x2;
+    x1.emplace(100);
+    x1.emplace(140);
+    x1.emplace(-55);
+    x2.emplace(140);
+    insert_node_handle_unique2(x1, x2);
+    BOOST_TEST(x2.size() == 3);
+  }
+
+  {
+    boost::unordered_node_map<int, int, hash_thing> x1;
+    boost::unordered_node_map<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_unique2(x1, x2);
+    BOOST_TEST(x2.size() == 4);
+  }
+
+  {
+    boost::unordered_node_map<int, int, hash_thing> x1;
+    boost::unordered_node_map<int, int> x2;
+    x1.emplace(67, 50);
+    x1.emplace(23, 45);
+    x1.emplace(18, 19);
+    x2.emplace(23, 50);
+    x2.emplace(12, 49);
+    insert_node_handle_unique2(x1, x2);
+    BOOST_TEST(x2.size() == 4);
+  }
+}
+
+#else
+UNORDERED_AUTO_TEST (examples) {
+  example1<boost::unordered_map>();
+  example2<boost::unordered_set>();
+  example3<boost::unordered_set>();
+  failed_insertion_with_hint<boost::unordered_map, boost::unordered_set>();
+  node_handle_tests<boost::unordered_map, boost::unordered_set>();
+}
+
 template <typename Container1, typename Container2>
 void insert_node_handle_equiv(Container1& c1, Container2& c2)
 {
@@ -389,14 +553,6 @@ void insert_node_handle_equiv(Container1& c1, Container2& c2)
   }
 }
 
-struct hash_thing
-{
-  std::size_t operator()(int x) const
-  {
-    return static_cast<std::size_t>(x * 13 + 5);
-  }
-};
-
 UNORDERED_AUTO_TEST (insert_node_handle_unique_tests) {
   {
     boost::unordered_set<int> x1;
@@ -547,4 +703,6 @@ UNORDERED_AUTO_TEST (insert_node_handle_unique_tests2) {
   }
 }
 
+#endif
+
 RUN_TESTS()

test/unordered/noexcept_tests.cpp

@@ -6,8 +6,8 @@
 
 #include "../helpers/unordered.hpp"
 
-#include "../helpers/test.hpp"
 #include "../helpers/fwd.hpp"
+#include "../helpers/test.hpp"
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
@@ -203,6 +203,10 @@ namespace noexcept_tests {
         boost::unordered_flat_set<int> >::value));
       BOOST_TEST((boost::is_nothrow_move_constructible<
         boost::unordered_flat_map<int, int> >::value));
+      BOOST_TEST((boost::is_nothrow_move_constructible<
+        boost::unordered_node_set<int> >::value));
+      BOOST_TEST((boost::is_nothrow_move_constructible<
+        boost::unordered_node_map<int, int> >::value));
 #else
       BOOST_TEST((boost::is_nothrow_move_constructible<
         boost::unordered_set<int> >::value));
@@ -222,6 +226,13 @@ namespace noexcept_tests {
     BOOST_TEST(
       (!boost::is_nothrow_move_constructible<boost::unordered_flat_set<int,
           boost::hash<int>, equal_to_possible_exception> >::value));
+
+    BOOST_TEST(
+      (!boost::is_nothrow_move_constructible<
+        boost::unordered_node_set<int, hash_possible_exception> >::value));
+    BOOST_TEST(
+      (!boost::is_nothrow_move_constructible<boost::unordered_node_set<int,
+          boost::hash<int>, equal_to_possible_exception> >::value));
 #else
     BOOST_TEST((!boost::is_nothrow_move_constructible<
                 boost::unordered_set<int, hash_possible_exception> >::value));
@@ -231,31 +242,22 @@ namespace noexcept_tests {
 #endif
   }
 
-  UNORDERED_AUTO_TEST (test_nothrow_move_when_noexcept) {
-#ifdef BOOST_UNORDERED_FOA_TESTS
-    typedef boost::unordered_flat_set<int, hash_nothrow_move_construct,
-      equal_to_nothrow_move_construct>
-      throwing_set;
-#else
-    typedef boost::unordered_set<int, hash_nothrow_move_construct,
-      equal_to_nothrow_move_construct>
-      throwing_set;
-#endif
-
+  template <class X> static void test_nothrow_move_when_noexcept(X*)
+  {
     if (have_is_nothrow_move) {
-      BOOST_TEST(boost::is_nothrow_move_constructible<throwing_set>::value);
+      BOOST_TEST(boost::is_nothrow_move_constructible<X>::value);
     }
 
     throwing_test_exception = false;
 
-    throwing_set x1;
+    X x1;
     x1.insert(10);
     x1.insert(50);
 
     try {
       throwing_test_exception = true;
 
-      throwing_set x2 = boost::move(x1);
+      X x2 = boost::move(x1);
       BOOST_TEST(x2.size() == 2);
       BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
       BOOST_TEST(have_is_nothrow_move);
@@ -327,24 +329,16 @@ namespace noexcept_tests {
     }
   }
 
-  UNORDERED_AUTO_TEST (test_nothrow_swap_when_noexcept) {
-#if BOOST_UNORDERED_FOA_TESTS
-    typedef boost::unordered_flat_set<int, hash_nothrow_swap,
-      equal_to_nothrow_swap>
-      throwing_set;
-#else
-    typedef boost::unordered_set<int, hash_nothrow_swap, equal_to_nothrow_swap>
-      throwing_set;
-#endif
-
+  template <class X> static void test_nothrow_swap_when_noexcept(X*)
+  {
     if (have_is_nothrow_swap) {
-      BOOST_TEST(boost::is_nothrow_swappable<throwing_set>::value);
+      BOOST_TEST(boost::is_nothrow_swappable<X>::value);
     }
 
     throwing_test_exception = false;
 
-    throwing_set x1;
-    throwing_set x2;
+    X x1;
+    X x2;
     x1.insert(10);
     x1.insert(50);
     for (int i = 0; i < 100; ++i) {
@@ -365,7 +359,7 @@ namespace noexcept_tests {
 
     throwing_test_exception = false;
   }
-}
+} // namespace noexcept_tests
 
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
@@ -401,6 +395,7 @@ template <class T> class allocator2
 {
   BOOST_COPYABLE_AND_MOVABLE(allocator2)
   allocator2 operator=(BOOST_COPY_ASSIGN_REF(allocator2));
+
 public:
   typedef T value_type;
   typedef boost::true_type propagate_on_container_move_assignment;
@@ -431,21 +426,53 @@ UNORDERED_AUTO_TEST (prelim_allocator_checks) {
 
   BOOST_TEST(boost::allocator_is_always_equal<allocator2<int> >::type::value);
   BOOST_TEST(boost::allocator_propagate_on_container_move_assignment<
-             allocator2<int> >::type::value);
+    allocator2<int> >::type::value);
 }
 
 using test::default_generator;
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
+boost::unordered_flat_set<int, noexcept_tests::hash_nothrow_move_construct,
+  noexcept_tests::equal_to_nothrow_move_construct>* throwing_set;
+boost::unordered_flat_set<int, noexcept_tests::hash_nothrow_swap,
+  noexcept_tests::equal_to_nothrow_swap>* throwing_set2;
+
 boost::unordered_flat_set<int, noexcept_tests::hash_nothrow_swap,
   noexcept_tests::equal_to_nothrow_swap, allocator1<int> >* throwing_set_alloc1;
 
 boost::unordered_flat_set<int, noexcept_tests::hash_nothrow_swap,
   noexcept_tests::equal_to_nothrow_swap, allocator2<int> >* throwing_set_alloc2;
 
+boost::unordered_node_set<int, noexcept_tests::hash_nothrow_move_construct,
+  noexcept_tests::equal_to_nothrow_move_construct>* throwing_node_set;
+boost::unordered_node_set<int, noexcept_tests::hash_nothrow_swap,
+  noexcept_tests::equal_to_nothrow_swap>* throwing_node_set2;
+
+boost::unordered_node_set<int, noexcept_tests::hash_nothrow_swap,
+  noexcept_tests::equal_to_nothrow_swap, allocator1<int> >*
+  throwing_node_set_alloc1;
+
+boost::unordered_node_set<int, noexcept_tests::hash_nothrow_swap,
+  noexcept_tests::equal_to_nothrow_swap, allocator2<int> >*
+  throwing_node_set_alloc2;
+
+// clang-format off
+UNORDERED_TEST(
+  test_nothrow_move_when_noexcept, ((throwing_set)(throwing_node_set)))
+UNORDERED_TEST(
+  test_nothrow_swap_when_noexcept, ((throwing_set2)(throwing_node_set2)))
 UNORDERED_TEST(test_nothrow_move_assign_when_noexcept,
-  ((throwing_set_alloc1)(throwing_set_alloc2))((default_generator)))
+  ((throwing_set_alloc1)(throwing_set_alloc2)
+   (throwing_node_set_alloc1)(throwing_node_set_alloc2))(
+    (default_generator)))
+// clang-format on
 #else
+boost::unordered_set<int, noexcept_tests::hash_nothrow_move_construct,
+  noexcept_tests::equal_to_nothrow_move_construct>* throwing_set;
+
+boost::unordered_set<int, noexcept_tests::hash_nothrow_swap,
+  noexcept_tests::equal_to_nothrow_swap>* throwing_set2;
+
 boost::unordered_set<int, noexcept_tests::hash_nothrow_move_assign,
   noexcept_tests::equal_to_nothrow_move_assign, allocator1<int> >*
   throwing_set_alloc1;
@@ -454,6 +481,8 @@ boost::unordered_set<int, noexcept_tests::hash_nothrow_move_assign,
   noexcept_tests::equal_to_nothrow_move_assign, allocator2<int> >*
   throwing_set_alloc2;
 
+UNORDERED_TEST(test_nothrow_move_when_noexcept, ((throwing_set)))
+UNORDERED_TEST(test_nothrow_swap_when_noexcept, ((throwing_set2)))
 UNORDERED_TEST(test_nothrow_move_assign_when_noexcept,
   ((throwing_set_alloc1)(throwing_set_alloc2))((default_generator)))
 #endif

test/unordered/post_move_tests.cpp

@@ -1,5 +1,5 @@
 
-// Copyright (C) 2022 Christian Mazakas
+// Copyright (C) 2022-2023 Christian Mazakas
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or move at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -335,12 +335,14 @@ namespace move_tests {
       static_cast<typename T::size_type>(std::distance(y.begin(), y.end())));
   }
 
+#ifndef BOOST_UNORDERED_FOA_TESTS
   template <class T> static void extract(T& y, test::random_values<T> const& v)
   {
     (void)y.extract(get_key(*v.begin()));
     BOOST_TEST_EQ(y.size(),
       static_cast<typename T::size_type>(std::distance(y.begin(), y.end())));
   }
+#endif
 
   template <class T> static void merge(T& y, test::random_values<T> const& v)
   {
@@ -375,6 +377,7 @@ namespace move_tests {
       static_cast<typename T::size_type>(std::distance(y.begin(), y.end())));
   }
 
+#ifndef BOOST_UNORDERED_FOA_TESTS
   template <class T> static void buckets(T& y, test::random_values<T> const& v)
   {
     (void)y.begin(0);
@@ -384,6 +387,7 @@ namespace move_tests {
     (void)y.bucket_size(0);
     (void)y.bucket(get_key(*v.begin()));
   }
+#endif
 
   template <class T>
   static void double_move_construct(T& y, test::random_values<T> const&)
@@ -607,9 +611,38 @@ namespace move_tests {
     test::cxx11_allocator<std::pair<test::object const, test::object>,
       test::no_propagate_move> >* test_map_no_prop_move;
 
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    test::allocator2<test::object> >* test_node_set;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    test::allocator1<std::pair<test::object const, test::object> > >*
+    test_node_map;
+
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::propagate_move> >*
+    test_node_set_prop_move;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<std::pair<test::object const, test::object>,
+      test::propagate_move> >* test_node_map_prop_move;
+
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_move> >*
+    test_node_set_no_prop_move;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<std::pair<test::object const, test::object>,
+      test::no_propagate_move> >* test_node_map_no_prop_move;
+
+  // clang-format off
   UNORDERED_TEST(post_move_tests,
-    ((test_set)(test_map)(test_set_prop_move)(test_map_prop_move)(test_set_no_prop_move)(test_map_no_prop_move))(
+    ((test_set)(test_map)(test_set_prop_move)(test_map_prop_move)
+     (test_set_no_prop_move)(test_map_no_prop_move)
+     (test_node_set)(test_node_map)
+     (test_node_set_prop_move)(test_node_map_prop_move)
+     (test_node_set_no_prop_move)(test_node_map_no_prop_move))(
       (default_generator)(generate_collisions)(limited_range)))
+// clang-format on
 #else
   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<std::pair<test::object const, test::object> > >*
@@ -654,12 +687,14 @@ namespace move_tests {
     test::cxx11_allocator<std::pair<test::object const, test::object>,
       test::no_propagate_move> >* test_multimap_no_prop_move;
 
+// clang-format off
   UNORDERED_TEST(post_move_tests,
     ((test_set)(test_multiset)(test_map)(test_multimap)(test_set_prop_move)(
       test_multiset_prop_move)(test_map_prop_move)(test_multimap_prop_move)(
       test_set_no_prop_move)(test_multiset_no_prop_move)(test_map_no_prop_move)(
       test_multimap_no_prop_move))(
       (default_generator)(generate_collisions)(limited_range)))
+// clang-format on
 #endif
 }
 

test/unordered/rehash_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -437,6 +437,35 @@ namespace rehash_tests {
     tracker.compare(x);
   }
 
+  template <class X>
+  void rehash_node_stability(X*, test::random_generator generator)
+  {
+    typedef typename X::value_type value_type;
+    std::set<value_type const*> elements;
+
+    test::random_values<X> v(1000, generator);
+    test::ordered<X> tracker;
+    tracker.insert_range(v.begin(), v.end());
+
+    X x(v.begin(), v.end());
+
+    typedef typename X::iterator iterator;
+    for (iterator pos = x.begin(); pos != x.end(); ++pos) {
+      elements.insert(boost::addressof(*pos));
+    }
+
+    x.rehash(2 * x.bucket_count());
+
+    for (iterator pos = x.begin(); pos != x.end(); ++pos) {
+      if (!BOOST_TEST(
+            elements.find(boost::addressof(*pos)) != elements.end())) {
+        break;
+      }
+    }
+
+    tracker.compare(x);
+  }
+
   template <class X> void rehash_test1(X*, test::random_generator generator)
   {
     test::random_values<X> v(1000, generator);
@@ -581,32 +610,67 @@ namespace rehash_tests {
     monotonic_allocator<std::pair<test::object const, test::object> > >*
     test_map_monotonic;
 
-  UNORDERED_TEST(rehash_empty_test1, ((int_set_ptr)(test_map_ptr)))
+  boost::unordered_node_set<int>* int_node_set_ptr;
+  boost::unordered_node_map<test::movable, test::movable, test::hash,
+    test::equal_to, test::allocator2<test::movable> >* test_node_map_ptr;
+
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    test::allocator1<test::object> >* test_node_set_tracking;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    test::allocator1<std::pair<test::object const, test::object> > >*
+    test_node_map_tracking;
+
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    monotonic_allocator<test::object> >* test_node_set_monotonic;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    monotonic_allocator<std::pair<test::object const, test::object> > >*
+    test_node_map_monotonic;
+
+  // clang-format off
+  UNORDERED_TEST(rehash_empty_test1,
+    ((int_set_ptr)(test_map_ptr)
+     (int_node_set_ptr)(test_node_map_ptr)))
   UNORDERED_TEST(rehash_empty_test2,
-    ((int_set_ptr)(test_map_ptr))(
+    ((int_set_ptr)(test_map_ptr)
+     (int_node_set_ptr)(test_node_map_ptr))(
       (default_generator)(generate_collisions)(limited_range)))
   UNORDERED_TEST(rehash_empty_test3,
-    ((int_set_ptr)(test_map_ptr))(
+    ((int_set_ptr)(test_map_ptr)
+     (int_node_set_ptr)(test_node_map_ptr))(
+      (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(rehash_test1,
+    ((int_set_ptr)(test_map_ptr)
+     (int_node_set_ptr)(test_node_map_ptr))(
+        (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(reserve_empty_test1,
+    ((int_set_ptr)(test_map_ptr)(int_node_set_ptr)(test_node_map_ptr)))
+  UNORDERED_TEST(reserve_empty_test2,
+    ((int_set_ptr)(test_map_ptr)(int_node_set_ptr)(test_node_map_ptr)))
+  UNORDERED_TEST(reserve_test1,
+    ((int_set_ptr)(test_map_ptr)(int_node_set_ptr)(test_node_map_ptr))(
+      (default_generator)(generate_collisions)(limited_range)))
+  UNORDERED_TEST(reserve_test2,
+    ((int_set_ptr)(test_map_ptr)(int_node_set_ptr)(test_node_map_ptr))(
       (default_generator)(generate_collisions)(limited_range)))
-  UNORDERED_TEST(
-    rehash_test1, ((int_set_ptr)(test_map_ptr))(
-                    (default_generator)(generate_collisions)(limited_range)))
-  UNORDERED_TEST(reserve_empty_test1, ((int_set_ptr)(test_map_ptr)))
-  UNORDERED_TEST(reserve_empty_test2, ((int_set_ptr)(test_map_ptr)))
-  UNORDERED_TEST(
-    reserve_test1, ((int_set_ptr)(test_map_ptr))(
-                     (default_generator)(generate_collisions)(limited_range)))
-  UNORDERED_TEST(
-    reserve_test2, ((int_set_ptr)(test_map_ptr))(
-                     (default_generator)(generate_collisions)(limited_range)))
   UNORDERED_TEST(rehash_empty_tracking,
-    ((test_set_tracking)(test_map_tracking))(
+    ((test_set_tracking)(test_map_tracking)
+     (test_node_set_tracking)(test_node_map_tracking))(
       (default_generator)(generate_collisions)(limited_range)))
-  UNORDERED_TEST(
-    rehash_nonempty_tracking, ((test_set_tracking)(test_map_tracking))(
-                                (default_generator)(limited_range)))
-  UNORDERED_TEST(rehash_stability, ((test_set_monotonic)(test_map_monotonic))(
-                                     (default_generator)(limited_range)))
+  UNORDERED_TEST(rehash_nonempty_tracking,
+    ((test_set_tracking)(test_map_tracking)
+     (test_node_set_tracking)(test_node_map_tracking))(
+      (default_generator)(limited_range)))
+  UNORDERED_TEST(rehash_stability,
+    ((test_set_monotonic)(test_map_monotonic)
+     (test_node_set_monotonic)(test_node_map_monotonic))(
+        (default_generator)(limited_range)))
+  UNORDERED_TEST(rehash_node_stability,
+    ((int_node_set_ptr)(test_node_map_ptr)
+     (test_node_set_tracking)(test_node_map_tracking))(
+      (default_generator)(generate_collisions)(limited_range)))
+  // clang-format on
 #else
   boost::unordered_set<int>* int_set_ptr;
   boost::unordered_multiset<test::object, test::hash, test::equal_to,
@@ -639,6 +703,7 @@ namespace rehash_tests {
     monotonic_allocator<std::pair<test::object const, test::object> > >*
     test_multimap_monotonic;
 
+  // clang-format off
   UNORDERED_TEST(rehash_empty_test1,
     ((int_set_ptr)(test_multiset_ptr)(test_map_ptr)(int_multimap_ptr)))
   UNORDERED_TEST(rehash_empty_test2,
@@ -669,6 +734,12 @@ namespace rehash_tests {
   UNORDERED_TEST(rehash_stability,
     ((test_set_monotonic)(test_multiset_monotonic)(test_map_monotonic)(test_multimap_monotonic))(
       (default_generator)(limited_range)))
+  UNORDERED_TEST(rehash_node_stability,
+    ((int_set_ptr)(test_map_ptr)(test_set_tracking)(test_map_tracking)
+     (test_multiset_ptr)(int_multimap_ptr)
+     (test_multiset_tracking)(test_multimap_tracking))(
+      (default_generator)(generate_collisions)(limited_range)))
+// clang-format on
 #endif
 } // namespace rehash_tests
 

test/unordered/reserve_tests.cpp

@@ -1,4 +1,4 @@
-// Copyright 2021-2022 Christian Mazakas.
+// Copyright 2021-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)
 
@@ -45,7 +45,8 @@ template <typename T> struct A
 
 template <class T> int A<T>::count = 0;
 
-template <class UnorderedContainer> void bucket_count_constructor()
+template <class UnorderedContainer>
+void bucket_count_constructor(UnorderedContainer*)
 {
   BOOST_TEST_EQ(num_allocations, 0u);
   BOOST_TEST_EQ(total_allocation, 0u);
@@ -64,7 +65,8 @@ template <class UnorderedContainer> void bucket_count_constructor()
   num_allocations = 0;
 }
 
-template <class UnorderedContainer> void range_bucket_constructor()
+template <class UnorderedContainer>
+void range_bucket_constructor(UnorderedContainer*)
 {
   BOOST_TEST_EQ(num_allocations, 0u);
   BOOST_TEST_EQ(total_allocation, 0u);
@@ -85,7 +87,7 @@ template <class UnorderedContainer> void range_bucket_constructor()
   num_allocations = 0;
 }
 
-template <class UnorderedContainer> void reserve_tests()
+template <class UnorderedContainer> void reserve_tests(UnorderedContainer*)
 {
   BOOST_TEST_EQ(num_allocations, 0u);
   BOOST_TEST_EQ(total_allocation, 0u);
@@ -124,7 +126,7 @@ template <class UnorderedContainer> void reserve_tests()
   num_allocations = 0;
 }
 
-template <class UnorderedContainer> void rehash_tests()
+template <class UnorderedContainer> void rehash_tests(UnorderedContainer*)
 {
   BOOST_TEST_EQ(num_allocations, 0u);
   BOOST_TEST_EQ(total_allocation, 0u);
@@ -191,89 +193,81 @@ template <class UnorderedContainer> void rehash_tests()
   num_allocations = 0;
 }
 
-UNORDERED_AUTO_TEST (unordered_set_reserve) {
-  {
-    // prove Allocator invariants
-    // from cppref:
-    // Given:
-    // * A, an Allocator type for type T
-    // * B, the corresponding Allocator type for some cv-unqualified object type
-    //   U (as obtained by rebinding A)
-    //
-    // Expression:
-    // A a(b)
-    //
-    // Return Type:
-    // Constructs `a` such that `B(a)==b` and `A(b)==a`.
-    // (Note: This implies that all allocators related by rebind maintain each
-    // other's resources, such as memory pools.)
-    //
-    //
-    typedef boost::allocator_rebind<A<int>, float>::type alloc_rebound;
-    alloc_rebound b;
-    A<int> a(b);
-    BOOST_ASSERT(alloc_rebound(a) == b);
-    BOOST_ASSERT(A<int>(b) == a);
-  }
-
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  typedef boost::unordered_flat_set<int*, boost::hash<int*>,
-    std::equal_to<int*>, A<int*> >
-    unordered_set;
-
-  typedef boost::unordered_flat_map<int*, int*, boost::hash<int*>,
-    std::equal_to<int*>, A<std::pair<int const*, int*> > >
-    unordered_map;
-
-  bucket_count_constructor<unordered_set>();
-  bucket_count_constructor<unordered_map>();
-
-  range_bucket_constructor<unordered_set>();
-  range_bucket_constructor<unordered_map>();
-
-  reserve_tests<unordered_set>();
-  reserve_tests<unordered_map>();
-
-  rehash_tests<unordered_set>();
-  rehash_tests<unordered_map>();
-
-#else
-  typedef boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
-    A<int> >
-    unordered_set;
-
-  typedef boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
-    A<int> >
-    unordered_multiset;
-
-  typedef boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
-    A<std::pair<int const, int> > >
-    unordered_map;
-
-  typedef boost::unordered_multimap<int, int, boost::hash<int>,
-    std::equal_to<int>, A<std::pair<int const, int> > >
-    unordered_multimap;
-
-  bucket_count_constructor<unordered_set>();
-  bucket_count_constructor<unordered_map>();
-  bucket_count_constructor<unordered_multiset>();
-  bucket_count_constructor<unordered_multimap>();
-
-  range_bucket_constructor<unordered_set>();
-  range_bucket_constructor<unordered_map>();
-  range_bucket_constructor<unordered_multiset>();
-  range_bucket_constructor<unordered_multimap>();
-
-  reserve_tests<unordered_set>();
-  reserve_tests<unordered_map>();
-  reserve_tests<unordered_multiset>();
-  reserve_tests<unordered_multimap>();
-
-  rehash_tests<unordered_set>();
-  rehash_tests<unordered_map>();
-  rehash_tests<unordered_multiset>();
-  rehash_tests<unordered_multimap>();
-#endif
+UNORDERED_AUTO_TEST (allocator_check) {
+  // prove Allocator invariants
+  // from cppref:
+  // Given:
+  // * A, an Allocator type for type T
+  // * B, the corresponding Allocator type for some cv-unqualified object type
+  //   U (as obtained by rebinding A)
+  //
+  // Expression:
+  // A a(b)
+  //
+  // Return Type:
+  // Constructs `a` such that `B(a)==b` and `A(b)==a`.
+  // (Note: This implies that all allocators related by rebind maintain each
+  // other's resources, such as memory pools.)
+  //
+  //
+  typedef boost::allocator_rebind<A<int>, float>::type alloc_rebound;
+  alloc_rebound b;
+  A<int> a(b);
+  BOOST_ASSERT(alloc_rebound(a) == b);
+  BOOST_ASSERT(A<int>(b) == a);
 }
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+static boost::unordered_flat_set<int*, boost::hash<int*>, std::equal_to<int*>,
+  A<int*> >* test_set;
+static boost::unordered_flat_map<int*, int*, boost::hash<int*>,
+  std::equal_to<int*>, A<std::pair<int const*, int*> > >* test_map;
+
+static boost::unordered_node_set<int*, boost::hash<int*>, std::equal_to<int*>,
+  A<int*> >* test_node_set;
+
+static boost::unordered_node_map<int*, int*, boost::hash<int*>,
+  std::equal_to<int*>, A<std::pair<int const*, int*> > >* test_node_map;
+
+// clang-format off
+UNORDERED_TEST(bucket_count_constructor,
+  ((test_set)(test_map)(test_node_set)(test_node_map)))
+
+UNORDERED_TEST(range_bucket_constructor,
+  ((test_set)(test_map)(test_node_set)(test_node_map)))
+
+UNORDERED_TEST(reserve_tests,
+  ((test_set)(test_map)(test_node_set)(test_node_map)))
+
+UNORDERED_TEST(rehash_tests,
+  ((test_set)(test_map)(test_node_set)(test_node_map)))
+// clang-format on
+#else
+static boost::unordered_set<int, boost::hash<int>, std::equal_to<int>, A<int> >*
+  test_set;
+
+static boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
+  A<int> >* test_multiset;
+
+static boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+  A<std::pair<int const, int> > >* test_map;
+
+static boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
+  A<std::pair<int const, int> > >* test_multimap;
+
+// clang-format off
+UNORDERED_TEST(bucket_count_constructor,
+  ((test_set)(test_map)(test_multiset)(test_multimap)))
+
+UNORDERED_TEST(range_bucket_constructor,
+  ((test_set)(test_map)(test_multiset)(test_multimap)))
+
+UNORDERED_TEST(reserve_tests,
+  ((test_set)(test_map)(test_multiset)(test_multimap)))
+
+UNORDERED_TEST(rehash_tests,
+  ((test_set)(test_map)(test_multiset)(test_multimap)))
+// clang-format on
+#endif
+
 RUN_TESTS()

test/unordered/scary_tests.cpp

@@ -312,7 +312,10 @@ void set_scary_test()
 UNORDERED_AUTO_TEST (scary_tests) {
 #ifdef BOOST_UNORDERED_FOA_TESTS
   map_scary_test<boost::unordered_flat_map>();
+  map_scary_test<boost::unordered_node_map>();
+
   set_scary_test<boost::unordered_flat_set>();
+  set_scary_test<boost::unordered_node_set>();
 #else
   map_scary_test<boost::unordered_map>();
   map_scary_test<boost::unordered_multimap>();

test/unordered/scoped_allocator.cpp

@@ -1,5 +1,5 @@
 
-// Copyright 2021-2022 Christian Mazakas.
+// Copyright 2021-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)
 
@@ -65,21 +65,12 @@ typedef std::scoped_allocator_adaptor<test::allocator<pair_type>,
   test::allocator<boost::uint64_t> >
   allocator_type;
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
-typedef boost::unordered_flat_map<const boost::uint64_t, vector_type,
-  boost::hash<boost::uint64_t>, std::equal_to<boost::uint64_t>, allocator_type>
-  map_type;
-#else
-typedef boost::unordered_map<const boost::uint64_t, vector_type,
-  boost::hash<boost::uint64_t>, std::equal_to<boost::uint64_t>, allocator_type>
-  map_type;
-#endif
-
-UNORDERED_AUTO_TEST (scoped_allocator) {
+template <class X> static void scoped_allocator(X*)
+{
   allocator_type alloc(
     test::allocator<pair_type>(1337), test::allocator<boost::uint64_t>(7331));
 
-  map_type map(alloc);
+  X map(alloc);
 
   for (unsigned i = 0; i < 10; ++i) {
     boost::ignore_unused(map[i]);
@@ -88,6 +79,24 @@ UNORDERED_AUTO_TEST (scoped_allocator) {
   BOOST_TEST(map.size() == 10);
 }
 
+#ifdef BOOST_UNORDERED_FOA_TESTS
+static boost::unordered_flat_map<const boost::uint64_t, vector_type,
+  boost::hash<boost::uint64_t>, std::equal_to<boost::uint64_t>, allocator_type>*
+  test_map;
+
+static boost::unordered_node_map<const boost::uint64_t, vector_type,
+  boost::hash<boost::uint64_t>, std::equal_to<boost::uint64_t>, allocator_type>*
+  test_node_map;
+
+UNORDERED_TEST(scoped_allocator, ((test_map)(test_node_map)))
+#else
+static boost::unordered_map<const boost::uint64_t, vector_type,
+  boost::hash<boost::uint64_t>, std::equal_to<boost::uint64_t>, allocator_type>*
+  test_map;
+
+UNORDERED_TEST(scoped_allocator, ((test_map)))
+#endif
+
 RUN_TESTS()
 
 #endif

test/unordered/simple_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -8,10 +8,13 @@
 
 #include "../helpers/unordered.hpp"
 
-#include "../helpers/test.hpp"
-#include <cstdlib>
-#include <algorithm>
 #include "../helpers/equivalent.hpp"
+#include "../helpers/generators.hpp"
+#include "../helpers/test.hpp"
+#include <algorithm>
+#include <cstdlib>
+
+test::seed_t initialize_seed(14878);
 
 template <class X> void simple_test(X const& a)
 {
@@ -84,59 +87,76 @@ template <class X> void simple_test(X const& a)
   }
 }
 
-UNORDERED_AUTO_TEST (simple_tests) {
-  using namespace std;
-  srand(14878);
+template <class X> static void simple_set_tests(X*)
+{
+  X x;
 
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_set.\n";
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_set<int> set;
-#else
-  boost::unordered_set<int> set;
-#endif
-  simple_test(set);
+  simple_test(x);
 
-  set.insert(1);
-  set.insert(2);
-  set.insert(1456);
-  simple_test(set);
+  x.insert(1);
+  x.insert(2);
+  x.insert(1456);
+  simple_test(x);
+}
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
-  boost::unordered_multiset<int> multiset;
-  simple_test(multiset);
+template <class X> static void simple_multiset_tests(X*)
+{
+  X x;
+  simple_test(x);
 
   for (int i1 = 0; i1 < 1000; ++i1) {
     int count = rand() % 10, index = rand();
     for (int j = 0; j < count; ++j)
-      multiset.insert(index);
+      x.insert(index);
   }
-  simple_test(multiset);
+  simple_test(x);
+}
 #endif
 
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_map.\n";
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  boost::unordered_flat_map<int, int> map;
-#else
-  boost::unordered_map<int, int> map;
-#endif
+template <class X> static void simple_map_tests(X*)
+{
+  X x;
 
   for (int i2 = 0; i2 < 1000; ++i2) {
-    map.insert(std::pair<const int, int>(rand(), rand()));
+    x.insert(std::pair<const int, int>(rand(), rand()));
   }
-  simple_test(map);
+  simple_test(x);
+}
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
-  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
-  boost::unordered_multimap<int, int> multimap;
+template <class X> static void simple_multimap_tests(X*)
+{
+  X x;
 
   for (int i3 = 0; i3 < 1000; ++i3) {
     int count = rand() % 10, index = rand();
     for (int j = 0; j < count; ++j)
-      multimap.insert(std::pair<const int, int>(index, rand()));
+      x.insert(std::pair<const int, int>(index, rand()));
   }
-  simple_test(multimap);
-#endif
+  simple_test(x);
 }
+#endif
+
+#ifdef BOOST_UNORDERED_FOA_TESTS
+static boost::unordered_flat_set<int>* flat_set;
+static boost::unordered_flat_map<int, int>* flat_map;
+static boost::unordered_node_set<int>* node_set;
+static boost::unordered_node_map<int, int>* node_map;
+
+UNORDERED_TEST(simple_map_tests, ((flat_map)(node_map)))
+UNORDERED_TEST(simple_set_tests, ((flat_set)(node_set)))
+#else
+static boost::unordered_set<int>* set;
+static boost::unordered_map<int, int>* map;
+static boost::unordered_multiset<int>* multiset;
+static boost::unordered_multimap<int, int>* multimap;
+
+UNORDERED_TEST(simple_set_tests, ((set)))
+UNORDERED_TEST(simple_map_tests, ((map)))
+UNORDERED_TEST(simple_multiset_tests, ((multiset)))
+UNORDERED_TEST(simple_multimap_tests, ((multimap)))
+
+#endif
 
 RUN_TESTS()

test/unordered/swap_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022 Christian Mazakas.
+// Copyright 2022-2023 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -168,19 +168,58 @@ namespace swap_tests {
     test::cxx11_allocator<test::object, test::no_propagate_swap> >*
     test_map_no_prop_swap;
 
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to, std::allocator<test::object> >* test_node_map_std_alloc;
+
+  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::propagate_swap> >*
+    test_node_set_prop_swap;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to, test::cxx11_allocator<test::object, test::propagate_swap> >*
+    test_node_map_prop_swap;
+
+  boost::unordered_node_set<test::object, test::hash, test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_node_set_no_prop_swap;
+  boost::unordered_node_map<test::object, test::object, test::hash,
+    test::equal_to,
+    test::cxx11_allocator<test::object, test::no_propagate_swap> >*
+    test_node_map_no_prop_swap;
+
   UNORDERED_AUTO_TEST (check_traits) {
     BOOST_TEST(!is_propagate(test_set));
     BOOST_TEST(is_propagate(test_set_prop_swap));
     BOOST_TEST(!is_propagate(test_set_no_prop_swap));
+
+    BOOST_TEST(!is_propagate(test_node_set));
+    BOOST_TEST(is_propagate(test_node_set_prop_swap));
+    BOOST_TEST(!is_propagate(test_node_set_no_prop_swap));
   }
 
+// clang-format off
   UNORDERED_TEST(swap_tests1,
-    ((test_map_std_alloc)(test_set)(test_map)(test_set_prop_swap)(test_map_prop_swap)(test_set_no_prop_swap)(test_map_no_prop_swap))(
+    ((test_map_std_alloc)(test_set)(test_map)
+     (test_set_prop_swap)(test_map_prop_swap)
+     (test_set_no_prop_swap)(test_map_no_prop_swap)
+     (test_node_map_std_alloc)(test_node_set)(test_node_map)
+     (test_node_set_prop_swap)(test_node_map_prop_swap)
+     (test_node_set_no_prop_swap)(test_node_map_no_prop_swap))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(swap_tests2,
-    ((test_set)(test_map)(test_set_prop_swap)(test_map_prop_swap)(test_set_no_prop_swap)(test_map_no_prop_swap))(
+    ((test_set)(test_map)
+     (test_set_prop_swap)(test_map_prop_swap)
+     (test_set_no_prop_swap)(test_map_no_prop_swap)
+     (test_node_set)(test_node_map)
+     (test_node_set_prop_swap)(test_node_map_prop_swap)
+     (test_node_set_no_prop_swap)(test_node_map_no_prop_swap))(
       (default_generator)(generate_collisions)(limited_range)))
+// clang-format on
 #else
   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
     std::allocator<test::object> >* test_map_std_alloc;