optimized SSE2-based group15

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

.github/workflows/ci.yml

@@ -72,8 +72,7 @@ jobs:
               compiler: clang-14,  cxxstd: '17,20,2b',          os: ubuntu-22.04, ccache_key: "san2" }
 
           # OSX, clang
-          - { compiler: clang,     cxxstd: '03,11,14,17,2a',    os: macos-11, }
-          - { compiler: clang,     cxxstd: '03,11,14,17,2a',    os: macos-12, sanitize: yes }
+          - { compiler: clang,     cxxstd: '03,11,14,17,2a',    os: macos-11, sanitize: yes }
 
     timeout-minutes: 120
     runs-on: ${{matrix.os}}

.gitignore

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

doc/unordered/changes.adoc

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

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

doc/unordered/unordered_flat_set.adoc

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

doc/unordered/unordered_map.adoc

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

doc/unordered/unordered_multimap.adoc

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

doc/unordered/unordered_multiset.adoc

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

doc/unordered/unordered_set.adoc

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

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

@@ -1,196 +0,0 @@
-/* Copyright 2023 Christian Mazakas.
- * Distributed under the Boost Software License, Version 1.0.
- * (See accompanying file LICENSE_1_0.txt or copy at
- * http://www.boost.org/LICENSE_1_0.txt)
- *
- * See https://www.boost.org/libs/unordered for library home page.
- */
-
-#ifndef BOOST_UNORDERED_DETAIL_FOA_NODE_HANDLE_HPP
-#define BOOST_UNORDERED_DETAIL_FOA_NODE_HANDLE_HPP
-
-#include <boost/config.hpp>
-#include <boost/core/allocator_access.hpp>
-
-namespace boost{
-namespace unordered{
-namespace detail{
-namespace foa{
-
-template <class Iterator,class NodeType>
-struct insert_return_type
-{
-  Iterator position;
-  bool     inserted;
-  NodeType node;
-};
-
-template <class T>
-union opt_storage {
-  BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS T t_;
-
-  opt_storage(){}
-  ~opt_storage(){}
-};
-
-template <class TypePolicy,class Allocator>
-struct node_handle_base
-{
-  protected:
-    using type_policy=TypePolicy;
-    using element_type=typename type_policy::element_type;
-
-  public:
-    using allocator_type = Allocator;
-
-  private:
-    using node_value_type=typename type_policy::value_type;
-    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,22 +1477,7 @@ namespace boost {
         }
 
 #endif
-
-        template <typename T, typename Alloc, typename Key>
-        inline typename boost::allocator_pointer<Alloc>::type
-        construct_node_from_key(T*, Alloc& alloc, BOOST_FWD_REF(Key) k)
-        {
-          return construct_node(alloc, boost::forward<Key>(k));
-        }
-
-        template <typename T, typename V, typename Alloc, typename Key>
-        inline typename boost::allocator_pointer<Alloc>::type
-        construct_node_from_key(
-          std::pair<T const, V>*, Alloc& alloc, BOOST_FWD_REF(Key) k)
-        {
-          return construct_node_pair(alloc, boost::forward<Key>(k));
-        }
-      } // namespace func
+      }
     }
   }
 }
@@ -2655,10 +2640,8 @@ namespace boost {
           } else {
             node_allocator_type alloc = node_alloc();
 
-            value_type* dispatch = BOOST_NULLPTR;
-
-            node_tmp tmp(detail::func::construct_node_from_key(
-                           dispatch, alloc, boost::forward<Key>(k)),
+            node_tmp tmp(
+              detail::func::construct_node_pair(alloc, boost::forward<Key>(k)),
               alloc);
 
             if (size_ + 1 > max_load_) {
@@ -2677,7 +2660,7 @@ namespace boost {
         template <typename Key>
         iterator try_emplace_hint_unique(c_iterator hint, BOOST_FWD_REF(Key) k)
         {
-          if (hint.p && this->key_eq()(extractor::extract(*hint), k)) {
+          if (hint.p && this->key_eq()(hint->first, k)) {
             return iterator(hint.p, hint.itb);
           } else {
             return try_emplace_unique(k).first;

include/boost/unordered/detail/mulx.hpp

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

include/boost/unordered/detail/narrow_cast.hpp

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

include/boost/unordered/detail/prime_fmod.hpp

@@ -11,7 +11,6 @@
 #include <boost/preprocessor/seq/enum.hpp>
 #include <boost/preprocessor/seq/for_each.hpp>
 #include <boost/preprocessor/seq/size.hpp>
-#include <boost/unordered/detail/narrow_cast.hpp>
 
 #include <boost/config.hpp>
 
@@ -118,9 +117,15 @@ 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(
-              narrow_cast<boost::uint32_t>(hash) + narrow_cast<boost::uint32_t>(hash >> 32),
+              boost::uint32_t(hash & 0xffffffffu) + 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 Hash, class KeyEqual> struct are_transparent
+      template <class, class A, class B> struct are_transparent
       {
         static bool const value =
-          is_transparent<Hash>::value && is_transparent<KeyEqual>::value;
+          is_transparent<A>::value && is_transparent<B>::value;
       };
 
       template <class Key, class UnorderedMap> struct transparent_non_iterable

include/boost/unordered/unordered_flat_map.hpp

@@ -32,8 +32,10 @@ namespace boost {
 #pragma warning(disable : 4714) /* marked as __forceinline not inlined */
 #endif
 
-    namespace detail {
-      template <class Key, class T> struct flat_map_types
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    class unordered_flat_map
+    {
+      struct map_types
       {
         using key_type = Key;
         using raw_key_type = typename std::remove_const<Key>::type;
@@ -43,46 +45,19 @@ namespace boost {
         using moved_type = std::pair<raw_key_type&&, raw_mapped_type&&>;
         using value_type = std::pair<Key const, T>;
 
-        using element_type = value_type;
-
-        static value_type& value_from(element_type& x) { return x; }
-
         template <class K, class V>
         static raw_key_type const& extract(std::pair<K, V> const& kv)
         {
           return kv.first;
         }
 
-        static moved_type move(element_type& x)
+        static moved_type move(value_type& x)
         {
           // TODO: we probably need to launder here
           return {std::move(const_cast<raw_key_type&>(x.first)),
             std::move(const_cast<raw_mapped_type&>(x.second))};
         }
-
-        template <class A>
-        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,
@@ -303,37 +278,24 @@ namespace boost {
       template <class M>
       std::pair<iterator, bool> insert_or_assign(key_type const& key, M&& obj)
       {
-        auto ibp = table_.try_emplace(key, std::forward<M>(obj));
-        if (ibp.second) {
-          return ibp;
+        auto iter_bool_pair = table_.try_emplace(key, std::forward<M>(obj));
+        if (iter_bool_pair.second) {
+          return iter_bool_pair;
         }
-        ibp.first->second = std::forward<M>(obj);
-        return ibp;
+        iter_bool_pair.first->second = std::forward<M>(obj);
+        return iter_bool_pair;
       }
 
       template <class M>
       std::pair<iterator, bool> insert_or_assign(key_type&& key, M&& obj)
       {
-        auto ibp = table_.try_emplace(std::move(key), std::forward<M>(obj));
-        if (ibp.second) {
-          return ibp;
+        auto iter_bool_pair =
+          table_.try_emplace(std::move(key), std::forward<M>(obj));
+        if (iter_bool_pair.second) {
+          return iter_bool_pair;
         }
-        ibp.first->second = std::forward<M>(obj);
-        return ibp;
-      }
-
-      template <class K, class M>
-      typename std::enable_if<
-        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
-        std::pair<iterator, bool> >::type
-      insert_or_assign(K&& k, M&& obj)
-      {
-        auto ibp = table_.try_emplace(std::forward<K>(k), std::forward<M>(obj));
-        if (ibp.second) {
-          return ibp;
-        }
-        ibp.first->second = std::forward<M>(obj);
-        return ibp;
+        iter_bool_pair.first->second = std::forward<M>(obj);
+        return iter_bool_pair;
       }
 
       template <class M>
@@ -349,16 +311,6 @@ namespace boost {
           .first;
       }
 
-      template <class K, class M>
-      typename std::enable_if<
-        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
-        iterator>::type
-      insert_or_assign(const_iterator, K&& k, M&& obj)
-      {
-        return this->insert_or_assign(std::forward<K>(k), std::forward<M>(obj))
-          .first;
-      }
-
       template <class... Args>
       BOOST_FORCEINLINE std::pair<iterator, bool> emplace(Args&&... args)
       {
@@ -385,17 +337,6 @@ namespace boost {
         return table_.try_emplace(std::move(key), std::forward<Args>(args)...);
       }
 
-      template <class K, class... Args>
-      BOOST_FORCEINLINE typename std::enable_if<
-        boost::unordered::detail::transparent_non_iterable<K,
-          unordered_flat_map>::value,
-        std::pair<iterator, bool> >::type
-      try_emplace(K&& key, Args&&... args)
-      {
-        return table_.try_emplace(
-          std::forward<K>(key), std::forward<Args>(args)...);
-      }
-
       template <class... Args>
       BOOST_FORCEINLINE iterator try_emplace(
         const_iterator, key_type const& key, Args&&... args)
@@ -411,18 +352,6 @@ namespace boost {
           .first;
       }
 
-      template <class K, class... Args>
-      BOOST_FORCEINLINE typename std::enable_if<
-        boost::unordered::detail::transparent_non_iterable<K,
-          unordered_flat_map>::value,
-        iterator>::type
-      try_emplace(const_iterator, K&& key, Args&&... args)
-      {
-        return table_
-          .try_emplace(std::forward<K>(key), std::forward<Args>(args)...)
-          .first;
-      }
-
       BOOST_FORCEINLINE void erase(iterator pos) { table_.erase(pos); }
       BOOST_FORCEINLINE void erase(const_iterator pos)
       {
@@ -498,34 +427,6 @@ 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;
@@ -536,15 +437,6 @@ namespace boost {
         return table_.try_emplace(std::move(key)).first->second;
       }
 
-      template <class K>
-      typename std::enable_if<
-        boost::unordered::detail::are_transparent<K, hasher, key_equal>::value,
-        mapped_type&>::type
-      operator[](K&& key)
-      {
-        return table_.try_emplace(std::forward<K>(key)).first->second;
-      }
-
       BOOST_FORCEINLINE size_type count(key_type const& key) const
       {
         auto pos = table_.find(key);

include/boost/unordered/unordered_flat_set.hpp

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

include/boost/unordered/unordered_map.hpp

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

include/boost/unordered/unordered_node_map.hpp

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

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

include/boost/unordered/unordered_node_set.hpp

@@ -1,772 +0,0 @@
-// Copyright (C) 2022 Christian Mazakas
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-#ifndef BOOST_UNORDERED_UNORDERED_NODE_SET_HPP_INCLUDED
-#define BOOST_UNORDERED_UNORDERED_NODE_SET_HPP_INCLUDED
-
-#include <boost/config.hpp>
-#if defined(BOOST_HAS_PRAGMA_ONCE)
-#pragma once
-#endif
-
-#include <boost/unordered/detail/foa.hpp>
-#include <boost/unordered/detail/foa/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

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

include/boost/unordered/unordered_set.hpp

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

test/Jamfile.v2

@@ -1,6 +1,6 @@
 
 # Copyright 2006-2008 Daniel James.
-# Copyright 2022-2023 Christian Mazakas
+# Copyright 2022 Christian Mazakas
 # Distributed under the Boost Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -26,7 +26,6 @@ project
 
         <toolset>gcc-4.4:<cxxflags>-Wno-strict-aliasing
         <toolset>gcc-4.4:<cxxflags>-fno-deduce-init-list
-        <toolset>clang-14:<cxxflags>-Wunused-template
 
         <toolset>gcc:<warnings-as-errors>on
         <toolset>clang:<warnings-as-errors>on
@@ -95,9 +94,7 @@ run exception/erase_exception_tests.cpp ;
 run exception/rehash_exception_tests.cpp ;
 run exception/swap_exception_tests.cpp : : : <define>BOOST_UNORDERED_SWAP_METHOD=2 ;
 run exception/merge_exception_tests.cpp ;
-run exception/less_tests.cpp ;
 
-run unordered/narrow_cast_tests.cpp ;
 run quick.cpp ;
 
 import ../../config/checks/config : requires ;
@@ -142,8 +139,6 @@ build_foa erase_if ;
 build_foa scary_tests ;
 build_foa init_type_insert_tests ;
 build_foa max_load_tests ;
-build_foa extract_tests ;
-build_foa node_handle_tests ;
 
 run unordered/hash_is_avalanching_test.cpp ;
 

test/cmake_subdir_test/CMakeLists.txt

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

test/exception/assign_exception_tests.cpp

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

test/exception/containers.hpp

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

test/exception/insert_exception_tests.cpp

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

test/exception/less_tests.cpp

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

test/exception/merge_exception_tests.cpp

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

test/exception/move_assign_exception_tests.cpp

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

test/exception/swap_exception_tests.cpp

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

test/helpers/invariants.hpp

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

test/helpers/tracker.hpp

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

test/helpers/unordered.hpp

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

test/objects/exception.hpp

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

test/objects/minimal.hpp

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

test/objects/test.hpp

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

test/unordered/assign_tests.cpp

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

test/unordered/at_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2007-2009 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -11,12 +11,16 @@
 
 namespace at_tests {
 
-  template <class X> static void at_tests(X*)
-  {
+  UNORDERED_AUTO_TEST (at_tests) {
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Create Map" << std::endl;
 
-    X x;
-    X const& x_const(x);
+#ifdef BOOST_UNORDERED_FOA_TESTS
+    boost::unordered_flat_map<std::string, int> x;
+    boost::unordered_flat_map<std::string, int> const& x_const(x);
+#else
+    boost::unordered_map<std::string, int> x;
+    boost::unordered_map<std::string, int> const& x_const(x);
+#endif
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Check empty container" << std::endl;
 
@@ -60,21 +64,6 @@ namespace at_tests {
 
     BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Finished" << std::endl;
   }
-
-#ifdef BOOST_UNORDERED_FOA_TESTS
-  static boost::unordered_flat_map<std::string, int>* test_map;
-  static boost::unordered_node_map<std::string, int>* test_node_map;
-
-  // clang-format off
-  UNORDERED_TEST(at_tests, ((test_map)(test_node_map)))
-  // clang-format on
-#else
-  static boost::unordered_map<std::string, int>* test_map;
-
-  // clang-format off
-  UNORDERED_TEST(at_tests, ((test_map)))
-  // clang-format on
-#endif
-} // namespace at_tests
+}
 
 RUN_TESTS()

test/unordered/compile_map.cpp

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

test/unordered/compile_set.cpp

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

test/unordered/constructor_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2010 Daniel James.
-// Copyright (C) 2022-2023 Christian Mazakas
+// Copyright (C) 2022 Christian Mazakas
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -655,27 +655,23 @@ namespace constructor_tests {
 
   boost::unordered_flat_set<test::object, test::hash, test::equal_to,
     test::allocator1<test::object> >* test_set;
-  boost::unordered_node_set<test::object, test::hash, test::equal_to,
-    test::allocator1<test::object> >* test_node_set;
   boost::unordered_flat_map<test::object, test::object, test::hash,
     test::equal_to, test::allocator2<test::object> >* test_map;
-  boost::unordered_node_map<test::object, test::object, test::hash,
-    test::equal_to, test::allocator2<test::object> >* test_node_map;
 
   UNORDERED_TEST(constructor_tests1,
-    ((test_map_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_map_std_alloc)(test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(constructor_tests2,
-    ((test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(map_constructor_test,
-    ((test_map_std_alloc)(test_map)(test_node_map))(
+    ((test_map_std_alloc)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(no_alloc_default_construct_test,
-    ((test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 #else
   boost::unordered_map<test::object, test::object, test::hash, test::equal_to,
@@ -713,8 +709,6 @@ namespace constructor_tests {
     std::initializer_list<int> init;
 #ifdef BOOST_UNORDERED_FOA_TESTS
     boost::unordered_flat_set<int> x1 = init;
-    boost::unordered_node_set<int> x2 = init;
-    BOOST_TEST(x2.empty());
 #else
     boost::unordered_set<int> x1 = init;
 #endif
@@ -728,9 +722,6 @@ namespace constructor_tests {
   UNORDERED_AUTO_TEST (test_initializer_list) {
 #ifdef BOOST_UNORDERED_FOA_TESTS
     boost::unordered_flat_set<int> x1 = {2, 10, 45, -5};
-    boost::unordered_node_set<int> x2 = {2, 10, 45, -5};
-    BOOST_TEST(x2.find(10) != x2.end());
-    BOOST_TEST(x2.find(46) == x2.end());
 #else
     boost::unordered_set<int> x1 = {2, 10, 45, -5};
 #endif

test/unordered/contains_tests.cpp

@@ -1,4 +1,4 @@
-// Copyright 2021-2023 Christian Mazakas.
+// Copyright 2021-2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -137,24 +137,6 @@ void test_map()
 
   typedef boost::unordered_flat_map<key, int, hasher, key_equal>
     non_transparent_map3;
-
-  typedef boost::unordered_node_map<key, int, transparent_hasher,
-    transparent_key_equal>
-    transparent_node_map;
-
-  typedef boost::unordered_node_map<key, int, transparent_hasher, key_equal>
-    non_transparent_node_map1;
-
-  typedef boost::unordered_node_map<key, int, hasher, transparent_key_equal>
-    non_transparent_node_map2;
-
-  typedef boost::unordered_node_map<key, int, hasher, key_equal>
-    non_transparent_node_map3;
-
-  test_map_transparent_contains<transparent_node_map>();
-  test_map_non_transparent_contains<non_transparent_node_map1>();
-  test_map_non_transparent_contains<non_transparent_node_map2>();
-  test_map_non_transparent_contains<non_transparent_node_map3>();
 #else
   typedef boost::unordered_map<key, int, transparent_hasher,
     transparent_key_equal>
@@ -272,22 +254,6 @@ void test_set()
     non_transparent_set2;
   typedef boost::unordered_flat_set<key, hasher, key_equal>
     non_transparent_set3;
-
-  typedef boost::unordered_node_set<key, transparent_hasher,
-    transparent_key_equal>
-    transparent_node_set;
-
-  typedef boost::unordered_node_set<key, transparent_hasher, key_equal>
-    non_transparent_node_set1;
-  typedef boost::unordered_node_set<key, hasher, transparent_key_equal>
-    non_transparent_node_set2;
-  typedef boost::unordered_node_set<key, hasher, key_equal>
-    non_transparent_node_set3;
-
-  test_set_transparent_contains<transparent_node_set>();
-  test_set_non_transparent_contains<non_transparent_node_set1>();
-  test_set_non_transparent_contains<non_transparent_node_set2>();
-  test_set_non_transparent_contains<non_transparent_node_set3>();
 #else
   typedef boost::unordered_set<key, transparent_hasher, transparent_key_equal>
     transparent_set;

test/unordered/copy_tests.cpp

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

test/unordered/emplace_tests.cpp

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

test/unordered/equality_tests.cpp

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

test/unordered/equivalent_keys_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -36,21 +36,9 @@ 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);
@@ -64,8 +52,6 @@ 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) {
@@ -79,16 +65,11 @@ 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));
 
-#ifdef BOOST_UNORDERED_FOA_TESTS
   for (int i = 0; i < 5; ++i)
+#ifdef BOOST_UNORDERED_FOA_TESTS
     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,8 +110,6 @@ 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,16 +270,10 @@ 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)(test_node_set)(test_node_map))(
+    erase_tests1, ((test_set)(test_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;
@@ -290,11 +284,10 @@ 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,10 +1,14 @@
 
 // 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/unordered.hpp"
+// 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/equivalent.hpp"
 #include "../helpers/helpers.hpp"
@@ -109,19 +113,6 @@ 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,
@@ -131,10 +122,12 @@ 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-2023 Christian Mazakas
+// Copyright (C) 2022 Christian Mazakas
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -138,13 +138,9 @@ 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)(test_node_set)(test_node_map))(
+    find_tests1, ((test_set)(test_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-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -8,7 +8,6 @@
 #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>
@@ -24,13 +23,6 @@ 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)
@@ -38,13 +30,6 @@ 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)
@@ -52,15 +37,7 @@ 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)
@@ -108,7 +85,6 @@ 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;
@@ -130,24 +106,6 @@ 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-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -8,7 +8,6 @@
 #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>
@@ -32,22 +31,12 @@ 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)
@@ -55,26 +44,12 @@ 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(
@@ -125,7 +100,6 @@ 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;
@@ -133,15 +107,10 @@ 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
@@ -149,16 +118,9 @@ 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;
@@ -176,24 +138,6 @@ 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-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -13,12 +13,11 @@ 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.
@@ -34,11 +33,11 @@ namespace incomplete_test {
   typedef boost::unordered_flat_map<value, value, hash, equals,
     allocator<std::pair<value const, value> > >
     map;
-  typedef boost::unordered_flat_set<value, hash, equals, allocator<value> > set;
-  typedef boost::unordered_node_map<value, value, hash, equals,
+  typedef boost::unordered_flat_map<value, value, hash, equals,
     allocator<std::pair<value const, value> > >
     multimap;
-  typedef boost::unordered_node_set<value, hash, equals, allocator<value> >
+  typedef boost::unordered_flat_set<value, hash, equals, allocator<value> > set;
+  typedef boost::unordered_flat_set<value, hash, equals, allocator<value> >
     multiset;
 #else
   typedef boost::unordered_map<value, value, hash, equals,
@@ -98,7 +97,7 @@ namespace incomplete_test {
   };
   struct struct2
   {
-    boost::unordered_node_map<struct2, struct2, hash, equals,
+    boost::unordered_flat_map<struct2, struct2, hash, equals,
       allocator<std::pair<struct2 const, struct2> > >
       x;
   };
@@ -108,7 +107,7 @@ namespace incomplete_test {
   };
   struct struct4
   {
-    boost::unordered_node_set<struct4, hash, equals, allocator<struct4> > x;
+    boost::unordered_flat_set<struct4, hash, equals, allocator<struct4> > x;
   };
 #else
   struct struct1
@@ -196,7 +195,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,16 +7,9 @@
 #error "This test is only for the FOA-style conatiners"
 #endif
 
-#include "../helpers/test.hpp"
 #include "../helpers/unordered.hpp"
 
-#include <boost/config.hpp>
-
-#if defined(BOOST_LIBSTDCXX_VERSION)
-#if BOOST_LIBSTDCXX_VERSION < 60000
-#define BOOST_UNORDERED_NO_INIT_TYPE_TESTS
-#endif
-#endif
+#include "../helpers/test.hpp"
 
 struct move_only
 {
@@ -33,49 +26,18 @@ struct move_only
   }
 };
 
-namespace std {
+namespace std{
 
-  template <> struct hash<move_only>
-  {
-    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
+template <> struct hash<move_only>
 {
-  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)
+  std::size_t operator()(move_only const& mo) const noexcept
   {
-    return lhs.x_ == rhs.x_;
+    return std::hash<int>()(mo.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;
@@ -106,15 +68,15 @@ struct raii_tracker
   }
 };
 
-namespace std {
+namespace std{
 
-  template <> struct hash<raii_tracker>
+template <> struct hash<raii_tracker>
+{
+  std::size_t operator()(raii_tracker const& rt) const noexcept
   {
-    std::size_t operator()(raii_tracker const& rt) const noexcept
-    {
-      return std::hash<int>()(rt.x_);
-    }
-  };
+    return std::hash<int>()(rt.x_);
+  }
+};
 
 } // namespace std
 
@@ -128,7 +90,9 @@ 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<std::pair<move_only, int>, init_type>::value, "");
+  static_assert(
+    std::is_same<decltype(std::make_pair(move_only(1), v)), init_type>::value,
+    "");
 
   map.insert(std::make_pair(move_only(1), v));
   map.insert({move_only(2), v});
@@ -271,167 +235,10 @@ 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-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -88,11 +88,12 @@ namespace insert_hint {
     }
   }
 #endif
-
-  template <class X> static void insert_hint_unique(X*)
-  {
-    typedef X container;
-
+  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
     container x;
     x.insert(x.cbegin(), 10);
     BOOST_TEST_EQ(x.size(), 1u);
@@ -100,10 +101,12 @@ namespace insert_hint {
     test::check_equivalent_keys(x);
   }
 
-  template <class X> static void insert_hint_unique_single(X*)
-  {
-    typedef X container;
-
+  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
     container x;
     x.insert(10);
 
@@ -118,18 +121,6 @@ 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-2023 Christian Mazakas
+// Copyright (C) 2022 Christian Mazakas
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -17,7 +17,6 @@
 #include "../helpers/input_iterator.hpp"
 #include "../helpers/helpers.hpp"
 
-#include <boost/move/core.hpp>
 #include <vector>
 
 namespace insert_tests {
@@ -220,7 +219,7 @@ namespace insert_tests {
       test::check_instances check_;
 
       X x;
-      iterator pos = x.begin();
+      const_iterator pos = x.begin();
       tracker_type tracker = test::create_ordered(x);
 
       test::random_values<X> v(1000, generator);
@@ -248,7 +247,7 @@ namespace insert_tests {
       test::check_instances check_;
 
       X x;
-      iterator pos = x.begin();
+      const_iterator pos = x.begin();
       tracker_type tracker = test::create_ordered(x);
 
       test::random_values<X> v(1000, generator);
@@ -694,69 +693,6 @@ 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)
   {
@@ -956,62 +892,45 @@ 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_node_set_std_alloc)
-     (test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_set_std_alloc)(test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(
-    insert_tests2, ((test_set)(test_node_set)(test_map)(test_node_map))(
+    insert_tests2, ((test_set)(test_map))(
                      (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(unique_emplace_tests1,
-    ((test_set_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_set_std_alloc)(test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(move_emplace_tests,
-    ((test_set_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_set_std_alloc)(test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(default_emplace_tests,
-    ((test_set_std_alloc)(test_set)(test_node_set)(test_map)(test_node_map))(
+    ((test_set_std_alloc)(test_set)(test_map))(
       (default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(map_tests,
-    ((test_map)(test_node_map))
-    ((default_generator)(generate_collisions)(limited_range)))
+    ((test_map))((default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(
-    map_tests2, ((test_map)(test_node_map))((default_generator)(generate_collisions)))
+    map_tests2, ((test_map))((default_generator)(generate_collisions)))
 
   UNORDERED_TEST(map_insert_range_test1,
-    ((test_map)(test_node_map))((default_generator)(generate_collisions)(limited_range)))
+    ((test_map))((default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(map_insert_range_test2,
-    ((test_map)(test_node_map))((default_generator)(generate_collisions)(limited_range)))
+    ((test_map))((default_generator)(generate_collisions)(limited_range)))
 
   UNORDERED_TEST(
-    set_tests, ((test_set_std_alloc)(test_set)(test_node_set))((default_generator)))
-
-  UNORDERED_TEST(set_tests2, ((test_pc_set)(test_pc_node_set)))
+    set_tests, ((test_set_std_alloc)(test_set))((default_generator)))
 #else
   boost::unordered_set<test::movable, test::hash, test::equal_to,
     std::allocator<test::movable> >* test_set_std_alloc;
@@ -1027,10 +946,6 @@ 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)))
@@ -1075,8 +990,6 @@ 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)
@@ -1096,19 +1009,23 @@ namespace insert_tests {
     }
   };
 
-  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;
-
+  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
     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());
 
-    Set<initialize_from_two_ints> set2;
+#ifdef BOOST_UNORDERED_FOA_TESTS
+  boost::unordered_flat_set<initialize_from_two_ints> set2;
+#else
+    boost::unordered_set<initialize_from_two_ints> set2;
+#endif
+
 #if defined(__GNUC__) && (__GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5))
     set2.insert({{1, 2}});
 #else
@@ -1136,16 +1053,6 @@ 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)
 
@@ -1167,31 +1074,18 @@ namespace insert_tests {
 #endif
 #endif
 
-  template <class X> static void insert_initializer_list_map(X*)
-  {
-    X map;
-
+  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({});
     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;
@@ -1230,71 +1124,64 @@ namespace insert_tests {
     }
   };
 
-  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());
+  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
 
-    x.emplace(2, 3);
-    BOOST_TEST(
-      x.find(2) != x.end() && x.find(2)->second == overloaded_constructor(3));
+#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
+      x.emplace();
+      BOOST_TEST(
+        x.find(0) != x.end() && x.find(0)->second == overloaded_constructor());
+#endif
 
-    x.try_emplace(5);
-    BOOST_TEST(
-      x.find(5) != x.end() && x.find(5)->second == overloaded_constructor());
-  }
+      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
-  template <class X> static void multimap_emplace_test(X*)
-  {
-    X x;
+    {
+      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());
+      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));
+    }
+#endif
   }
-#endif
 
+  UNORDERED_AUTO_TEST (set_emplace_test) {
 #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;
+    boost::unordered_flat_set<overloaded_constructor> x;
     overloaded_constructor check;
+#else
+    boost::unordered_set<overloaded_constructor> x;
+    overloaded_constructor check;
+#endif
 
 #if !BOOST_UNORDERED_SUN_WORKAROUNDS1
     x.emplace();
@@ -1322,18 +1209,6 @@ 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
   {
@@ -1483,14 +1358,6 @@ 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
@@ -1522,14 +1389,6 @@ 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
@@ -1543,17 +1402,27 @@ RUN_TESTS_QUIET()
 
 #else // 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*)
-  {
+UNORDERED_AUTO_TEST (PIECEWISE_TEST_NAME) {
 #if EMULATING_PIECEWISE_CONSTRUCTION
   test::detail::disable_construction_tracking _scoped;
 #endif
 
-    X x;
+  {
+#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.emplace(PIECEWISE_NAMESPACE::piecewise_construct,
       TUPLE_NAMESPACE::make_tuple(), TUPLE_NAMESPACE::make_tuple());
@@ -1597,102 +1466,70 @@ RUN_TESTS_QUIET()
                x.find(overloaded_constructor(2, 3))->second ==
                  overloaded_constructor(4, 5, 6));
   }
-
-  template <class X>
-  static void SET_PIECEWISE_TEST(X*)
+#ifndef BOOST_UNORDERED_FOA_TESTS
   {
-#if EMULATING_PIECEWISE_CONSTRUCTION
-    test::detail::disable_construction_tracking _scoped;
-#endif
-
-    X x;
-    std::pair<overloaded_constructor, overloaded_constructor> check;
+    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(check) != x.end() && *x.find(check) == check);
+    BOOST_TEST(
+      x.find(overloaded_constructor()) != x.end() &&
+      x.find(overloaded_constructor())->second == overloaded_constructor());
 
-    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);
+    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));
   }
-
-#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)) {
-    {
+UNORDERED_AUTO_TEST (BOOST_PP_CAT(PIECEWISE_TEST_NAME, 2)) {
 #if EMULATING_PIECEWISE_CONSTRUCTION
-      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));
-    }
-  }
+  test::detail::disable_construction_tracking _scoped;
 #endif
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
-  // clang-format off
-  UNORDERED_TEST(SET_PIECEWISE_TEST,
-    ((test_pair_oc_set)(test_pair_oc_node_set)))
-  // clang-format on
+  boost::unordered_flat_set<
+    std::pair<overloaded_constructor, overloaded_constructor> >
+    x;
 #else
-  // clang-format off
-  UNORDERED_TEST(SET_PIECEWISE_TEST, ((test_pair_oc_set)))
-  // clang-format on
+  boost::unordered_set<
+    std::pair<overloaded_constructor, overloaded_constructor> >
+    x;
 #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,23 +1,20 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/unordered.hpp"
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
-void foo(boost::unordered_flat_set<int>&, boost::unordered_flat_map<int, int>&,
-  boost::unordered_node_set<int>&, boost::unordered_node_map<int, int>&);
+void foo(boost::unordered_flat_set<int>&, boost::unordered_flat_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, x3, x4);
+  foo(x1, x2);
 
   return 0;
 }

test/unordered/link_test_2.cpp

@@ -1,15 +1,14 @@
 
 // Copyright 2006-2009 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
 #include "../helpers/unordered.hpp"
 
 #ifdef BOOST_UNORDERED_FOA_TESTS
-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)
+void foo(
+  boost::unordered_flat_set<int>& x1, boost::unordered_flat_map<int, int>& x2)
 {
 #if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x0613))
   struct dummy
@@ -21,8 +20,6 @@ void foo(boost::unordered_flat_set<int>& x1,
 
   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-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -86,17 +86,12 @@ 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;
 
-  // 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(set_load_factor_tests, ((int_set_ptr)(int_map_ptr)))
 
   UNORDERED_TEST(load_factor_insert_tests,
-    ((int_set_ptr)(int_map_ptr)(int_node_set_ptr)(int_node_map_ptr))(
+    ((int_set_ptr)(int_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,24 +69,9 @@ 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_node_set_ptr)(test_node_map_ptr)
-   (test_node_set_tracking)(test_node_map_tracking))(
+  ((int_set_ptr)(test_map_ptr)(test_set_tracking)(test_map_tracking))(
     (sequential)))
-// clang-format on
 #endif
 
 RUN_TESTS()

test/unordered/merge_tests.cpp

@@ -1,6 +1,6 @@
 
 // Copyright 2016 Daniel James.
-// Copyright 2022-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -16,9 +16,14 @@
 
 namespace merge_tests {
 
-  template <class X> static void merge_set(X*)
-  {
-    X x, y;
+  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
 
     x.merge(y);
     BOOST_TEST(x.empty());
@@ -232,23 +237,22 @@ 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))
@@ -304,82 +308,7 @@ 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,
@@ -401,8 +330,6 @@ 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))
@@ -485,6 +412,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-2023 Christian Mazakas.
+// Copyright 2022 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,68 +408,18 @@ 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_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))(
+    ((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))(
       (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_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))(
+    ((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))(
       (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_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))(
+    ((test_set)(test_map)(test_set_prop_move)(test_map_prop_move)(test_set_no_prop_move)(test_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_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))(
+    ((test_set)(test_map)(test_set_prop_move)(test_map_prop_move)(test_set_no_prop_move)(test_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

@@ -1,107 +0,0 @@
-// 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 "../helpers/unordered.hpp"
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
 
 #include "../helpers/helpers.hpp"
 #include "../helpers/metafunctions.hpp"
@@ -17,19 +17,15 @@
 #include <set>
 #include <string>
 
-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;
+UNORDERED_AUTO_TEST (example1) {
+  typedef boost::unordered_map<int, std::string>::insert_return_type
+    insert_return_type;
 
-  Map<int, std::string> src;
+  boost::unordered_map<int, std::string> src;
   src.emplace(1, "one");
   src.emplace(2, "two");
   src.emplace(3, "buckle my shoe");
-  Map<int, std::string> dst;
+  boost::unordered_map<int, std::string> dst;
   dst.emplace(3, "three");
 
   dst.insert(src.extract(src.find(1)));
@@ -46,16 +42,12 @@ static void example1()
   BOOST_TEST(r.node.mapped() == "buckle my shoe");
 }
 
-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;
+UNORDERED_AUTO_TEST (example2) {
+  boost::unordered_set<int> src;
   src.insert(1);
   src.insert(3);
   src.insert(5);
-  Set<int> dst;
+  boost::unordered_set<int> dst;
   dst.insert(2);
   dst.insert(4);
   dst.insert(5);
@@ -65,18 +57,14 @@ static void example2()
   // dst == {1, 2, 3, 4, 5}
 }
 
-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;
+UNORDERED_AUTO_TEST (example3) {
+  typedef boost::unordered_set<int>::iterator iterator;
 
-  Set<int> src;
+  boost::unordered_set<int> src;
   src.insert(1);
   src.insert(3);
   src.insert(5);
-  Set<int> dst;
+  boost::unordered_set<int> dst;
   dst.insert(2);
   dst.insert(4);
   dst.insert(5);
@@ -100,24 +88,16 @@ static void example3()
   BOOST_TEST(it == dst2.end());
 }
 
-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()
-{
+UNORDERED_AUTO_TEST (failed_insertion_with_hint) {
   {
-    Set<int> src;
-    Set<int> dst;
+    boost::unordered_set<int> src;
+    boost::unordered_set<int> dst;
     src.emplace(10);
     src.emplace(20);
     dst.emplace(10);
     dst.emplace(20);
 
-    typename Set<int>::node_type nh = src.extract(10);
+    boost::unordered_set<int>::node_type nh = src.extract(10);
 
     BOOST_TEST(dst.insert(dst.find(10), boost::move(nh)) == dst.find(10));
     BOOST_TEST(nh);
@@ -136,14 +116,14 @@ static void failed_insertion_with_hint()
   }
 
   {
-    Map<int, int> src;
-    Map<int, int> dst;
+    boost::unordered_map<int, int> src;
+    boost::unordered_map<int, int> dst;
     src.emplace(10, 30);
     src.emplace(20, 5);
     dst.emplace(10, 20);
     dst.emplace(20, 2);
 
-    typename Map<int, int>::node_type nh = src.extract(10);
+    boost::unordered_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());
@@ -251,38 +231,20 @@ template <typename Container> void node_handle_tests_impl(Container& c)
   BOOST_TEST(!n4);
 }
 
-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;
+UNORDERED_AUTO_TEST (node_handle_tests) {
+  boost::unordered_set<int> x1;
   x1.emplace(100);
   x1.emplace(140);
   x1.emplace(-55);
   node_handle_tests_impl(x1);
 
-  Map<int, std::string> x2;
+  boost::unordered_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)
@@ -326,10 +288,8 @@ insert_empty_node(boost::unordered_multiset<T, Hash, KeyEqual, Allocator>& c)
   return c.insert(node_type());
 }
 
-#endif
-
 template <typename Container1, typename Container2>
-static void insert_node_handle_unique(Container1& c1, Container2& c2)
+void insert_node_handle_unique(Container1& c1, Container2& c2)
 {
   typedef typename Container1::node_type node_type;
   typedef typename Container1::value_type value_type;
@@ -370,7 +330,7 @@ static void insert_node_handle_unique(Container1& c1, Container2& c2)
 }
 
 template <typename Container1, typename Container2>
-static void insert_node_handle_unique2(Container1& c1, Container2& c2)
+void insert_node_handle_unique2(Container1& c1, Container2& c2)
 {
   typedef typename Container1::node_type node_type;
   typedef typename Container1::value_type value_type;
@@ -402,130 +362,6 @@ static 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)
 {
@@ -553,6 +389,14 @@ 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;
@@ -703,6 +547,4 @@ 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/fwd.hpp"
 #include "../helpers/test.hpp"
+#include "../helpers/fwd.hpp"
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
@@ -203,10 +203,6 @@ 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));
@@ -226,13 +222,6 @@ 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));
@@ -242,22 +231,31 @@ namespace noexcept_tests {
 #endif
   }
 
-  template <class X> static void test_nothrow_move_when_noexcept(X*)
-  {
+  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
+
     if (have_is_nothrow_move) {
-      BOOST_TEST(boost::is_nothrow_move_constructible<X>::value);
+      BOOST_TEST(boost::is_nothrow_move_constructible<throwing_set>::value);
     }
 
     throwing_test_exception = false;
 
-    X x1;
+    throwing_set x1;
     x1.insert(10);
     x1.insert(50);
 
     try {
       throwing_test_exception = true;
 
-      X x2 = boost::move(x1);
+      throwing_set x2 = boost::move(x1);
       BOOST_TEST(x2.size() == 2);
       BOOST_TEST(*x2.begin() == 10 || *x2.begin() == 50);
       BOOST_TEST(have_is_nothrow_move);
@@ -329,16 +327,24 @@ namespace noexcept_tests {
     }
   }
 
-  template <class X> static void test_nothrow_swap_when_noexcept(X*)
-  {
+  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
+
     if (have_is_nothrow_swap) {
-      BOOST_TEST(boost::is_nothrow_swappable<X>::value);
+      BOOST_TEST(boost::is_nothrow_swappable<throwing_set>::value);
     }
 
     throwing_test_exception = false;
 
-    X x1;
-    X x2;
+    throwing_set x1;
+    throwing_set x2;
     x1.insert(10);
     x1.insert(50);
     for (int i = 0; i < 100; ++i) {
@@ -359,7 +365,7 @@ namespace noexcept_tests {
 
     throwing_test_exception = false;
   }
-} // namespace noexcept_tests
+}
 
 #if defined(BOOST_MSVC)
 #pragma warning(pop)
@@ -395,7 +401,6 @@ 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;
@@ -426,53 +431,23 @@ 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_move_assign,
+  noexcept_tests::equal_to_nothrow_move_assign, allocator1<int> >*
+  throwing_set_alloc1;
 
-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_move_assign,
+  noexcept_tests::equal_to_nothrow_move_assign, allocator2<int> >*
+  throwing_set_alloc2;
 
-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)
-   (throwing_node_set_alloc1)(throwing_node_set_alloc2))(
-    (default_generator)))
-// clang-format on
+  ((throwing_set_alloc1)(throwing_set_alloc2))((default_generator)))
 #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;
@@ -481,8 +456,6 @@ 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-2023 Christian Mazakas
+// Copyright (C) 2022 Christian Mazakas
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or move at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -335,14 +335,12 @@ 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)
   {
@@ -377,7 +375,6 @@ 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);
@@ -387,7 +384,6 @@ 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&)
@@ -611,38 +607,9 @@ 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_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))(
+    ((test_set)(test_map)(test_set_prop_move)(test_map_prop_move)(test_set_no_prop_move)(test_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> > >*
@@ -687,14 +654,12 @@ 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-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -437,35 +437,6 @@ 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);
@@ -610,67 +581,32 @@ namespace rehash_tests {
     monotonic_allocator<std::pair<test::object const, test::object> > >*
     test_map_monotonic;
 
-  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_test1, ((int_set_ptr)(test_map_ptr)))
   UNORDERED_TEST(rehash_empty_test2,
-    ((int_set_ptr)(test_map_ptr)
-     (int_node_set_ptr)(test_node_map_ptr))(
+    ((int_set_ptr)(test_map_ptr))(
       (default_generator)(generate_collisions)(limited_range)))
   UNORDERED_TEST(rehash_empty_test3,
-    ((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))(
+    ((int_set_ptr)(test_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_node_set_tracking)(test_node_map_tracking))(
+    ((test_set_tracking)(test_map_tracking))(
       (default_generator)(generate_collisions)(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
+  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)))
 #else
   boost::unordered_set<int>* int_set_ptr;
   boost::unordered_multiset<test::object, test::hash, test::equal_to,
@@ -703,7 +639,6 @@ 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,
@@ -734,12 +669,6 @@ 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-2023 Christian Mazakas.
+// Copyright 2021-2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -45,8 +45,7 @@ template <typename T> struct A
 
 template <class T> int A<T>::count = 0;
 
-template <class UnorderedContainer>
-void bucket_count_constructor(UnorderedContainer*)
+template <class UnorderedContainer> void bucket_count_constructor()
 {
   BOOST_TEST_EQ(num_allocations, 0u);
   BOOST_TEST_EQ(total_allocation, 0u);
@@ -65,8 +64,7 @@ void bucket_count_constructor(UnorderedContainer*)
   num_allocations = 0;
 }
 
-template <class UnorderedContainer>
-void range_bucket_constructor(UnorderedContainer*)
+template <class UnorderedContainer> void range_bucket_constructor()
 {
   BOOST_TEST_EQ(num_allocations, 0u);
   BOOST_TEST_EQ(total_allocation, 0u);
@@ -87,7 +85,7 @@ void range_bucket_constructor(UnorderedContainer*)
   num_allocations = 0;
 }
 
-template <class UnorderedContainer> void reserve_tests(UnorderedContainer*)
+template <class UnorderedContainer> void reserve_tests()
 {
   BOOST_TEST_EQ(num_allocations, 0u);
   BOOST_TEST_EQ(total_allocation, 0u);
@@ -126,7 +124,7 @@ template <class UnorderedContainer> void reserve_tests(UnorderedContainer*)
   num_allocations = 0;
 }
 
-template <class UnorderedContainer> void rehash_tests(UnorderedContainer*)
+template <class UnorderedContainer> void rehash_tests()
 {
   BOOST_TEST_EQ(num_allocations, 0u);
   BOOST_TEST_EQ(total_allocation, 0u);
@@ -193,81 +191,89 @@ template <class UnorderedContainer> void rehash_tests(UnorderedContainer*)
   num_allocations = 0;
 }
 
-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);
-}
+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
-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;
+  typedef boost::unordered_flat_set<int*, boost::hash<int*>,
+    std::equal_to<int*>, A<int*> >
+    unordered_set;
 
-static boost::unordered_node_set<int*, boost::hash<int*>, std::equal_to<int*>,
-  A<int*> >* test_node_set;
+  typedef boost::unordered_flat_map<int*, int*, boost::hash<int*>,
+    std::equal_to<int*>, A<std::pair<int const*, int*> > >
+    unordered_map;
 
-static boost::unordered_node_map<int*, int*, boost::hash<int*>,
-  std::equal_to<int*>, A<std::pair<int const*, int*> > >* test_node_map;
+  bucket_count_constructor<unordered_set>();
+  bucket_count_constructor<unordered_map>();
 
-// clang-format off
-UNORDERED_TEST(bucket_count_constructor,
-  ((test_set)(test_map)(test_node_set)(test_node_map)))
+  range_bucket_constructor<unordered_set>();
+  range_bucket_constructor<unordered_map>();
 
-UNORDERED_TEST(range_bucket_constructor,
-  ((test_set)(test_map)(test_node_set)(test_node_map)))
+  reserve_tests<unordered_set>();
+  reserve_tests<unordered_map>();
 
-UNORDERED_TEST(reserve_tests,
-  ((test_set)(test_map)(test_node_set)(test_node_map)))
+  rehash_tests<unordered_set>();
+  rehash_tests<unordered_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;
+  typedef boost::unordered_set<int, boost::hash<int>, std::equal_to<int>,
+    A<int> >
+    unordered_set;
 
-static boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
-  A<int> >* test_multiset;
+  typedef boost::unordered_multiset<int, boost::hash<int>, std::equal_to<int>,
+    A<int> >
+    unordered_multiset;
 
-static boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
-  A<std::pair<int const, int> > >* test_map;
+  typedef boost::unordered_map<int, int, boost::hash<int>, std::equal_to<int>,
+    A<std::pair<int const, int> > >
+    unordered_map;
 
-static boost::unordered_multimap<int, int, boost::hash<int>, std::equal_to<int>,
-  A<std::pair<int const, int> > >* test_multimap;
+  typedef boost::unordered_multimap<int, int, boost::hash<int>,
+    std::equal_to<int>, A<std::pair<int const, int> > >
+    unordered_multimap;
 
-// clang-format off
-UNORDERED_TEST(bucket_count_constructor,
-  ((test_set)(test_map)(test_multiset)(test_multimap)))
+  bucket_count_constructor<unordered_set>();
+  bucket_count_constructor<unordered_map>();
+  bucket_count_constructor<unordered_multiset>();
+  bucket_count_constructor<unordered_multimap>();
 
-UNORDERED_TEST(range_bucket_constructor,
-  ((test_set)(test_map)(test_multiset)(test_multimap)))
+  range_bucket_constructor<unordered_set>();
+  range_bucket_constructor<unordered_map>();
+  range_bucket_constructor<unordered_multiset>();
+  range_bucket_constructor<unordered_multimap>();
 
-UNORDERED_TEST(reserve_tests,
-  ((test_set)(test_map)(test_multiset)(test_multimap)))
+  reserve_tests<unordered_set>();
+  reserve_tests<unordered_map>();
+  reserve_tests<unordered_multiset>();
+  reserve_tests<unordered_multimap>();
 
-UNORDERED_TEST(rehash_tests,
-  ((test_set)(test_map)(test_multiset)(test_multimap)))
-// clang-format on
+  rehash_tests<unordered_set>();
+  rehash_tests<unordered_map>();
+  rehash_tests<unordered_multiset>();
+  rehash_tests<unordered_multimap>();
 #endif
+}
 
 RUN_TESTS()

test/unordered/scary_tests.cpp

@@ -312,10 +312,7 @@ 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-2023 Christian Mazakas.
+// Copyright 2021-2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -65,12 +65,21 @@ typedef std::scoped_allocator_adaptor<test::allocator<pair_type>,
   test::allocator<boost::uint64_t> >
   allocator_type;
 
-template <class X> static void scoped_allocator(X*)
-{
+#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) {
   allocator_type alloc(
     test::allocator<pair_type>(1337), test::allocator<boost::uint64_t>(7331));
 
-  X map(alloc);
+  map_type map(alloc);
 
   for (unsigned i = 0; i < 10; ++i) {
     boost::ignore_unused(map[i]);
@@ -79,24 +88,6 @@ template <class X> static void scoped_allocator(X*)
   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-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -8,13 +8,10 @@
 
 #include "../helpers/unordered.hpp"
 
-#include "../helpers/equivalent.hpp"
-#include "../helpers/generators.hpp"
 #include "../helpers/test.hpp"
-#include <algorithm>
 #include <cstdlib>
-
-test::seed_t initialize_seed(14878);
+#include <algorithm>
+#include "../helpers/equivalent.hpp"
 
 template <class X> void simple_test(X const& a)
 {
@@ -87,76 +84,59 @@ template <class X> void simple_test(X const& a)
   }
 }
 
-template <class X> static void simple_set_tests(X*)
-{
-  X x;
+UNORDERED_AUTO_TEST (simple_tests) {
+  using namespace std;
+  srand(14878);
 
-  simple_test(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);
 
-  x.insert(1);
-  x.insert(2);
-  x.insert(1456);
-  simple_test(x);
-}
+  set.insert(1);
+  set.insert(2);
+  set.insert(1456);
+  simple_test(set);
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
-template <class X> static void simple_multiset_tests(X*)
-{
-  X x;
-  simple_test(x);
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multiset.\n";
+  boost::unordered_multiset<int> multiset;
+  simple_test(multiset);
 
   for (int i1 = 0; i1 < 1000; ++i1) {
     int count = rand() % 10, index = rand();
     for (int j = 0; j < count; ++j)
-      x.insert(index);
+      multiset.insert(index);
   }
-  simple_test(x);
-}
+  simple_test(multiset);
 #endif
 
-template <class X> static void simple_map_tests(X*)
-{
-  X x;
+  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
 
   for (int i2 = 0; i2 < 1000; ++i2) {
-    x.insert(std::pair<const int, int>(rand(), rand()));
+    map.insert(std::pair<const int, int>(rand(), rand()));
   }
-  simple_test(x);
-}
+  simple_test(map);
 
 #ifndef BOOST_UNORDERED_FOA_TESTS
-template <class X> static void simple_multimap_tests(X*)
-{
-  X x;
+  BOOST_LIGHTWEIGHT_TEST_OSTREAM << "Test unordered_multimap.\n";
+  boost::unordered_multimap<int, int> multimap;
 
   for (int i3 = 0; i3 < 1000; ++i3) {
     int count = rand() % 10, index = rand();
     for (int j = 0; j < count; ++j)
-      x.insert(std::pair<const int, int>(index, rand()));
+      multimap.insert(std::pair<const int, int>(index, rand()));
   }
-  simple_test(x);
+  simple_test(multimap);
+#endif
 }
-#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-2023 Christian Mazakas.
+// Copyright 2022 Christian Mazakas.
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
@@ -168,58 +168,19 @@ 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_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))(
+    ((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))(
       (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_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))(
+    ((test_set)(test_map)(test_set_prop_swap)(test_map_prop_swap)(test_set_no_prop_swap)(test_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;