passenger 6.0.14 → 6.0.27

data/src/cxx_supportlib/vendor-modified/boost/unordered/unordered_set.hpp

@@ -1,6 +1,7 @@
-
 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
 // Copyright (C) 2005-2011 Daniel James.
+// Copyright (C) 2022-2023 Christian Mazakas
+// Copyright (C) 2024 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)
 
@@ -14,14 +15,13 @@
 #pragma once
 #endif
 
-#include <boost/core/explicit_operator_bool.hpp>
-#include <boost/functional/hash.hpp>
-#include <boost/move/move.hpp>
+#include <boost/unordered/detail/serialize_fca_container.hpp>
 #include <boost/unordered/detail/set.hpp>
+#include <boost/unordered/detail/type_traits.hpp>
+
+#include <boost/container_hash/hash.hpp>
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
 #include <initializer_list>
-#endif
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
@@ -38,9 +38,6 @@ namespace boost {
   namespace unordered {
     template <class T, class H, class P, class A> class unordered_set
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-      BOOST_COPYABLE_AND_MOVABLE(unordered_set)
-#endif
       template <typename, typename, typename, typename>
       friend class unordered_multiset;
 
@@ -55,8 +52,6 @@ namespace boost {
       typedef boost::unordered::detail::set<A, T, H, P> types;
       typedef typename types::value_allocator_traits value_allocator_traits;
       typedef typename types::table table;
-      typedef typename table::node_pointer node_pointer;
-      typedef typename table::link_pointer link_pointer;
 
     public:
       typedef typename value_allocator_traits::pointer pointer;
@@ -68,9 +63,9 @@ namespace boost {
       typedef std::size_t size_type;
       typedef std::ptrdiff_t difference_type;
 
-      typedef typename table::iterator iterator;
+      typedef typename table::c_iterator iterator;
       typedef typename table::c_iterator const_iterator;
-      typedef typename table::l_iterator local_iterator;
+      typedef typename table::cl_iterator local_iterator;
       typedef typename table::cl_iterator const_local_iterator;
       typedef typename types::node_type node_type;
       typedef typename types::insert_return_type insert_return_type;
@@ -95,33 +90,31 @@ namespace boost {
 
       unordered_set(unordered_set const&);
 
-#if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
-  !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      unordered_set(BOOST_RV_REF(unordered_set) other)
-        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+      unordered_set(unordered_set&& other)
+        noexcept(table::nothrow_move_constructible)
           : table_(other.table_, boost::unordered::detail::move_tag())
       {
         // The move is done in table_
       }
-#endif
 
       explicit unordered_set(allocator_type const&);
 
       unordered_set(unordered_set const&, allocator_type const&);
 
-      unordered_set(BOOST_RV_REF(unordered_set), allocator_type const&);
+      unordered_set(unordered_set&&, allocator_type const&);
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
       unordered_set(std::initializer_list<value_type>,
         size_type = boost::unordered::detail::default_bucket_count,
         const hasher& = hasher(), const key_equal& l = key_equal(),
         const allocator_type& = allocator_type());
-#endif
 
       explicit unordered_set(size_type, const allocator_type&);
 
       explicit unordered_set(size_type, const hasher&, const allocator_type&);
 
+      template <class InputIterator>
+      unordered_set(InputIterator, InputIterator, const allocator_type&);
+
       template <class InputIt>
       unordered_set(InputIt, InputIt, size_type, const allocator_type&);
 
@@ -129,339 +122,206 @@ namespace boost {
       unordered_set(
         InputIt, InputIt, size_type, const hasher&, const allocator_type&);
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+      unordered_set(std::initializer_list<value_type>, const allocator_type&);
+
       unordered_set(
         std::initializer_list<value_type>, size_type, const allocator_type&);
 
       unordered_set(std::initializer_list<value_type>, size_type, const hasher&,
         const allocator_type&);
-#endif
 
       // Destructor
 
-      ~unordered_set() BOOST_NOEXCEPT;
-
-// Assign
+      ~unordered_set() noexcept;
 
-#if defined(BOOST_UNORDERED_USE_MOVE)
-      unordered_set& operator=(BOOST_COPY_ASSIGN_REF(unordered_set) x)
-      {
-        table_.assign(x.table_, boost::unordered::detail::true_type());
-        return *this;
-      }
+      // Assign
 
-      unordered_set& operator=(BOOST_RV_REF(unordered_set) x)
-        BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::is_nothrow_move_assignable<H>::value&&
-              boost::is_nothrow_move_assignable<P>::value)
-      {
-        table_.move_assign(x.table_, boost::unordered::detail::true_type());
-        return *this;
-      }
-#else
       unordered_set& operator=(unordered_set const& x)
       {
-        table_.assign(x.table_, boost::unordered::detail::true_type());
+        table_.assign(x.table_, std::true_type());
         return *this;
       }
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       unordered_set& operator=(unordered_set&& x)
-        BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::is_nothrow_move_assignable<H>::value&&
-              boost::is_nothrow_move_assignable<P>::value)
+        noexcept(value_allocator_traits::is_always_equal::value&&
+            std::is_nothrow_move_assignable<H>::value&&
+              std::is_nothrow_move_assignable<P>::value)
       {
-        table_.move_assign(x.table_, boost::unordered::detail::true_type());
+        table_.move_assign(x.table_, std::true_type());
         return *this;
       }
-#endif
-#endif
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
       unordered_set& operator=(std::initializer_list<value_type>);
-#endif
 
-      allocator_type get_allocator() const BOOST_NOEXCEPT
+      allocator_type get_allocator() const noexcept
       {
-        return table_.node_alloc();
+        return allocator_type(table_.node_alloc());
       }
 
       // iterators
 
-      iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
+      iterator begin() noexcept { return iterator(table_.begin()); }
 
-      const_iterator begin() const BOOST_NOEXCEPT
+      const_iterator begin() const noexcept
       {
         return const_iterator(table_.begin());
       }
 
-      iterator end() BOOST_NOEXCEPT { return iterator(); }
+      iterator end() noexcept { return iterator(); }
 
-      const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
+      const_iterator end() const noexcept { return const_iterator(); }
 
-      const_iterator cbegin() const BOOST_NOEXCEPT
+      const_iterator cbegin() const noexcept
       {
         return const_iterator(table_.begin());
       }
 
-      const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
+      const_iterator cend() const noexcept { return const_iterator(); }
 
       // size and capacity
 
-      bool empty() const BOOST_NOEXCEPT { return table_.size_ == 0; }
-
-      size_type size() const BOOST_NOEXCEPT { return table_.size_; }
-
-      size_type max_size() const BOOST_NOEXCEPT;
-
-// emplace
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-      template <class... Args>
-      std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
-      {
-        return table_.emplace_unique(
-          table::extractor::extract(boost::forward<Args>(args)...),
-          boost::forward<Args>(args)...);
-      }
-
-#else
-
-#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
-
-      // 0 argument emplace requires special treatment in case
-      // the container is instantiated with a value type that
-      // doesn't have a default constructor.
-
-      std::pair<iterator, bool> emplace(
-        boost::unordered::detail::empty_emplace =
-          boost::unordered::detail::empty_emplace(),
-        value_type v = value_type())
+      BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
       {
-        return this->emplace(boost::move(v));
+        return table_.size_ == 0;
       }
 
-#endif
+      size_type size() const noexcept { return table_.size_; }
 
-      template <typename A0>
-      std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
-      {
-        return table_.emplace_unique(
-          table::extractor::extract(boost::forward<A0>(a0)),
-          boost::unordered::detail::create_emplace_args(
-            boost::forward<A0>(a0)));
-      }
+      size_type max_size() const noexcept;
 
-      template <typename A0, typename A1>
-      std::pair<iterator, bool> emplace(
-        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-      {
-        return table_.emplace_unique(
-          table::extractor::extract(
-            boost::forward<A0>(a0), boost::forward<A1>(a1)),
-          boost::unordered::detail::create_emplace_args(
-            boost::forward<A0>(a0), boost::forward<A1>(a1)));
-      }
+      // emplace
 
-      template <typename A0, typename A1, typename A2>
-      std::pair<iterator, bool> emplace(
-        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+      template <class... Args> std::pair<iterator, bool> emplace(Args&&... args)
       {
         return table_.emplace_unique(
-          table::extractor::extract(
-            boost::forward<A0>(a0), boost::forward<A1>(a1)),
-          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
-            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+          table::extractor::extract(detail::as_const(args)...),
+          std::forward<Args>(args)...);
       }
 
-#endif
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
       template <class... Args>
-      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
+      iterator emplace_hint(const_iterator hint, Args&&... args)
       {
         return table_.emplace_hint_unique(hint,
-          table::extractor::extract(boost::forward<Args>(args)...),
-          boost::forward<Args>(args)...);
-      }
-
-#else
-
-#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
-
-      iterator emplace_hint(const_iterator hint,
-        boost::unordered::detail::empty_emplace =
-          boost::unordered::detail::empty_emplace(),
-        value_type v = value_type())
-      {
-        return this->emplace_hint(hint, boost::move(v));
+          table::extractor::extract(detail::as_const(args)...),
+          std::forward<Args>(args)...);
       }
 
-#endif
-
-      template <typename A0>
-      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
+      std::pair<iterator, bool> insert(value_type const& x)
       {
-        return table_.emplace_hint_unique(hint,
-          table::extractor::extract(boost::forward<A0>(a0)),
-          boost::unordered::detail::create_emplace_args(
-            boost::forward<A0>(a0)));
+        return this->emplace(x);
       }
 
-      template <typename A0, typename A1>
-      iterator emplace_hint(
-        const_iterator hint, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+      std::pair<iterator, bool> insert(value_type&& x)
       {
-        return table_.emplace_hint_unique(hint,
-          table::extractor::extract(
-            boost::forward<A0>(a0), boost::forward<A1>(a1)),
-          boost::unordered::detail::create_emplace_args(
-            boost::forward<A0>(a0), boost::forward<A1>(a1)));
+        return this->emplace(std::move(x));
       }
 
-      template <typename A0, typename A1, typename A2>
-      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
-        BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_set>::value,
+        std::pair<iterator, bool> >::type
+      insert(Key&& k)
       {
-        return table_.emplace_hint_unique(hint,
-          table::extractor::extract(
-            boost::forward<A0>(a0), boost::forward<A1>(a1)),
-          boost::unordered::detail::create_emplace_args(boost::forward<A0>(a0),
-            boost::forward<A1>(a1), boost::forward<A2>(a2)));
+        return table_.try_emplace_unique(std::forward<Key>(k));
       }
 
-#endif
-
-#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                       \
-  template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                          \
-  std::pair<iterator, bool> emplace(                                           \
-    BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))                        \
-  {                                                                            \
-    return table_.emplace_unique(                                              \
-      table::extractor::extract(                                               \
-        boost::forward<A0>(a0), boost::forward<A1>(a1)),                       \
-      boost::unordered::detail::create_emplace_args(                           \
-        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)));               \
-  }                                                                            \
-                                                                               \
-  template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                          \
-  iterator emplace_hint(                                                       \
-    const_iterator hint, BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))   \
-  {                                                                            \
-    return table_.emplace_hint_unique(hint,                                    \
-      table::extractor::extract(                                               \
-        boost::forward<A0>(a0), boost::forward<A1>(a1)),                       \
-      boost::unordered::detail::create_emplace_args(                           \
-        BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)));               \
-  }
-
-      BOOST_UNORDERED_EMPLACE(1, 4, _)
-      BOOST_UNORDERED_EMPLACE(1, 5, _)
-      BOOST_UNORDERED_EMPLACE(1, 6, _)
-      BOOST_UNORDERED_EMPLACE(1, 7, _)
-      BOOST_UNORDERED_EMPLACE(1, 8, _)
-      BOOST_UNORDERED_EMPLACE(1, 9, _)
-      BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
-        BOOST_UNORDERED_EMPLACE, _)
-
-#undef BOOST_UNORDERED_EMPLACE
-
-#endif
-
-      std::pair<iterator, bool> insert(value_type const& x)
-      {
-        return this->emplace(x);
-      }
-
-      std::pair<iterator, bool> insert(BOOST_UNORDERED_RV_REF(value_type) x)
+      iterator insert(const_iterator hint, value_type const& x)
       {
-        return this->emplace(boost::move(x));
+        return this->emplace_hint(hint, x);
       }
 
-      iterator insert(const_iterator hint, value_type const& x)
+      iterator insert(const_iterator hint, value_type&& x)
       {
-        return this->emplace_hint(hint, x);
+        return this->emplace_hint(hint, std::move(x));
       }
 
-      iterator insert(const_iterator hint, BOOST_UNORDERED_RV_REF(value_type) x)
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_set>::value,
+        iterator>::type
+      insert(const_iterator hint, Key&& k)
       {
-        return this->emplace_hint(hint, boost::move(x));
+        return table_.try_emplace_hint_unique(hint, std::forward<Key>(k));
       }
 
       template <class InputIt> void insert(InputIt, InputIt);
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
       void insert(std::initializer_list<value_type>);
-#endif
 
       // extract
 
       node_type extract(const_iterator position)
       {
         return node_type(
-          table_.extract_by_iterator_unique(position), table_.node_alloc());
+          table_.extract_by_iterator_unique(position),
+          allocator_type(table_.node_alloc()));
       }
 
       node_type extract(const key_type& k)
       {
-        return node_type(table_.extract_by_key(k), table_.node_alloc());
+        return node_type(
+          table_.extract_by_key_impl(k),
+          allocator_type(table_.node_alloc()));
       }
 
-      insert_return_type insert(BOOST_RV_REF(node_type) np)
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_set>::value,
+        node_type>::type
+      extract(const Key& k)
+      {
+        return node_type(
+          table_.extract_by_key_impl(k),
+          allocator_type(table_.node_alloc()));
+      }
+
+      insert_return_type insert(node_type&& np)
       {
         insert_return_type result;
         table_.move_insert_node_type_unique(np, result);
-        return boost::move(result);
+        return result;
       }
 
-      iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
+      iterator insert(const_iterator hint, node_type&& np)
       {
         return table_.move_insert_node_type_with_hint_unique(hint, np);
       }
 
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) ||                               \
-  (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
-    private:
-      // Note: Use r-value node_type to insert.
-      insert_return_type insert(node_type&);
-      iterator insert(const_iterator, node_type& np);
-
-    public:
-#endif
-
       iterator erase(const_iterator);
       size_type erase(const key_type&);
       iterator erase(const_iterator, const_iterator);
+
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_set>::value,
+        size_type>::type
+      erase(Key&& k)
+      {
+        return table_.erase_key_unique_impl(std::forward<Key>(k));
+      }
+
       BOOST_UNORDERED_DEPRECATED("Use erase instead")
       void quick_erase(const_iterator it) { erase(it); }
       BOOST_UNORDERED_DEPRECATED("Use erase instead")
       void erase_return_void(const_iterator it) { erase(it); }
 
       void swap(unordered_set&)
-        BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::is_nothrow_swappable<H>::value&&
-              boost::is_nothrow_swappable<P>::value);
-      void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
+        noexcept(value_allocator_traits::is_always_equal::value&&
+            boost::unordered::detail::is_nothrow_swappable<H>::value&&
+              boost::unordered::detail::is_nothrow_swappable<P>::value);
+      void clear() noexcept { table_.clear_impl(); }
 
       template <typename H2, typename P2>
       void merge(boost::unordered_set<T, H2, P2, A>& source);
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       template <typename H2, typename P2>
       void merge(boost::unordered_set<T, H2, P2, A>&& source);
-#endif
 
       template <typename H2, typename P2>
       void merge(boost::unordered_multiset<T, H2, P2, A>& source);
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       template <typename H2, typename P2>
       void merge(boost::unordered_multiset<T, H2, P2, A>&& source);
-#endif
 
       // observers
 
@@ -472,24 +332,64 @@ namespace boost {
 
       const_iterator find(const key_type&) const;
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        const_iterator>::type
+      find(const Key& k) const
+      {
+        return const_iterator(table_.find(k));
+      }
+
       template <class CompatibleKey, class CompatibleHash,
         class CompatiblePredicate>
       const_iterator find(CompatibleKey const&, CompatibleHash const&,
         CompatiblePredicate const&) const;
 
+      bool contains(key_type const& k) const
+      {
+        return table_.find(k) != this->end();
+      }
+
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        bool>::type
+      contains(const Key& k) const
+      {
+        return table_.find(k) != this->end();
+      }
+
       size_type count(const key_type&) const;
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        size_type>::type
+      count(const Key& k) const
+      {
+        return table_.find(k) != this->end() ? 1 : 0;
+      }
+
       std::pair<const_iterator, const_iterator> equal_range(
         const key_type&) const;
 
-      // bucket interface
-
-      size_type bucket_count() const BOOST_NOEXCEPT
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        std::pair<const_iterator, const_iterator> >::type
+      equal_range(Key const& k) const
       {
-        return table_.bucket_count_;
+        iterator n = table_.find(k);
+        iterator m = n;
+        if (m != this->end()) {
+          ++m;
+        }
+
+        return std::make_pair(const_iterator(n), const_iterator(m));
       }
 
-      size_type max_bucket_count() const BOOST_NOEXCEPT
+      // bucket interface
+
+      size_type bucket_count() const noexcept { return table_.bucket_count(); }
+
+      size_type max_bucket_count() const noexcept
       {
         return table_.max_bucket_count();
       }
@@ -501,14 +401,22 @@ 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(Key&& k) const
+      {
+        return table_.hash_to_bucket(table_.hash(std::forward<Key>(k)));
+      }
+
       local_iterator begin(size_type n)
       {
-        return local_iterator(table_.begin(n), n, table_.bucket_count_);
+        return local_iterator(table_.begin(n));
       }
 
       const_local_iterator begin(size_type n) const
       {
-        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+        return const_local_iterator(table_.begin(n));
       }
 
       local_iterator end(size_type) { return local_iterator(); }
@@ -520,7 +428,7 @@ namespace boost {
 
       const_local_iterator cbegin(size_type n) const
       {
-        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+        return const_local_iterator(table_.begin(n));
       }
 
       const_local_iterator cend(size_type) const
@@ -530,9 +438,9 @@ namespace boost {
 
       // hash policy
 
-      float load_factor() const BOOST_NOEXCEPT;
-      float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
-      void max_load_factor(float) BOOST_NOEXCEPT;
+      float load_factor() const noexcept;
+      float max_load_factor() const noexcept { return table_.mlf_; }
+      void max_load_factor(float) noexcept;
       void rehash(size_type);
       void reserve(size_type);
 
@@ -544,6 +452,13 @@ namespace boost {
 #endif
     }; // class template unordered_set
 
+    template <class Archive, class K, class H, class P, class A>
+    void serialize(
+      Archive& ar, unordered_set<K, H, P, A>& c, unsigned int version)
+    {
+      detail::serialize_fca_container(ar, c, version);
+    }
+
 #if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
 
     template <class InputIterator,
@@ -552,49 +467,75 @@ namespace boost {
       class Pred =
         std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
       class Allocator = std::allocator<
-        typename std::iterator_traits<InputIterator>::value_type> >
+        typename std::iterator_traits<InputIterator>::value_type>,
+      class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_pred_v<Pred> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_set(InputIterator, InputIterator,
       std::size_t = boost::unordered::detail::default_bucket_count,
       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      ->unordered_set<typename std::iterator_traits<InputIterator>::value_type,
+      -> unordered_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 Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_pred_v<Pred> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_set(std::initializer_list<T>,
       std::size_t = boost::unordered::detail::default_bucket_count,
       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      ->unordered_set<T, Hash, Pred, Allocator>;
+      -> unordered_set<T, Hash, Pred, Allocator>;
 
-    template <class InputIterator, class Allocator>
+    template <class InputIterator, class Allocator,
+      class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_set(InputIterator, InputIterator, std::size_t, Allocator)
-      ->unordered_set<typename std::iterator_traits<InputIterator>::value_type,
+      -> unordered_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>
+    template <class InputIterator, class Hash, class Allocator,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_set(InputIterator, InputIterator, std::size_t, Hash, Allocator)
-      ->unordered_set<typename std::iterator_traits<InputIterator>::value_type,
+      -> unordered_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>
+    template <class T, class Allocator,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_set(std::initializer_list<T>, std::size_t, Allocator)
-      ->unordered_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
+      -> unordered_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
 
-    template <class T, class Hash, class Allocator>
+    template <class T, class Hash, class Allocator,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_set(std::initializer_list<T>, std::size_t, Hash, Allocator)
-      ->unordered_set<T, Hash, std::equal_to<T>, Allocator>;
+      -> unordered_set<T, Hash, std::equal_to<T>, Allocator>;
+
+    template <class InputIterator, class Allocator,
+      class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_set(InputIterator, InputIterator, Allocator)
+      -> unordered_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 = std::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_set(std::initializer_list<T>, Allocator)
+      -> unordered_set<T, boost::hash<T>, std::equal_to<T>, Allocator>;
 
 #endif
 
     template <class T, class H, class P, class A> class unordered_multiset
     {
-#if defined(BOOST_UNORDERED_USE_MOVE)
-      BOOST_COPYABLE_AND_MOVABLE(unordered_multiset)
-#endif
       template <typename, typename, typename, typename>
       friend class unordered_set;
 
@@ -609,8 +550,6 @@ namespace boost {
       typedef boost::unordered::detail::set<A, T, H, P> types;
       typedef typename types::value_allocator_traits value_allocator_traits;
       typedef typename types::table table;
-      typedef typename table::node_pointer node_pointer;
-      typedef typename table::link_pointer link_pointer;
 
     public:
       typedef typename value_allocator_traits::pointer pointer;
@@ -622,9 +561,9 @@ namespace boost {
       typedef std::size_t size_type;
       typedef std::ptrdiff_t difference_type;
 
-      typedef typename table::iterator iterator;
+      typedef typename table::c_iterator iterator;
       typedef typename table::c_iterator const_iterator;
-      typedef typename table::l_iterator local_iterator;
+      typedef typename table::cl_iterator local_iterator;
       typedef typename table::cl_iterator const_local_iterator;
       typedef typename types::node_type node_type;
 
@@ -648,35 +587,32 @@ namespace boost {
 
       unordered_multiset(unordered_multiset const&);
 
-#if defined(BOOST_UNORDERED_USE_MOVE) ||                                       \
-  !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
-      unordered_multiset(BOOST_RV_REF(unordered_multiset) other)
-        BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
+      unordered_multiset(unordered_multiset&& other)
+        noexcept(table::nothrow_move_constructible)
           : table_(other.table_, boost::unordered::detail::move_tag())
       {
         // The move is done in table_
       }
-#endif
 
       explicit unordered_multiset(allocator_type const&);
 
       unordered_multiset(unordered_multiset const&, allocator_type const&);
 
-      unordered_multiset(
-        BOOST_RV_REF(unordered_multiset), allocator_type const&);
+      unordered_multiset(unordered_multiset&&, allocator_type const&);
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
       unordered_multiset(std::initializer_list<value_type>,
         size_type = boost::unordered::detail::default_bucket_count,
         const hasher& = hasher(), const key_equal& l = key_equal(),
         const allocator_type& = allocator_type());
-#endif
 
       explicit unordered_multiset(size_type, const allocator_type&);
 
       explicit unordered_multiset(
         size_type, const hasher&, const allocator_type&);
 
+      template <class InputIterator>
+      unordered_multiset(InputIterator, InputIterator, const allocator_type&);
+
       template <class InputIt>
       unordered_multiset(InputIt, InputIt, size_type, const allocator_type&);
 
@@ -684,268 +620,107 @@ namespace boost {
       unordered_multiset(
         InputIt, InputIt, size_type, const hasher&, const allocator_type&);
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+      unordered_multiset(
+        std::initializer_list<value_type>, const allocator_type&);
+
       unordered_multiset(
         std::initializer_list<value_type>, size_type, const allocator_type&);
 
       unordered_multiset(std::initializer_list<value_type>, size_type,
         const hasher&, const allocator_type&);
-#endif
 
       // Destructor
 
-      ~unordered_multiset() BOOST_NOEXCEPT;
-
-// Assign
-
-#if defined(BOOST_UNORDERED_USE_MOVE)
-      unordered_multiset& operator=(BOOST_COPY_ASSIGN_REF(unordered_multiset) x)
-      {
-        table_.assign(x.table_, boost::unordered::detail::false_type());
-        return *this;
-      }
+      ~unordered_multiset() noexcept;
 
-      unordered_multiset& operator=(BOOST_RV_REF(unordered_multiset) x)
-        BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::is_nothrow_move_assignable<H>::value&&
-              boost::is_nothrow_move_assignable<P>::value)
-      {
-        table_.move_assign(x.table_, boost::unordered::detail::false_type());
-        return *this;
-      }
-#else
+      // Assign
       unordered_multiset& operator=(unordered_multiset const& x)
       {
-        table_.assign(x.table_, boost::unordered::detail::false_type());
+        table_.assign(x.table_, std::false_type());
         return *this;
       }
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       unordered_multiset& operator=(unordered_multiset&& x)
-        BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::is_nothrow_move_assignable<H>::value&&
-              boost::is_nothrow_move_assignable<P>::value)
+        noexcept(value_allocator_traits::is_always_equal::value&&
+            std::is_nothrow_move_assignable<H>::value&&
+              std::is_nothrow_move_assignable<P>::value)
       {
-        table_.move_assign(x.table_, boost::unordered::detail::false_type());
+        table_.move_assign(x.table_, std::false_type());
         return *this;
       }
-#endif
-#endif
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
       unordered_multiset& operator=(std::initializer_list<value_type>);
-#endif
 
-      allocator_type get_allocator() const BOOST_NOEXCEPT
+      allocator_type get_allocator() const noexcept
       {
-        return table_.node_alloc();
+        return allocator_type(table_.node_alloc());
       }
 
       // iterators
 
-      iterator begin() BOOST_NOEXCEPT { return iterator(table_.begin()); }
+      iterator begin() noexcept { return iterator(table_.begin()); }
 
-      const_iterator begin() const BOOST_NOEXCEPT
+      const_iterator begin() const noexcept
       {
         return const_iterator(table_.begin());
       }
 
-      iterator end() BOOST_NOEXCEPT { return iterator(); }
+      iterator end() noexcept { return iterator(); }
 
-      const_iterator end() const BOOST_NOEXCEPT { return const_iterator(); }
+      const_iterator end() const noexcept { return const_iterator(); }
 
-      const_iterator cbegin() const BOOST_NOEXCEPT
+      const_iterator cbegin() const noexcept
       {
         return const_iterator(table_.begin());
       }
 
-      const_iterator cend() const BOOST_NOEXCEPT { return const_iterator(); }
+      const_iterator cend() const noexcept { return const_iterator(); }
 
       // size and capacity
 
-      bool empty() const BOOST_NOEXCEPT { return table_.size_ == 0; }
-
-      size_type size() const BOOST_NOEXCEPT { return table_.size_; }
-
-      size_type max_size() const BOOST_NOEXCEPT;
-
-// emplace
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-      template <class... Args> iterator emplace(BOOST_FWD_REF(Args)... args)
+      BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
       {
-        return iterator(table_.emplace_equiv(
-          boost::unordered::detail::func::construct_node_from_args(
-            table_.node_alloc(), boost::forward<Args>(args)...)));
+        return table_.size_ == 0;
       }
 
-#else
-
-#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
-
-      // 0 argument emplace requires special treatment in case
-      // the container is instantiated with a value type that
-      // doesn't have a default constructor.
+      size_type size() const noexcept { return table_.size_; }
 
-      iterator emplace(boost::unordered::detail::empty_emplace =
-                         boost::unordered::detail::empty_emplace(),
-        value_type v = value_type())
-      {
-        return this->emplace(boost::move(v));
-      }
+      size_type max_size() const noexcept;
 
-#endif
+      // emplace
 
-      template <typename A0> iterator emplace(BOOST_FWD_REF(A0) a0)
+      template <class... Args> iterator emplace(Args&&... args)
       {
         return iterator(table_.emplace_equiv(
           boost::unordered::detail::func::construct_node_from_args(
-            table_.node_alloc(), boost::unordered::detail::create_emplace_args(
-                                   boost::forward<A0>(a0)))));
+            table_.node_alloc(), std::forward<Args>(args)...)));
       }
 
-      template <typename A0, typename A1>
-      iterator emplace(BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
-      {
-        return iterator(table_.emplace_equiv(
-          boost::unordered::detail::func::construct_node_from_args(
-            table_.node_alloc(),
-            boost::unordered::detail::create_emplace_args(
-              boost::forward<A0>(a0), boost::forward<A1>(a1)))));
-      }
-
-      template <typename A0, typename A1, typename A2>
-      iterator emplace(
-        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
-      {
-        return iterator(table_.emplace_equiv(
-          boost::unordered::detail::func::construct_node_from_args(
-            table_.node_alloc(),
-            boost::unordered::detail::create_emplace_args(
-              boost::forward<A0>(a0), boost::forward<A1>(a1),
-              boost::forward<A2>(a2)))));
-      }
-
-#endif
-
-#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
       template <class... Args>
-      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
-      {
-        return iterator(table_.emplace_hint_equiv(
-          hint, boost::unordered::detail::func::construct_node_from_args(
-                  table_.node_alloc(), boost::forward<Args>(args)...)));
-      }
-
-#else
-
-#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
-
-      iterator emplace_hint(const_iterator hint,
-        boost::unordered::detail::empty_emplace =
-          boost::unordered::detail::empty_emplace(),
-        value_type v = value_type())
-      {
-        return this->emplace_hint(hint, boost::move(v));
-      }
-
-#endif
-
-      template <typename A0>
-      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
-      {
-        return iterator(table_.emplace_hint_equiv(hint,
-          boost::unordered::detail::func::construct_node_from_args(
-            table_.node_alloc(), boost::unordered::detail::create_emplace_args(
-                                   boost::forward<A0>(a0)))));
-      }
-
-      template <typename A0, typename A1>
-      iterator emplace_hint(
-        const_iterator hint, BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1)
+      iterator emplace_hint(const_iterator hint, Args&&... args)
       {
         return iterator(table_.emplace_hint_equiv(
           hint, boost::unordered::detail::func::construct_node_from_args(
-                  table_.node_alloc(),
-                  boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0), boost::forward<A1>(a1)))));
+                  table_.node_alloc(), std::forward<Args>(args)...)));
       }
 
-      template <typename A0, typename A1, typename A2>
-      iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0,
-        BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
-      {
-        return iterator(table_.emplace_hint_equiv(
-          hint, boost::unordered::detail::func::construct_node_from_args(
-                  table_.node_alloc(),
-                  boost::unordered::detail::create_emplace_args(
-                    boost::forward<A0>(a0), boost::forward<A1>(a1),
-                    boost::forward<A2>(a2)))));
-      }
-
-#endif
-
-#if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-
-#define BOOST_UNORDERED_EMPLACE(z, n, _)                                       \
-  template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                          \
-  iterator emplace(BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))         \
-  {                                                                            \
-    return iterator(table_.emplace_equiv(                                      \
-      boost::unordered::detail::func::construct_node_from_args(                \
-        table_.node_alloc(),                                                   \
-        boost::unordered::detail::create_emplace_args(                         \
-          BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)))));           \
-  }                                                                            \
-                                                                               \
-  template <BOOST_PP_ENUM_PARAMS_Z(z, n, typename A)>                          \
-  iterator emplace_hint(                                                       \
-    const_iterator hint, BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a))   \
-  {                                                                            \
-    return iterator(table_.emplace_hint_equiv(                                 \
-      hint, boost::unordered::detail::func::construct_node_from_args(          \
-              table_.node_alloc(),                                             \
-              boost::unordered::detail::create_emplace_args(                   \
-                BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, a)))));     \
-  }
-
-      BOOST_UNORDERED_EMPLACE(1, 4, _)
-      BOOST_UNORDERED_EMPLACE(1, 5, _)
-      BOOST_UNORDERED_EMPLACE(1, 6, _)
-      BOOST_UNORDERED_EMPLACE(1, 7, _)
-      BOOST_UNORDERED_EMPLACE(1, 8, _)
-      BOOST_UNORDERED_EMPLACE(1, 9, _)
-      BOOST_PP_REPEAT_FROM_TO(10, BOOST_PP_INC(BOOST_UNORDERED_EMPLACE_LIMIT),
-        BOOST_UNORDERED_EMPLACE, _)
-
-#undef BOOST_UNORDERED_EMPLACE
-
-#endif
-
       iterator insert(value_type const& x) { return this->emplace(x); }
 
-      iterator insert(BOOST_UNORDERED_RV_REF(value_type) x)
-      {
-        return this->emplace(boost::move(x));
-      }
+      iterator insert(value_type&& x) { return this->emplace(std::move(x)); }
 
       iterator insert(const_iterator hint, value_type const& x)
       {
         return this->emplace_hint(hint, x);
       }
 
-      iterator insert(const_iterator hint, BOOST_UNORDERED_RV_REF(value_type) x)
+      iterator insert(const_iterator hint, value_type&& x)
       {
-        return this->emplace_hint(hint, boost::move(x));
+        return this->emplace_hint(hint, std::move(x));
       }
 
       template <class InputIt> void insert(InputIt, InputIt);
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
       void insert(std::initializer_list<value_type>);
-#endif
 
       // extract
 
@@ -957,31 +732,40 @@ namespace boost {
 
       node_type extract(const key_type& k)
       {
-        return node_type(table_.extract_by_key(k), table_.node_alloc());
+        return node_type(table_.extract_by_key_impl(k), table_.node_alloc());
       }
 
-      iterator insert(BOOST_RV_REF(node_type) np)
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_multiset>::value,
+        node_type>::type
+      extract(const Key& k)
+      {
+        return node_type(table_.extract_by_key_impl(k), table_.node_alloc());
+      }
+
+      iterator insert(node_type&& np)
       {
         return table_.move_insert_node_type_equiv(np);
       }
 
-      iterator insert(const_iterator hint, BOOST_RV_REF(node_type) np)
+      iterator insert(const_iterator hint, node_type&& np)
       {
         return table_.move_insert_node_type_with_hint_equiv(hint, np);
       }
 
-#if defined(BOOST_NO_CXX11_RVALUE_REFERENCES) ||                               \
-  (BOOST_COMP_GNUC && BOOST_COMP_GNUC < BOOST_VERSION_NUMBER(4, 6, 0))
-    private:
-      // Note: Use r-value node_type to insert.
-      iterator insert(node_type&);
-      iterator insert(const_iterator, node_type& np);
-
-    public:
-#endif
-
       iterator erase(const_iterator);
       size_type erase(const key_type&);
+
+      template <class Key>
+      typename boost::enable_if_c<
+        detail::transparent_non_iterable<Key, unordered_multiset>::value,
+        size_type>::type
+      erase(const Key& k)
+      {
+        return table_.erase_key_equiv_impl(k);
+      }
+
       iterator erase(const_iterator, const_iterator);
       BOOST_UNORDERED_DEPRECATED("Use erase instead")
       void quick_erase(const_iterator it) { erase(it); }
@@ -989,26 +773,22 @@ namespace boost {
       void erase_return_void(const_iterator it) { erase(it); }
 
       void swap(unordered_multiset&)
-        BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-            boost::is_nothrow_swappable<H>::value&&
-              boost::is_nothrow_swappable<P>::value);
-      void clear() BOOST_NOEXCEPT { table_.clear_impl(); }
+        noexcept(value_allocator_traits::is_always_equal::value&&
+            boost::unordered::detail::is_nothrow_swappable<H>::value&&
+              boost::unordered::detail::is_nothrow_swappable<P>::value);
+      void clear() noexcept { table_.clear_impl(); }
 
       template <typename H2, typename P2>
       void merge(boost::unordered_multiset<T, H2, P2, A>& source);
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       template <typename H2, typename P2>
       void merge(boost::unordered_multiset<T, H2, P2, A>&& source);
-#endif
 
       template <typename H2, typename P2>
       void merge(boost::unordered_set<T, H2, P2, A>& source);
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
       template <typename H2, typename P2>
       void merge(boost::unordered_set<T, H2, P2, A>&& source);
-#endif
 
       // observers
 
@@ -1019,24 +799,60 @@ namespace boost {
 
       const_iterator find(const key_type&) const;
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        const_iterator>::type
+      find(const Key& k) const
+      {
+        return table_.find(k);
+      }
+
       template <class CompatibleKey, class CompatibleHash,
         class CompatiblePredicate>
       const_iterator find(CompatibleKey const&, CompatibleHash const&,
         CompatiblePredicate const&) const;
 
+      bool contains(const key_type& k) const
+      {
+        return table_.find(k) != this->end();
+      }
+
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        bool>::type
+      contains(const Key& k) const
+      {
+        return table_.find(k) != this->end();
+      }
+
       size_type count(const key_type&) const;
 
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        size_type>::type
+      count(const Key& k) const
+      {
+        return table_.group_count(k);
+      }
+
       std::pair<const_iterator, const_iterator> equal_range(
         const key_type&) const;
 
-      // bucket interface
-
-      size_type bucket_count() const BOOST_NOEXCEPT
+      template <class Key>
+      typename boost::enable_if_c<detail::are_transparent<Key, H, P>::value,
+        std::pair<const_iterator, const_iterator> >::type
+      equal_range(const Key& k) const
       {
-        return table_.bucket_count_;
+        iterator first = table_.find(k);
+        iterator last = table_.next_group(k, first);
+        return std::make_pair(const_iterator(first), const_iterator(last));
       }
 
-      size_type max_bucket_count() const BOOST_NOEXCEPT
+      // bucket interface
+
+      size_type bucket_count() const noexcept { return table_.bucket_count(); }
+
+      size_type max_bucket_count() const noexcept
       {
         return table_.max_bucket_count();
       }
@@ -1048,14 +864,22 @@ 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(Key&& k) const
+      {
+        return table_.hash_to_bucket(table_.hash(std::forward<Key>(k)));
+      }
+
       local_iterator begin(size_type n)
       {
-        return local_iterator(table_.begin(n), n, table_.bucket_count_);
+        return local_iterator(table_.begin(n));
       }
 
       const_local_iterator begin(size_type n) const
       {
-        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+        return const_local_iterator(table_.begin(n));
       }
 
       local_iterator end(size_type) { return local_iterator(); }
@@ -1067,7 +891,7 @@ namespace boost {
 
       const_local_iterator cbegin(size_type n) const
       {
-        return const_local_iterator(table_.begin(n), n, table_.bucket_count_);
+        return const_local_iterator(table_.begin(n));
       }
 
       const_local_iterator cend(size_type) const
@@ -1077,9 +901,9 @@ namespace boost {
 
       // hash policy
 
-      float load_factor() const BOOST_NOEXCEPT;
-      float max_load_factor() const BOOST_NOEXCEPT { return table_.mlf_; }
-      void max_load_factor(float) BOOST_NOEXCEPT;
+      float load_factor() const noexcept;
+      float max_load_factor() const noexcept { return table_.mlf_; }
+      void max_load_factor(float) noexcept;
       void rehash(size_type);
       void reserve(size_type);
 
@@ -1091,6 +915,13 @@ namespace boost {
 #endif
     }; // class template unordered_multiset
 
+    template <class Archive, class K, class H, class P, class A>
+    void serialize(
+      Archive& ar, unordered_multiset<K, H, P, A>& c, unsigned int version)
+    {
+      detail::serialize_fca_container(ar, c, version);
+    }
+
 #if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
 
     template <class InputIterator,
@@ -1099,52 +930,80 @@ namespace boost {
       class Pred =
         std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
       class Allocator = std::allocator<
-        typename std::iterator_traits<InputIterator>::value_type> >
+        typename std::iterator_traits<InputIterator>::value_type>,
+      class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_pred_v<Pred> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multiset(InputIterator, InputIterator,
       std::size_t = boost::unordered::detail::default_bucket_count,
       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      ->unordered_multiset<
+      -> unordered_multiset<
         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 Pred = std::equal_to<T>, class Allocator = std::allocator<T>,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_pred_v<Pred> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multiset(std::initializer_list<T>,
       std::size_t = boost::unordered::detail::default_bucket_count,
       Hash = Hash(), Pred = Pred(), Allocator = Allocator())
-      ->unordered_multiset<T, Hash, Pred, Allocator>;
+      -> unordered_multiset<T, Hash, Pred, Allocator>;
 
-    template <class InputIterator, class Allocator>
+    template <class InputIterator, class Allocator,
+      class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multiset(InputIterator, InputIterator, std::size_t, Allocator)
-      ->unordered_multiset<
+      -> unordered_multiset<
         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>
+    template <class InputIterator, class Hash, class Allocator,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multiset(
       InputIterator, InputIterator, std::size_t, Hash, Allocator)
-      ->unordered_multiset<
+      -> unordered_multiset<
         typename std::iterator_traits<InputIterator>::value_type, Hash,
         std::equal_to<typename std::iterator_traits<InputIterator>::value_type>,
         Allocator>;
 
-    template <class T, class Allocator>
+    template <class T, class Allocator,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multiset(std::initializer_list<T>, std::size_t, Allocator)
-      ->unordered_multiset<T, boost::hash<T>, std::equal_to<T>, Allocator>;
+      -> unordered_multiset<T, boost::hash<T>, std::equal_to<T>, Allocator>;
 
-    template <class T, class Hash, class Allocator>
+    template <class T, class Hash, class Allocator,
+      class = std::enable_if_t<detail::is_hash_v<Hash> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
     unordered_multiset(std::initializer_list<T>, std::size_t, Hash, Allocator)
-      ->unordered_multiset<T, Hash, std::equal_to<T>, Allocator>;
+      -> unordered_multiset<T, Hash, std::equal_to<T>, Allocator>;
+
+    template <class InputIterator, class Allocator,
+      class = std::enable_if_t<detail::is_input_iterator_v<InputIterator> >,
+      class = std::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_multiset(InputIterator, InputIterator, Allocator)
+      -> unordered_multiset<
+        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 = std::enable_if_t<detail::is_allocator_v<Allocator> > >
+    unordered_multiset(std::initializer_list<T>, Allocator)
+      -> unordered_multiset<T, boost::hash<T>, std::equal_to<T>, Allocator>;
 
 #endif
 
     ////////////////////////////////////////////////////////////////////////////
     template <class T, class H, class P, class A>
     unordered_set<T, H, P, A>::unordered_set()
-        : table_(boost::unordered::detail::default_bucket_count, hasher(),
-            key_equal(), allocator_type())
     {
     }
 
@@ -1170,9 +1029,8 @@ namespace boost {
             unordered_set::value_allocator_traits::
               select_on_container_copy_construction(other.get_allocator()))
     {
-      if (other.table_.size_) {
-        table_.copy_buckets(
-          other.table_, boost::unordered::detail::true_type());
+      if (other.size()) {
+        table_.copy_buckets(other.table_, std::true_type());
       }
     }
 
@@ -1189,21 +1047,18 @@ namespace boost {
         : table_(other.table_, a)
     {
       if (other.table_.size_) {
-        table_.copy_buckets(
-          other.table_, boost::unordered::detail::true_type());
+        table_.copy_buckets(other.table_, std::true_type());
       }
     }
 
     template <class T, class H, class P, class A>
     unordered_set<T, H, P, A>::unordered_set(
-      BOOST_RV_REF(unordered_set) other, allocator_type const& a)
+      unordered_set&& other, allocator_type const& a)
         : table_(other.table_, a, boost::unordered::detail::move_tag())
     {
       table_.move_construct_buckets(other.table_);
     }
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-
     template <class T, class H, class P, class A>
     unordered_set<T, H, P, A>::unordered_set(
       std::initializer_list<value_type> list, size_type n, const hasher& hf,
@@ -1215,8 +1070,6 @@ namespace boost {
       this->insert(list.begin(), list.end());
     }
 
-#endif
-
     template <class T, class H, class P, class A>
     unordered_set<T, H, P, A>::unordered_set(
       size_type n, const allocator_type& a)
@@ -1231,6 +1084,17 @@ namespace boost {
     {
     }
 
+    template <class T, class H, class P, class A>
+    template <class InputIterator>
+    unordered_set<T, H, P, A>::unordered_set(
+      InputIterator f, InputIterator l, const allocator_type& a)
+        : table_(boost::unordered::detail::initial_size(
+                   f, l, detail::default_bucket_count),
+            hasher(), key_equal(), a)
+    {
+      this->insert(f, l);
+    }
+
     template <class T, class H, class P, class A>
     template <class InputIt>
     unordered_set<T, H, P, A>::unordered_set(
@@ -1251,7 +1115,15 @@ namespace boost {
       this->insert(f, l);
     }
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+    template <class T, class H, class P, class A>
+    unordered_set<T, H, P, A>::unordered_set(
+      std::initializer_list<value_type> list, const allocator_type& a)
+        : table_(boost::unordered::detail::initial_size(
+                   list.begin(), list.end(), detail::default_bucket_count),
+            hasher(), key_equal(), a)
+    {
+      this->insert(list.begin(), list.end());
+    }
 
     template <class T, class H, class P, class A>
     unordered_set<T, H, P, A>::unordered_set(
@@ -1275,15 +1147,11 @@ namespace boost {
       this->insert(list.begin(), list.end());
     }
 
-#endif
-
     template <class T, class H, class P, class A>
-    unordered_set<T, H, P, A>::~unordered_set() BOOST_NOEXCEPT
+    unordered_set<T, H, P, A>::~unordered_set() noexcept
     {
     }
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-
     template <class T, class H, class P, class A>
     unordered_set<T, H, P, A>& unordered_set<T, H, P, A>::operator=(
       std::initializer_list<value_type> list)
@@ -1293,12 +1161,10 @@ namespace boost {
       return *this;
     }
 
-#endif
-
     // size and capacity
 
     template <class T, class H, class P, class A>
-    std::size_t unordered_set<T, H, P, A>::max_size() const BOOST_NOEXCEPT
+    std::size_t unordered_set<T, H, P, A>::max_size() const noexcept
     {
       using namespace std;
 
@@ -1321,49 +1187,39 @@ namespace boost {
       }
     }
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     template <class T, class H, class P, class A>
     void unordered_set<T, H, P, A>::insert(
       std::initializer_list<value_type> list)
     {
       this->insert(list.begin(), list.end());
     }
-#endif
 
     template <class T, class H, class P, class A>
     typename unordered_set<T, H, P, A>::iterator
     unordered_set<T, H, P, A>::erase(const_iterator position)
     {
-      node_pointer node = table::get_node(position);
-      BOOST_ASSERT(node);
-      node_pointer next = table::next_node(node);
-      table_.erase_nodes_unique(node, next);
-      return iterator(next);
+      return table_.erase_node(position);
     }
 
     template <class T, class H, class P, class A>
     typename unordered_set<T, H, P, A>::size_type
     unordered_set<T, H, P, A>::erase(const key_type& k)
     {
-      return table_.erase_key_unique(k);
+      return table_.erase_key_unique_impl(k);
     }
 
     template <class T, class H, class P, class A>
     typename unordered_set<T, H, P, A>::iterator
     unordered_set<T, H, P, A>::erase(const_iterator first, const_iterator last)
     {
-      node_pointer last_node = table::get_node(last);
-      if (first == last)
-        return iterator(last_node);
-      table_.erase_nodes_unique(table::get_node(first), last_node);
-      return iterator(last_node);
+      return table_.erase_nodes_range(first, last);
     }
 
     template <class T, class H, class P, class A>
     void unordered_set<T, H, P, A>::swap(unordered_set& other)
-      BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-          boost::is_nothrow_swappable<H>::value&&
-            boost::is_nothrow_swappable<P>::value)
+      noexcept(value_allocator_traits::is_always_equal::value&&
+          boost::unordered::detail::is_nothrow_swappable<H>::value&&
+            boost::unordered::detail::is_nothrow_swappable<P>::value)
     {
       table_.swap(other.table_);
     }
@@ -1392,7 +1248,6 @@ namespace boost {
       table_.merge_unique(source.table_);
     }
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <class T, class H, class P, class A>
     template <typename H2, typename P2>
     void unordered_set<T, H, P, A>::merge(
@@ -1400,7 +1255,6 @@ namespace boost {
     {
       table_.merge_unique(source.table_);
     }
-#endif
 
     template <class T, class H, class P, class A>
     template <typename H2, typename P2>
@@ -1410,7 +1264,6 @@ namespace boost {
       table_.merge_unique(source.table_);
     }
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <class T, class H, class P, class A>
     template <typename H2, typename P2>
     void unordered_set<T, H, P, A>::merge(
@@ -1418,7 +1271,6 @@ namespace boost {
     {
       table_.merge_unique(source.table_);
     }
-#endif
 
     // lookup
 
@@ -1426,7 +1278,7 @@ namespace boost {
     typename unordered_set<T, H, P, A>::const_iterator
     unordered_set<T, H, P, A>::find(const key_type& k) const
     {
-      return const_iterator(table_.find_node(k));
+      return const_iterator(table_.find(k));
     }
 
     template <class T, class H, class P, class A>
@@ -1436,8 +1288,7 @@ namespace boost {
     unordered_set<T, H, P, A>::find(CompatibleKey const& k,
       CompatibleHash const& hash, CompatiblePredicate const& eq) const
     {
-      return const_iterator(
-        table_.find_node_impl(table::policy::apply_hash(hash, k), k, eq));
+      return table_.transparent_find(k, hash, eq);
     }
 
     template <class T, class H, class P, class A>
@@ -1452,9 +1303,12 @@ namespace boost {
       typename unordered_set<T, H, P, A>::const_iterator>
     unordered_set<T, H, P, A>::equal_range(const key_type& k) const
     {
-      node_pointer n = table_.find_node(k);
-      return std::make_pair(
-        const_iterator(n), const_iterator(n ? table::next_node(n) : n));
+      iterator first = table_.find(k);
+      iterator second = first;
+      if (second != this->end()) {
+        ++second;
+      }
+      return std::make_pair(first, second);
     }
 
     template <class T, class H, class P, class A>
@@ -1467,15 +1321,19 @@ namespace boost {
     // hash policy
 
     template <class T, class H, class P, class A>
-    float unordered_set<T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+    float unordered_set<T, H, P, A>::load_factor() const noexcept
     {
-      BOOST_ASSERT(table_.bucket_count_ != 0);
+      if (table_.size_ == 0) {
+        return 0.0f;
+      }
+
+      BOOST_ASSERT(table_.bucket_count() != 0);
       return static_cast<float>(table_.size_) /
-             static_cast<float>(table_.bucket_count_);
+             static_cast<float>(table_.bucket_count());
     }
 
     template <class T, class H, class P, class A>
-    void unordered_set<T, H, P, A>::max_load_factor(float m) BOOST_NOEXCEPT
+    void unordered_set<T, H, P, A>::max_load_factor(float m) noexcept
     {
       table_.max_load_factor(m);
     }
@@ -1489,8 +1347,7 @@ namespace boost {
     template <class T, class H, class P, class A>
     void unordered_set<T, H, P, A>::reserve(size_type n)
     {
-      table_.rehash(static_cast<std::size_t>(
-        std::ceil(static_cast<double>(n) / table_.mlf_)));
+      table_.reserve(n);
     }
 
     template <class T, class H, class P, class A>
@@ -1520,9 +1377,8 @@ namespace boost {
     }
 
     template <class T, class H, class P, class A>
-    inline void swap(
-      unordered_set<T, H, P, A>& m1, unordered_set<T, H, P, A>& m2)
-      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)))
+    inline void swap(unordered_set<T, H, P, A>& m1,
+      unordered_set<T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)))
     {
 #if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x0613))
       struct dummy
@@ -1533,12 +1389,17 @@ namespace boost {
       m1.swap(m2);
     }
 
+    template <class K, class H, class P, class A, class Predicate>
+    typename unordered_set<K, H, P, A>::size_type erase_if(
+      unordered_set<K, H, P, A>& c, Predicate pred)
+    {
+      return detail::erase_if(c, pred);
+    }
+
     ////////////////////////////////////////////////////////////////////////////
 
     template <class T, class H, class P, class A>
     unordered_multiset<T, H, P, A>::unordered_multiset()
-        : table_(boost::unordered::detail::default_bucket_count, hasher(),
-            key_equal(), allocator_type())
     {
     }
 
@@ -1567,8 +1428,7 @@ namespace boost {
               select_on_container_copy_construction(other.get_allocator()))
     {
       if (other.table_.size_) {
-        table_.copy_buckets(
-          other.table_, boost::unordered::detail::false_type());
+        table_.copy_buckets(other.table_, std::false_type());
       }
     }
 
@@ -1585,21 +1445,18 @@ namespace boost {
         : table_(other.table_, a)
     {
       if (other.table_.size_) {
-        table_.copy_buckets(
-          other.table_, boost::unordered::detail::false_type());
+        table_.copy_buckets(other.table_, std::false_type());
       }
     }
 
     template <class T, class H, class P, class A>
     unordered_multiset<T, H, P, A>::unordered_multiset(
-      BOOST_RV_REF(unordered_multiset) other, allocator_type const& a)
+      unordered_multiset&& other, allocator_type const& a)
         : table_(other.table_, a, boost::unordered::detail::move_tag())
     {
       table_.move_construct_buckets(other.table_);
     }
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-
     template <class T, class H, class P, class A>
     unordered_multiset<T, H, P, A>::unordered_multiset(
       std::initializer_list<value_type> list, size_type n, const hasher& hf,
@@ -1611,8 +1468,6 @@ namespace boost {
       this->insert(list.begin(), list.end());
     }
 
-#endif
-
     template <class T, class H, class P, class A>
     unordered_multiset<T, H, P, A>::unordered_multiset(
       size_type n, const allocator_type& a)
@@ -1627,6 +1482,17 @@ namespace boost {
     {
     }
 
+    template <class T, class H, class P, class A>
+    template <class InputIterator>
+    unordered_multiset<T, H, P, A>::unordered_multiset(
+      InputIterator f, InputIterator l, const allocator_type& a)
+        : table_(boost::unordered::detail::initial_size(
+                   f, l, detail::default_bucket_count),
+            hasher(), key_equal(), a)
+    {
+      this->insert(f, l);
+    }
+
     template <class T, class H, class P, class A>
     template <class InputIt>
     unordered_multiset<T, H, P, A>::unordered_multiset(
@@ -1647,7 +1513,15 @@ namespace boost {
       this->insert(f, l);
     }
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+    template <class T, class H, class P, class A>
+    unordered_multiset<T, H, P, A>::unordered_multiset(
+      std::initializer_list<value_type> list, const allocator_type& a)
+        : table_(boost::unordered::detail::initial_size(
+                   list.begin(), list.end(), detail::default_bucket_count),
+            hasher(), key_equal(), a)
+    {
+      this->insert(list.begin(), list.end());
+    }
 
     template <class T, class H, class P, class A>
     unordered_multiset<T, H, P, A>::unordered_multiset(
@@ -1671,15 +1545,11 @@ namespace boost {
       this->insert(list.begin(), list.end());
     }
 
-#endif
-
     template <class T, class H, class P, class A>
-    unordered_multiset<T, H, P, A>::~unordered_multiset() BOOST_NOEXCEPT
+    unordered_multiset<T, H, P, A>::~unordered_multiset() noexcept
     {
     }
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
-
     template <class T, class H, class P, class A>
     unordered_multiset<T, H, P, A>& unordered_multiset<T, H, P, A>::operator=(
       std::initializer_list<value_type> list)
@@ -1689,12 +1559,10 @@ namespace boost {
       return *this;
     }
 
-#endif
-
     // size and capacity
 
     template <class T, class H, class P, class A>
-    std::size_t unordered_multiset<T, H, P, A>::max_size() const BOOST_NOEXCEPT
+    std::size_t unordered_multiset<T, H, P, A>::max_size() const noexcept
     {
       using namespace std;
 
@@ -1714,24 +1582,19 @@ namespace boost {
       table_.insert_range_equiv(first, last);
     }
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     template <class T, class H, class P, class A>
     void unordered_multiset<T, H, P, A>::insert(
       std::initializer_list<value_type> list)
     {
       this->insert(list.begin(), list.end());
     }
-#endif
 
     template <class T, class H, class P, class A>
     typename unordered_multiset<T, H, P, A>::iterator
     unordered_multiset<T, H, P, A>::erase(const_iterator position)
     {
-      node_pointer node = table::get_node(position);
-      BOOST_ASSERT(node);
-      node_pointer next = table::next_node(node);
-      table_.erase_nodes_equiv(node, next);
-      return iterator(next);
+      BOOST_ASSERT(position != this->end());
+      return table_.erase_node(position);
     }
 
     template <class T, class H, class P, class A>
@@ -1746,18 +1609,14 @@ namespace boost {
     unordered_multiset<T, H, P, A>::erase(
       const_iterator first, const_iterator last)
     {
-      node_pointer last_node = table::get_node(last);
-      if (first == last)
-        return iterator(last_node);
-      table_.erase_nodes_equiv(table::get_node(first), last_node);
-      return iterator(last_node);
+      return table_.erase_nodes_range(first, last);
     }
 
     template <class T, class H, class P, class A>
     void unordered_multiset<T, H, P, A>::swap(unordered_multiset& other)
-      BOOST_NOEXCEPT_IF(value_allocator_traits::is_always_equal::value&&
-          boost::is_nothrow_swappable<H>::value&&
-            boost::is_nothrow_swappable<P>::value)
+      noexcept(value_allocator_traits::is_always_equal::value&&
+          boost::unordered::detail::is_nothrow_swappable<H>::value&&
+            boost::unordered::detail::is_nothrow_swappable<P>::value)
     {
       table_.swap(other.table_);
     }
@@ -1788,7 +1647,6 @@ namespace boost {
       }
     }
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <class T, class H, class P, class A>
     template <typename H2, typename P2>
     void unordered_multiset<T, H, P, A>::merge(
@@ -1798,7 +1656,6 @@ namespace boost {
         insert(source.extract(source.begin()));
       }
     }
-#endif
 
     template <class T, class H, class P, class A>
     template <typename H2, typename P2>
@@ -1810,7 +1667,6 @@ namespace boost {
       }
     }
 
-#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
     template <class T, class H, class P, class A>
     template <typename H2, typename P2>
     void unordered_multiset<T, H, P, A>::merge(
@@ -1820,7 +1676,6 @@ namespace boost {
         insert(source.extract(source.begin()));
       }
     }
-#endif
 
     // lookup
 
@@ -1828,7 +1683,7 @@ namespace boost {
     typename unordered_multiset<T, H, P, A>::const_iterator
     unordered_multiset<T, H, P, A>::find(const key_type& k) const
     {
-      return const_iterator(table_.find_node(k));
+      return const_iterator(table_.find(k));
     }
 
     template <class T, class H, class P, class A>
@@ -1838,16 +1693,14 @@ namespace boost {
     unordered_multiset<T, H, P, A>::find(CompatibleKey const& k,
       CompatibleHash const& hash, CompatiblePredicate const& eq) const
     {
-      return const_iterator(
-        table_.find_node_impl(table::policy::apply_hash(hash, k), k, eq));
+      return table_.transparent_find(k, hash, eq);
     }
 
     template <class T, class H, class P, class A>
     typename unordered_multiset<T, H, P, A>::size_type
     unordered_multiset<T, H, P, A>::count(const key_type& k) const
     {
-      node_pointer n = table_.find_node(k);
-      return n ? table_.group_count(n) : 0;
+      return table_.group_count(k);
     }
 
     template <class T, class H, class P, class A>
@@ -1855,9 +1708,9 @@ namespace boost {
       typename unordered_multiset<T, H, P, A>::const_iterator>
     unordered_multiset<T, H, P, A>::equal_range(const key_type& k) const
     {
-      node_pointer n = table_.find_node(k);
-      return std::make_pair(
-        const_iterator(n), const_iterator(n ? table_.next_group(n) : n));
+      iterator n = table_.find(k);
+      return std::make_pair(const_iterator(n),
+        const_iterator(n == end() ? n : table_.next_group(k, n)));
     }
 
     template <class T, class H, class P, class A>
@@ -1870,15 +1723,19 @@ namespace boost {
     // hash policy
 
     template <class T, class H, class P, class A>
-    float unordered_multiset<T, H, P, A>::load_factor() const BOOST_NOEXCEPT
+    float unordered_multiset<T, H, P, A>::load_factor() const noexcept
     {
-      BOOST_ASSERT(table_.bucket_count_ != 0);
+      if (table_.size_ == 0) {
+        return 0.0f;
+      }
+
+      BOOST_ASSERT(table_.bucket_count() != 0);
       return static_cast<float>(table_.size_) /
-             static_cast<float>(table_.bucket_count_);
+             static_cast<float>(table_.bucket_count());
     }
 
     template <class T, class H, class P, class A>
-    void unordered_multiset<T, H, P, A>::max_load_factor(float m) BOOST_NOEXCEPT
+    void unordered_multiset<T, H, P, A>::max_load_factor(float m) noexcept
     {
       table_.max_load_factor(m);
     }
@@ -1892,8 +1749,7 @@ namespace boost {
     template <class T, class H, class P, class A>
     void unordered_multiset<T, H, P, A>::reserve(size_type n)
     {
-      table_.rehash(static_cast<std::size_t>(
-        std::ceil(static_cast<double>(n) / table_.mlf_)));
+      table_.reserve(n);
     }
 
     template <class T, class H, class P, class A>
@@ -1923,9 +1779,8 @@ namespace boost {
     }
 
     template <class T, class H, class P, class A>
-    inline void swap(
-      unordered_multiset<T, H, P, A>& m1, unordered_multiset<T, H, P, A>& m2)
-      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(m1.swap(m2)))
+    inline void swap(unordered_multiset<T, H, P, A>& m1,
+      unordered_multiset<T, H, P, A>& m2) noexcept(noexcept(m1.swap(m2)))
     {
 #if BOOST_WORKAROUND(BOOST_CODEGEARC, BOOST_TESTED_AT(0x0613))
       struct dummy
@@ -1936,10 +1791,15 @@ namespace boost {
       m1.swap(m2);
     }
 
-    template <typename N, typename T, typename A> class node_handle_set
+    template <class K, class H, class P, class A, class Predicate>
+    typename unordered_multiset<K, H, P, A>::size_type erase_if(
+      unordered_multiset<K, H, P, A>& c, Predicate pred)
     {
-      BOOST_MOVABLE_BUT_NOT_COPYABLE(node_handle_set)
+      return detail::erase_if(c, pred);
+    }
 
+    template <typename N, typename T, typename A> class node_handle_set
+    {
       template <typename Types> friend struct ::boost::unordered::detail::table;
       template <class T2, class H2, class P2, class A2>
       friend class unordered_set;
@@ -1972,10 +1832,9 @@ namespace boost {
       }
 
     public:
-      BOOST_CONSTEXPR node_handle_set() BOOST_NOEXCEPT : ptr_(),
-                                                         has_alloc_(false)
-      {
-      }
+      constexpr node_handle_set() noexcept : ptr_(), has_alloc_(false) {}
+      node_handle_set(node_handle_set const&) = delete;
+      node_handle_set& operator=(node_handle_set const&) = delete;
 
       ~node_handle_set()
       {
@@ -1986,14 +1845,14 @@ namespace boost {
         }
       }
 
-      node_handle_set(BOOST_RV_REF(node_handle_set) n) BOOST_NOEXCEPT
-        : ptr_(n.ptr_),
-          alloc_(boost::move(n.alloc_))
+      node_handle_set(node_handle_set&& n) noexcept
+          : ptr_(n.ptr_),
+            alloc_(std::move(n.alloc_))
       {
         n.ptr_ = node_pointer();
       }
 
-      node_handle_set& operator=(BOOST_RV_REF(node_handle_set) n)
+      node_handle_set& operator=(node_handle_set&& n)
       {
         BOOST_ASSERT(!alloc_.has_value() ||
                      value_allocator_traits::
@@ -2010,7 +1869,7 @@ namespace boost {
         if (!alloc_.has_value() ||
             value_allocator_traits::propagate_on_container_move_assignment::
               value) {
-          alloc_ = boost::move(n.alloc_);
+          alloc_ = std::move(n.alloc_);
         }
         ptr_ = n.ptr_;
         n.ptr_ = node_pointer();
@@ -2022,15 +1881,21 @@ namespace boost {
 
       allocator_type get_allocator() const { return *alloc_; }
 
-      BOOST_EXPLICIT_OPERATOR_BOOL_NOEXCEPT()
+      explicit operator bool() const noexcept
+      {
+        return !this->operator!();
+      }
 
-      bool operator!() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
+      bool operator!() const noexcept { return ptr_ ? 0 : 1; }
 
-      bool empty() const BOOST_NOEXCEPT { return ptr_ ? 0 : 1; }
+      BOOST_ATTRIBUTE_NODISCARD bool empty() const noexcept
+      {
+        return ptr_ ? 0 : 1;
+      }
 
-      void swap(node_handle_set& n) BOOST_NOEXCEPT_IF(
-        value_allocator_traits::propagate_on_container_swap::value ||
-        value_allocator_traits::is_always_equal::value)
+      void swap(node_handle_set& n)
+        noexcept(value_allocator_traits::propagate_on_container_swap::value ||
+                 value_allocator_traits::is_always_equal::value)
       {
         BOOST_ASSERT(
           !alloc_.has_value() || !n.alloc_.has_value() ||
@@ -2038,60 +1903,70 @@ namespace boost {
           alloc_ == n.alloc_);
         if (value_allocator_traits::propagate_on_container_swap::value ||
             !alloc_.has_value() || !n.alloc_.has_value()) {
-          boost::swap(alloc_, n.alloc_);
+          boost::core::invoke_swap(alloc_, n.alloc_);
         }
-        boost::swap(ptr_, n.ptr_);
+        boost::core::invoke_swap(ptr_, n.ptr_);
       }
     };
 
     template <typename N, typename T, typename A>
     void swap(node_handle_set<N, T, A>& x, node_handle_set<N, T, A>& y)
-      BOOST_NOEXCEPT_IF(BOOST_NOEXCEPT_EXPR(x.swap(y)))
+      noexcept(noexcept(x.swap(y)))
     {
       x.swap(y);
     }
 
-    template <typename N, typename T, typename A> struct insert_return_type_set
+    template <class Iter, class NodeType> struct insert_return_type_set
     {
-    private:
-      BOOST_MOVABLE_BUT_NOT_COPYABLE(insert_return_type_set)
-
-      typedef typename boost::unordered::detail::rebind_wrap<A, T>::type
-        value_allocator;
-      typedef N node_;
-
     public:
+      Iter position;
       bool inserted;
-      boost::unordered::iterator_detail::c_iterator<node_> position;
-      boost::unordered::node_handle_set<N, T, A> node;
+      NodeType node;
 
-      insert_return_type_set() : inserted(false), position(), node() {}
+      insert_return_type_set() : position(), inserted(false), node() {}
+      insert_return_type_set(insert_return_type_set const&) = delete;
+      insert_return_type_set& operator=(insert_return_type_set const&) = delete;
 
-      insert_return_type_set(BOOST_RV_REF(insert_return_type_set)
-          x) BOOST_NOEXCEPT : inserted(x.inserted),
-                              position(x.position),
-                              node(boost::move(x.node))
+      insert_return_type_set(insert_return_type_set&& x) noexcept
+          : position(x.position),
+            inserted(x.inserted),
+            node(std::move(x.node))
       {
       }
 
-      insert_return_type_set& operator=(BOOST_RV_REF(insert_return_type_set) x)
+      insert_return_type_set& operator=(insert_return_type_set&& x)
       {
         inserted = x.inserted;
         position = x.position;
-        node = boost::move(x.node);
+        node = std::move(x.node);
         return *this;
       }
     };
 
-    template <typename N, typename T, typename A>
-    void swap(
-      insert_return_type_set<N, T, A>& x, insert_return_type_set<N, T, A>& y)
+    template <class Iter, class NodeType>
+    void swap(insert_return_type_set<Iter, NodeType>& x,
+      insert_return_type_set<Iter, NodeType>& y)
     {
-      boost::swap(x.node, y.node);
-      boost::swap(x.inserted, y.inserted);
-      boost::swap(x.position, y.position);
+      boost::core::invoke_swap(x.node, y.node);
+      boost::core::invoke_swap(x.inserted, y.inserted);
+      boost::core::invoke_swap(x.position, y.position);
     }
   } // namespace unordered
+
+  namespace serialization {
+    template <class K, class H, class P, class A>
+    struct version<boost::unordered_set<K, H, P, A> >
+    {
+      BOOST_STATIC_CONSTANT(int, value = 1);
+    };
+
+    template <class K, class H, class P, class A>
+    struct version<boost::unordered_multiset<K, H, P, A> >
+    {
+      BOOST_STATIC_CONSTANT(int, value = 1);
+    };
+  } // namespace serialization
+
 } // namespace boost
 
 #if defined(BOOST_MSVC)