passenger 6.0.20 → 6.0.22

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

@@ -1,7 +1,7 @@
-
 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
 // Copyright (C) 2005-2011 Daniel James.
-// Copyright (C) 2022 Christian Mazakas
+// 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)
 
@@ -15,16 +15,13 @@
 #pragma once
 #endif
 
-#include <boost/unordered/detail/requires_cxx11.hpp>
-#include <boost/core/explicit_operator_bool.hpp>
-#include <boost/functional/hash.hpp>
-#include <boost/move/move.hpp>
+#include <boost/unordered/detail/serialize_fca_container.hpp>
 #include <boost/unordered/detail/set.hpp>
 #include <boost/unordered/detail/type_traits.hpp>
 
-#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
+#include <boost/container_hash/hash.hpp>
+
 #include <initializer_list>
-#endif
 
 #if defined(BOOST_MSVC)
 #pragma warning(push)
@@ -41,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;
 
@@ -96,28 +90,23 @@ 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&);
 
@@ -133,7 +122,6 @@ 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(
@@ -141,263 +129,100 @@ namespace boost {
 
       unordered_set(std::initializer_list<value_type>, size_type, const hasher&,
         const allocator_type&);
-#endif
 
       // Destructor
 
-      ~unordered_set() BOOST_NOEXCEPT;
+      ~unordered_set() noexcept;
 
-// Assign
+      // Assign
 
-#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;
-      }
-
-      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
 
-      BOOST_ATTRIBUTE_NODISCARD bool empty() const BOOST_NOEXCEPT
+      BOOST_ATTRIBUTE_NODISCARD bool empty() const 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
+      size_type size() const noexcept { return table_.size_; }
 
-#if !BOOST_UNORDERED_SUN_WORKAROUNDS1
+      size_type max_size() const noexcept;
 
-      // 0 argument emplace requires special treatment in case
-      // the container is instantiated with a value type that
-      // doesn't have a default constructor.
+      // emplace
 
-      std::pair<iterator, bool> emplace(
-        boost::unordered::detail::empty_emplace =
-          boost::unordered::detail::empty_emplace(),
-        value_type v = value_type())
-      {
-        return this->emplace(boost::move(v));
-      }
-
-#endif
-
-      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)));
-      }
-
-      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)));
-      }
-
-      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(std::forward<Args>(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)...);
+          table::extractor::extract(std::forward<Args>(args)...),
+          std::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 table_.emplace_hint_unique(hint,
-          table::extractor::extract(boost::forward<A0>(a0)),
-          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)
-      {
-        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)));
-      }
-
-      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 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)));
-      }
-
-#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)
+      std::pair<iterator, bool> insert(value_type&& x)
       {
-        return this->emplace(boost::move(x));
+        return this->emplace(std::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)
+      insert(Key&& k)
       {
-        return table_.try_emplace_unique(boost::forward<Key>(k));
+        return table_.try_emplace_unique(std::forward<Key>(k));
       }
 
       iterator insert(const_iterator hint, value_type const& x)
@@ -405,37 +230,38 @@ namespace boost {
         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 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)
+      insert(const_iterator hint, Key&& k)
       {
-        return table_.try_emplace_hint_unique(hint, boost::forward<Key>(k));
+        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_impl(k), table_.node_alloc());
+        return node_type(
+          table_.extract_by_key_impl(k),
+          allocator_type(table_.node_alloc()));
       }
 
       template <class Key>
@@ -444,31 +270,23 @@ namespace boost {
         node_type>::type
       extract(const Key& k)
       {
-        return node_type(table_.extract_by_key_impl(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)
+      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);
@@ -477,9 +295,9 @@ namespace boost {
       typename boost::enable_if_c<
         detail::transparent_non_iterable<Key, unordered_set>::value,
         size_type>::type
-      erase(BOOST_FWD_REF(Key) k)
+      erase(Key&& k)
       {
-        return table_.erase_key_unique_impl(boost::forward<Key>(k));
+        return table_.erase_key_unique_impl(std::forward<Key>(k));
       }
 
       BOOST_UNORDERED_DEPRECATED("Use erase instead")
@@ -488,26 +306,22 @@ namespace boost {
       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
 
@@ -573,12 +387,9 @@ namespace boost {
 
       // bucket interface
 
-      size_type bucket_count() const BOOST_NOEXCEPT
-      {
-        return table_.bucket_count();
-      }
+      size_type bucket_count() const noexcept { return table_.bucket_count(); }
 
-      size_type max_bucket_count() const BOOST_NOEXCEPT
+      size_type max_bucket_count() const noexcept
       {
         return table_.max_bucket_count();
       }
@@ -593,9 +404,9 @@ namespace boost {
       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
+      bucket(Key&& k) const
       {
-        return table_.hash_to_bucket(table_.hash(boost::forward<Key>(k)));
+        return table_.hash_to_bucket(table_.hash(std::forward<Key>(k)));
       }
 
       local_iterator begin(size_type n)
@@ -627,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);
 
@@ -641,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,
@@ -650,10 +468,10 @@ namespace boost {
         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> > >
+      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())
@@ -662,17 +480,17 @@ namespace boost {
 
     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> > >
+      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>;
 
     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> > >
+      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,
         boost::hash<typename std::iterator_traits<InputIterator>::value_type>,
@@ -680,9 +498,9 @@ namespace boost {
         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> > >
+      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,
         Hash,
@@ -690,19 +508,19 @@ namespace boost {
         Allocator>;
 
     template <class T, class Allocator,
-      class = boost::enable_if_t<detail::is_allocator_v<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>;
 
     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> > >
+      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>;
 
     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> > >
+      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>,
@@ -710,7 +528,7 @@ namespace boost {
         Allocator>;
 
     template <class T, class Allocator,
-      class = boost::enable_if_t<detail::is_allocator_v<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>;
 
@@ -718,9 +536,6 @@ namespace boost {
 
     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;
 
@@ -772,29 +587,23 @@ 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&);
 
@@ -811,7 +620,6 @@ 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&);
 
@@ -820,265 +628,99 @@ namespace boost {
 
       unordered_multiset(std::initializer_list<value_type>, size_type,
         const hasher&, const allocator_type&);
-#endif
 
       // Destructor
 
-      ~unordered_multiset() BOOST_NOEXCEPT;
+      ~unordered_multiset() 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& 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
 
-      BOOST_ATTRIBUTE_NODISCARD bool empty() const BOOST_NOEXCEPT
+      BOOST_ATTRIBUTE_NODISCARD bool empty() const 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)
-      {
-        return iterator(table_.emplace_equiv(
-          boost::unordered::detail::func::construct_node_from_args(
-            table_.node_alloc(), 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.
+      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));
-      }
-
-#endif
-
-      template <typename A0> iterator emplace(BOOST_FWD_REF(A0) a0)
-      {
-        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)))));
-      }
+      size_type max_size() const noexcept;
 
-      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)))));
-      }
+      // emplace
 
-      template <typename A0, typename A1, typename A2>
-      iterator emplace(
-        BOOST_FWD_REF(A0) a0, BOOST_FWD_REF(A1) a1, BOOST_FWD_REF(A2) a2)
+      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), boost::forward<A1>(a1),
-              boost::forward<A2>(a2)))));
+            table_.node_alloc(), 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)
-      {
-        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
 
@@ -1102,26 +744,16 @@ namespace boost {
         return node_type(table_.extract_by_key_impl(k), table_.node_alloc());
       }
 
-      iterator insert(BOOST_RV_REF(node_type) np)
+      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&);
 
@@ -1141,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
 
@@ -1222,12 +850,9 @@ namespace boost {
 
       // bucket interface
 
-      size_type bucket_count() const BOOST_NOEXCEPT
-      {
-        return table_.bucket_count();
-      }
+      size_type bucket_count() const noexcept { return table_.bucket_count(); }
 
-      size_type max_bucket_count() const BOOST_NOEXCEPT
+      size_type max_bucket_count() const noexcept
       {
         return table_.max_bucket_count();
       }
@@ -1242,9 +867,9 @@ namespace boost {
       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
+      bucket(Key&& k) const
       {
-        return table_.hash_to_bucket(table_.hash(boost::forward<Key>(k)));
+        return table_.hash_to_bucket(table_.hash(std::forward<Key>(k)));
       }
 
       local_iterator begin(size_type n)
@@ -1276,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);
 
@@ -1290,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,
@@ -1299,10 +931,10 @@ namespace boost {
         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> > >
+      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())
@@ -1312,17 +944,17 @@ namespace boost {
 
     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> > >
+      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>;
 
     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> > >
+      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<
         typename std::iterator_traits<InputIterator>::value_type,
@@ -1331,9 +963,9 @@ namespace boost {
         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> > >
+      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<
@@ -1342,19 +974,19 @@ namespace boost {
         Allocator>;
 
     template <class T, class Allocator,
-      class = boost::enable_if_t<detail::is_allocator_v<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>;
 
     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> > >
+      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>;
 
     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> > >
+      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,
@@ -1363,7 +995,7 @@ namespace boost {
         Allocator>;
 
     template <class T, class Allocator,
-      class = boost::enable_if_t<detail::is_allocator_v<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>;
 
@@ -1398,8 +1030,7 @@ namespace boost {
               select_on_container_copy_construction(other.get_allocator()))
     {
       if (other.size()) {
-        table_.copy_buckets(
-          other.table_, boost::unordered::detail::true_type());
+        table_.copy_buckets(other.table_, std::true_type());
       }
     }
 
@@ -1416,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,
@@ -1442,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)
@@ -1489,8 +1115,6 @@ 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)
@@ -1523,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)
@@ -1541,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;
 
@@ -1569,14 +1187,12 @@ 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
@@ -1601,9 +1217,9 @@ namespace boost {
 
     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_);
     }
@@ -1632,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(
@@ -1640,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>
@@ -1650,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(
@@ -1658,7 +1271,6 @@ namespace boost {
     {
       table_.merge_unique(source.table_);
     }
-#endif
 
     // lookup
 
@@ -1709,7 +1321,7 @@ 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
     {
       if (table_.size_ == 0) {
         return 0.0f;
@@ -1721,7 +1333,7 @@ namespace boost {
     }
 
     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);
     }
@@ -1765,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
@@ -1817,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());
       }
     }
 
@@ -1835,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,
@@ -1861,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)
@@ -1908,8 +1513,6 @@ 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)
@@ -1942,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)
@@ -1960,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;
 
@@ -1985,14 +1582,12 @@ 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
@@ -2019,9 +1614,9 @@ namespace boost {
 
     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_);
     }
@@ -2052,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(
@@ -2062,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>
@@ -2074,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(
@@ -2084,7 +1676,6 @@ namespace boost {
         insert(source.extract(source.begin()));
       }
     }
-#endif
 
     // lookup
 
@@ -2132,7 +1723,7 @@ 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
     {
       if (table_.size_ == 0) {
         return 0.0f;
@@ -2144,7 +1735,7 @@ namespace boost {
     }
 
     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);
     }
@@ -2188,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
@@ -2210,8 +1800,6 @@ namespace boost {
 
     template <typename N, typename T, typename A> class node_handle_set
     {
-      BOOST_MOVABLE_BUT_NOT_COPYABLE(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;
@@ -2244,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()
       {
@@ -2258,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::
@@ -2282,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();
@@ -2294,18 +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; }
 
-      BOOST_ATTRIBUTE_NODISCARD bool empty() const BOOST_NOEXCEPT
+      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() ||
@@ -2313,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 <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;
       NodeType 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 : position(x.position),
-                              inserted(x.inserted),
-                              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 <class Iter, class NodeType>
-    void swap(
-      insert_return_type_set<Iter, NodeType>& x, insert_return_type_set<Iter, NodeType>& y)
+    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)