passenger 6.0.20 → 6.0.21

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/map.hpp

@@ -1,6 +1,7 @@
 
 // Copyright (C) 2005-2016 Daniel James
 // Copyright (C) 2022 Christian Mazakas
+// Copyright (C) 2024 Braden Ganetsky
 // 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)
 
@@ -18,6 +19,7 @@ namespace boost {
         typedef std::pair<K const, M> value_type;
         typedef H hasher;
         typedef P key_equal;
+        typedef K key_type;
         typedef K const const_key_type;
 
         typedef

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/narrow_cast.hpp

@@ -9,21 +9,21 @@
 #ifndef BOOST_UNORDERED_DETAIL_NARROW_CAST_HPP
 #define BOOST_UNORDERED_DETAIL_NARROW_CAST_HPP
 
+#include <boost/unordered/detail/static_assert.hpp>
+
 #include <boost/config.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
+#include <type_traits>
 
 namespace boost{
 namespace unordered{
 namespace detail{
 
 template<typename To,typename From>
-BOOST_CONSTEXPR To narrow_cast(From x) BOOST_NOEXCEPT
+constexpr To narrow_cast(From x) noexcept
 {
-  BOOST_STATIC_ASSERT(boost::is_integral<From>::value);
-  BOOST_STATIC_ASSERT(boost::is_integral<To>::value);
-  BOOST_STATIC_ASSERT(sizeof(From)>=sizeof(To));
+  BOOST_UNORDERED_STATIC_ASSERT(std::is_integral<From>::value);
+  BOOST_UNORDERED_STATIC_ASSERT(std::is_integral<To>::value);
+  BOOST_UNORDERED_STATIC_ASSERT(sizeof(From)>=sizeof(To));
 
   return static_cast<To>(
     x
@@ -32,7 +32,7 @@ BOOST_CONSTEXPR To narrow_cast(From x) BOOST_NOEXCEPT
     /* Avoids VS's "Run-Time Check Failure #1 - A cast to a smaller data type
      * has caused a loss of data."
      */
-    &static_cast<typename boost::make_unsigned<To>::type>(~static_cast<To>(0))
+    &static_cast<typename std::make_unsigned<To>::type>(~static_cast<To>(0))
 #endif
   );
 }

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/opt_storage.hpp

@@ -0,0 +1,30 @@
+// Copyright (C) 2023 Christian Mazakas
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_UNORDERED_DETAIL_OPT_STORAGE_HPP
+#define BOOST_UNORDERED_DETAIL_OPT_STORAGE_HPP
+
+#include <boost/config.hpp>
+
+#include <memory>
+
+namespace boost {
+  namespace unordered {
+    namespace detail {
+      template <class T> union opt_storage
+      {
+        BOOST_ATTRIBUTE_NO_UNIQUE_ADDRESS T t_;
+
+        opt_storage() {}
+        ~opt_storage() {}
+
+        T* address() noexcept { return std::addressof(t_); }
+        T const* address() const noexcept { return std::addressof(t_); }
+      };
+    } // namespace detail
+  } // namespace unordered
+} // namespace boost
+
+#endif // BOOST_UNORDERED_DETAIL_OPT_STORAGE_HPP

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/prime_fmod.hpp

@@ -1,5 +1,5 @@
 // Copyright (C) 2022 Joaquin M Lopez Munoz.
-// Copyright (C) 2022 Christian Mazakas
+// Copyright (C) 2022-2023 Christian Mazakas
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
@@ -7,13 +7,10 @@
 #ifndef BOOST_UNORDERED_DETAIL_PRIME_FMOD_HPP
 #define BOOST_UNORDERED_DETAIL_PRIME_FMOD_HPP
 
-#include <boost/cstdint.hpp>
-#include <boost/preprocessor/seq/enum.hpp>
-#include <boost/preprocessor/seq/for_each.hpp>
-#include <boost/preprocessor/seq/size.hpp>
 #include <boost/unordered/detail/narrow_cast.hpp>
 
 #include <boost/config.hpp>
+#include <boost/cstdint.hpp>
 
 #include <climits>
 #include <cstddef>
@@ -37,21 +34,90 @@ namespace boost {
     namespace detail {
       template <class = void> struct prime_fmod_size
       {
-        // Because we compile for C++03, we don't have access to any inline
-        // initialization for array data members so the definitions must exist
-        // out-of-line. To keep the library header-only, we introduce a dummy
-        // template parameter which permits the definition to be included in
-        // multiple TUs without conflict.
-        //
-        static std::size_t sizes[];
-        static std::size_t const sizes_len;
-        static std::size_t (*positions[])(std::size_t);
+        constexpr static std::size_t const sizes[] = {13ul, 29ul, 53ul, 97ul,
+          193ul, 389ul, 769ul, 1543ul, 3079ul, 6151ul, 12289ul, 24593ul,
+          49157ul, 98317ul, 196613ul, 393241ul, 786433ul, 1572869ul, 3145739ul,
+          6291469ul, 12582917ul, 25165843ul, 50331653ul, 100663319ul,
+          201326611ul, 402653189ul, 805306457ul, 1610612741ul, 3221225473ul,
+#if !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
+          4294967291ul
+#else
+          6442450939ull, 12884901893ull, 25769803751ull, 51539607551ull,
+          103079215111ull, 206158430209ull, 412316860441ull, 824633720831ull,
+          1649267441651ull
+#endif
+        };
+
+        constexpr static std::size_t const sizes_len =
+          sizeof(sizes) / sizeof(sizes[0]);
 
 #if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-        static boost::uint64_t inv_sizes32[];
-        static std::size_t const inv_sizes32_len;
+        constexpr static boost::uint64_t const inv_sizes32[] = {
+          1418980313362273202ull, 636094623231363849ull, 348051774975651918ull,
+          190172619316593316ull, 95578984837873325ull, 47420935922132524ull,
+          23987963684927896ull, 11955116055547344ull, 5991147799191151ull,
+          2998982941588287ull, 1501077717772769ull, 750081082979285ull,
+          375261795343686ull, 187625172388393ull, 93822606204624ull,
+          46909513691883ull, 23456218233098ull, 11728086747027ull,
+          5864041509391ull, 2932024948977ull, 1466014921160ull, 733007198436ull,
+          366503839517ull, 183251896093ull, 91625960335ull, 45812983922ull,
+          22906489714ull, 11453246088ull, 5726623060ull};
+
+        constexpr static std::size_t const inv_sizes32_len =
+          sizeof(inv_sizes32) / sizeof(inv_sizes32[0]);
 #endif /* defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T) */
 
+        template <std::size_t SizeIndex, std::size_t Size = sizes[SizeIndex]>
+        static std::size_t position(std::size_t hash)
+        {
+          return hash % Size;
+        }
+
+        constexpr static std::size_t (*positions[])(std::size_t) = {
+#if !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
+          position<0, sizes[0]>,
+          position<1, sizes[1]>,
+          position<2, sizes[2]>,
+          position<3, sizes[3]>,
+          position<4, sizes[4]>,
+          position<5, sizes[5]>,
+          position<6, sizes[6]>,
+          position<7, sizes[7]>,
+          position<8, sizes[8]>,
+          position<9, sizes[9]>,
+          position<10, sizes[10]>,
+          position<11, sizes[11]>,
+          position<12, sizes[12]>,
+          position<13, sizes[13]>,
+          position<14, sizes[14]>,
+          position<15, sizes[15]>,
+          position<16, sizes[16]>,
+          position<17, sizes[17]>,
+          position<18, sizes[18]>,
+          position<19, sizes[19]>,
+          position<20, sizes[20]>,
+          position<21, sizes[21]>,
+          position<22, sizes[22]>,
+          position<23, sizes[23]>,
+          position<24, sizes[24]>,
+          position<25, sizes[25]>,
+          position<26, sizes[26]>,
+          position<27, sizes[27]>,
+          position<28, sizes[28]>,
+          position<29, sizes[29]>,
+#else
+          position<29, sizes[29]>,
+          position<30, sizes[30]>,
+          position<31, sizes[31]>,
+          position<32, sizes[32]>,
+          position<33, sizes[33]>,
+          position<34, sizes[34]>,
+          position<35, sizes[35]>,
+          position<36, sizes[36]>,
+          position<37, sizes[37]>,
+#endif
+        };
+
         static inline std::size_t size_index(std::size_t n)
         {
           std::size_t i = 0;
@@ -68,11 +134,6 @@ namespace boost {
           return sizes[size_index];
         }
 
-        template <std::size_t Size> static std::size_t modulo(std::size_t hash)
-        {
-          return hash % Size;
-        }
-
 #if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
         // We emulate the techniques taken from:
         // Faster Remainder by Direct Computation: Applications to Compilers and
@@ -118,8 +179,8 @@ namespace boost {
 #if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
           std::size_t sizes_under_32bit = inv_sizes32_len;
           if (BOOST_LIKELY(size_index < sizes_under_32bit)) {
-            return fast_modulo(
-              narrow_cast<boost::uint32_t>(hash) + narrow_cast<boost::uint32_t>(hash >> 32),
+            return fast_modulo(narrow_cast<boost::uint32_t>(hash) +
+                                 narrow_cast<boost::uint32_t>(hash >> 32),
               inv_sizes32[size_index], boost::uint32_t(sizes[size_index]));
           } else {
             return positions[size_index - sizes_under_32bit](hash);
@@ -130,134 +191,24 @@ namespace boost {
         }
       }; // prime_fmod_size
 
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE                      \
-  (13ul)(29ul)(53ul)(97ul)(193ul)(389ul)(769ul)(1543ul)(3079ul)(6151ul)(       \
-    12289ul)(24593ul)(49157ul)(98317ul)(196613ul)(393241ul)(786433ul)(         \
-    1572869ul)(3145739ul)(6291469ul)(12582917ul)(25165843ul)(50331653ul)(      \
-    100663319ul)(201326611ul)(402653189ul)(805306457ul)(1610612741ul)(         \
-    3221225473ul)
-
-#if !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT                                 \
-  BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE(4294967291ul)
+#if defined(BOOST_NO_CXX17_INLINE_VARIABLES)
+      // https://en.cppreference.com/w/cpp/language/static#Constant_static_members
+      // If a const non-inline (since C++17) static data member or a constexpr
+      // static data member (since C++11)(until C++17) is odr-used, a definition
+      // at namespace scope is still required, but it cannot have an
+      // initializer.
+      template <class T> constexpr std::size_t prime_fmod_size<T>::sizes[];
 
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT
-
-#else
-
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT                                 \
-  BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE
-
-// The original sequence here is this:
-// (6442450939ul)
-// (12884901893ul)
-// (25769803751ul)
-// (51539607551ul)
-// (103079215111ul)
-// (206158430209ul)
-// (412316860441ul)
-// (824633720831ul)
-// (1649267441651ul)
-//
-// but this causes problems on versions of mingw where the `long` type is 32
-// bits, even for 64-bit targets. We work around this by replacing the literals
-// with compile-time arithmetic, using bitshifts to reconstruct the number.
-//
-
-// clang-format off
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT                                   \
-  ((boost::ulong_long_type(1ul) << 32)   + boost::ulong_long_type(2147483643ul)) \
-  ((boost::ulong_long_type(3ul) << 32)   + boost::ulong_long_type(5ul))          \
-  ((boost::ulong_long_type(5ul) << 32)   + boost::ulong_long_type(4294967271ul)) \
-  ((boost::ulong_long_type(11ul) << 32)  + boost::ulong_long_type(4294967295ul)) \
-  ((boost::ulong_long_type(24ul) << 32)  + boost::ulong_long_type(7ul))          \
-  ((boost::ulong_long_type(48ul) << 32)  + boost::ulong_long_type(1ul))          \
-  ((boost::ulong_long_type(96ul) << 32)  + boost::ulong_long_type(25ul))         \
-  ((boost::ulong_long_type(191ul) << 32) + boost::ulong_long_type(4294967295ul)) \
-  ((boost::ulong_long_type(383ul) << 32) + boost::ulong_long_type(4294967283ul))
-      // clang-format on
-
-#endif /* BOOST_UNORDERED_FCA_HAS_64B_SIZE_T */
-
-#define BOOST_UNORDERED_PRIME_FMOD_SIZES                                       \
-  BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT
-
-      template <class T>
-      std::size_t prime_fmod_size<T>::sizes[] = {
-        BOOST_PP_SEQ_ENUM(BOOST_UNORDERED_PRIME_FMOD_SIZES)};
-
-      template <class T>
-      std::size_t const prime_fmod_size<T>::sizes_len = BOOST_PP_SEQ_SIZE(
-        BOOST_UNORDERED_PRIME_FMOD_SIZES);
-
-// Similarly here, we have to re-express the integer initialization using
-// arithmetic such that each literal can fit in a 32-bit value.
-//
 #if defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-      // clang-format off
-        template <class T>
-        boost::uint64_t prime_fmod_size<T>::inv_sizes32[] = {
-          (boost::ulong_long_type(330382099ul) << 32) + boost::ulong_long_type(2973438898ul) /* = 1418980313362273202 */,
-          (boost::ulong_long_type(148102320ul) << 32) + boost::ulong_long_type(2369637129ul) /* = 636094623231363849 */,
-          (boost::ulong_long_type(81037118ul) << 32)  + boost::ulong_long_type(3403558990ul) /* = 348051774975651918 */,
-          (boost::ulong_long_type(44278013ul) << 32)  + boost::ulong_long_type(1549730468ul) /* = 190172619316593316 */,
-          (boost::ulong_long_type(22253716ul) << 32)  + boost::ulong_long_type(2403401389ul) /* = 95578984837873325 */,
-          (boost::ulong_long_type(11041047ul) << 32)  + boost::ulong_long_type(143533612ul)  /* = 47420935922132524 */,
-          (boost::ulong_long_type(5585133ul) << 32)   + boost::ulong_long_type(106117528ul)  /* = 23987963684927896 */,
-          (boost::ulong_long_type(2783517ul) << 32)   + boost::ulong_long_type(1572687312ul) /* = 11955116055547344 */,
-          (boost::ulong_long_type(1394922ul) << 32)   + boost::ulong_long_type(3428720239ul) /* = 5991147799191151 */,
-          (boost::ulong_long_type(698255ul) << 32)    + boost::ulong_long_type(552319807ul)  /* = 2998982941588287 */,
-          (boost::ulong_long_type(349496ul) << 32)    + boost::ulong_long_type(3827689953ul) /* = 1501077717772769 */,
-          (boost::ulong_long_type(174641ul) << 32)    + boost::ulong_long_type(3699438549ul) /* = 750081082979285 */,
-          (boost::ulong_long_type(87372ul) << 32)     + boost::ulong_long_type(1912757574ul) /* = 375261795343686 */,
-          (boost::ulong_long_type(43684ul) << 32)     + boost::ulong_long_type(3821029929ul) /* = 187625172388393 */,
-          (boost::ulong_long_type(21844ul) << 32)     + boost::ulong_long_type(3340590800ul) /* = 93822606204624 */,
-          (boost::ulong_long_type(10921ul) << 32)     + boost::ulong_long_type(4175852267ul) /* = 46909513691883 */,
-          (boost::ulong_long_type(5461ul) << 32)      + boost::ulong_long_type(1401829642ul) /* = 23456218233098 */,
-          (boost::ulong_long_type(2730ul) << 32)      + boost::ulong_long_type(2826028947ul) /* = 11728086747027 */,
-          (boost::ulong_long_type(1365ul) << 32)      + boost::ulong_long_type(1411150351ul) /* = 5864041509391 */,
-          (boost::ulong_long_type(682ul) << 32)       + boost::ulong_long_type(2857253105ul) /* = 2932024948977 */,
-          (boost::ulong_long_type(341ul) << 32)       + boost::ulong_long_type(1431073224ul) /* = 1466014921160 */,
-          (boost::ulong_long_type(170ul) << 32)       + boost::ulong_long_type(2862758116ul) /* = 733007198436 */,
-          (boost::ulong_long_type(85ul) << 32)        + boost::ulong_long_type(1431619357ul) /* = 366503839517 */,
-          (boost::ulong_long_type(42ul) << 32)        + boost::ulong_long_type(2863269661ul) /* = 183251896093 */,
-          (boost::ulong_long_type(21ul) << 32)        + boost::ulong_long_type(1431647119ul) /* = 91625960335 */,
-          (boost::ulong_long_type(10ul) << 32)        + boost::ulong_long_type(2863310962ul) /* = 45812983922 */,
-          (boost::ulong_long_type(5ul) << 32)         + boost::ulong_long_type(1431653234ul) /* = 22906489714 */,
-          (boost::ulong_long_type(2ul) << 32)         + boost::ulong_long_type(2863311496ul) /* = 11453246088 */,
-          (boost::ulong_long_type(1ul) << 32)         + boost::ulong_long_type(1431655764ul) /* = 5726623060 */,
-        };
-      // clang-format on
-
       template <class T>
-      std::size_t const
-        prime_fmod_size<T>::inv_sizes32_len = sizeof(inv_sizes32) /
-                                              sizeof(inv_sizes32[0]);
-
-#endif /* defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T) */
-
-#define BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT(z, _, n)                  \
-  prime_fmod_size<T>::template modulo<n>,
+      constexpr boost::uint64_t prime_fmod_size<T>::inv_sizes32[];
+#endif
 
       template <class T>
-      std::size_t (*prime_fmod_size<T>::positions[])(std::size_t) = {
-#if !defined(BOOST_UNORDERED_FCA_HAS_64B_SIZE_T)
-        BOOST_PP_SEQ_FOR_EACH(BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT, ~,
-          BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT)
-#else
-        BOOST_PP_SEQ_FOR_EACH(BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT, ~,
-          BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT)
+      constexpr std::size_t (*prime_fmod_size<T>::positions[])(std::size_t);
 #endif
-      };
-
-#undef BOOST_UNORDERED_PRIME_FMOD_POSITIONS_ELEMENT
-#undef BOOST_UNORDERED_PRIME_FMOD_SIZES
-#undef BOOST_UNORDERED_PRIME_FMOD_SIZES_64BIT
-#undef BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT
-#undef BOOST_UNORDERED_PRIME_FMOD_SIZES_32BIT_INCOMPLETE
     } // namespace detail
-  }   // namespace unordered
+  } // namespace unordered
 } // namespace boost
 
 #endif // BOOST_UNORDERED_DETAIL_PRIME_FMOD_HPP

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/serialization_version.hpp

@@ -0,0 +1,74 @@
+/* Copyright 2023 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_SERIALIZATION_VERSION_HPP
+#define BOOST_UNORDERED_DETAIL_SERIALIZATION_VERSION_HPP
+
+#include <boost/config.hpp>
+#include <boost/core/serialization.hpp>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+
+/* boost::serialization::load_construct_adl(ar,t,version) requires user code
+ * to pass the serialization version for t, when this information is really
+ * stored in the archive. serialization_version<T> circumvents this design
+ * error by acting as a regular serializable type with the same serialization
+ * version as T; loading/saving serialization_version<T> does nothing with
+ * the archive data itself but captures the stored serialization version
+ * at load() time.
+ */
+
+template<typename T>
+struct serialization_version
+{
+  serialization_version():
+    value(boost::serialization::version<serialization_version>::value){}
+
+  serialization_version& operator=(unsigned int x){value=x;return *this;};
+
+  operator unsigned int()const{return value;}
+
+private:
+  friend class boost::serialization::access;
+
+  template<class Archive>
+  void serialize(Archive& ar,unsigned int version)
+  {
+    core::split_member(ar,*this,version);
+  }
+
+  template<class Archive>
+  void save(Archive&,unsigned int)const{}
+
+  template<class Archive>
+  void load(Archive&,unsigned int version)
+  {
+    this->value=version;
+  }
+
+  unsigned int value;
+};
+
+} /* namespace detail */
+} /* namespace unordered */
+
+namespace serialization{
+
+template<typename T>
+struct version<boost::unordered::detail::serialization_version<T> >
+{
+  BOOST_STATIC_CONSTANT(int,value=version<T>::value);
+};
+
+} /* namespace serialization */
+
+} /* namespace boost */
+
+#endif

data/src/cxx_supportlib/vendor-modified/boost/unordered/detail/serialize_container.hpp

@@ -0,0 +1,204 @@
+/* Copyright 2023 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+#ifndef BOOST_UNORDERED_DETAIL_SERIALIZE_CONTAINER_HPP
+#define BOOST_UNORDERED_DETAIL_SERIALIZE_CONTAINER_HPP
+
+#include <boost/core/serialization.hpp>
+#include <boost/throw_exception.hpp>
+#include <boost/unordered/detail/archive_constructed.hpp>
+#include <boost/unordered/detail/bad_archive_exception.hpp>
+#include <boost/unordered/detail/serialization_version.hpp>
+#include <cstddef>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+
+/* serialize_container(ar,x,v) serializes any of the unordered associative
+ * containers in Boost.Unordered. Iterator serialization is also supported
+ * through the following protocol: 
+ *  - At saving time, for each iterator it in [x.begin(),x.end()),
+ *    serialization_track(ar,it) is ADL-called to instruct the archive to
+ *    track the positions internally pointed to by the iterator via
+ *    track_address().
+ *  - At loading time, these addresses are mapped to those of the equivalent
+ *    reconstructed positions using again serialization_track(ar,it).
+ *  - Serializing an iterator reduces to serializing pointers to previously
+ *    tracked addresses via serialize_address().
+ */
+
+template<typename Iterator>
+std::pair<Iterator,bool> adapt_insert_return_type(Iterator it)
+{
+  return std::pair<Iterator,bool>(it,true);
+}
+
+template<typename Iterator>
+std::pair<Iterator,bool> adapt_insert_return_type(std::pair<Iterator,bool> p)
+{
+  return p;
+}
+
+template<typename Set,bool IsSaving> struct load_or_save_unordered_set;
+
+template<typename Set> struct load_or_save_unordered_set<Set,true> /* save */
+{
+  template<typename Archive>
+  void operator()(Archive& ar,const Set& x,unsigned int)const
+  {
+    typedef typename Set::value_type     value_type;
+    typedef typename Set::const_iterator const_iterator;
+
+    const std::size_t                       s=x.size();
+    const serialization_version<value_type> value_version;
+
+    ar<<core::make_nvp("count",s);
+    ar<<core::make_nvp("value_version",value_version);
+
+    for(const_iterator first=x.begin(),last=x.end();first!=last;++first){
+      core::save_construct_data_adl(ar,std::addressof(*first),value_version);
+      ar<<core::make_nvp("item",*first);
+      serialization_track(ar,first);
+    }
+  }
+};
+
+template<typename Set> struct load_or_save_unordered_set<Set,false> /* load */
+{
+  template<typename Archive>
+  void operator()(Archive& ar,Set& x,unsigned int)const
+  {
+    typedef typename Set::value_type value_type;
+    typedef typename Set::iterator   iterator;
+
+    std::size_t                       s;
+    serialization_version<value_type> value_version;
+
+    ar>>core::make_nvp("count",s);
+    ar>>core::make_nvp("value_version",value_version);
+
+    x.clear();
+    x.reserve(s); /* critical so that iterator tracking is stable */
+
+    for(std::size_t n=0;n<s;++n){
+      archive_constructed<value_type> value("item",ar,value_version);
+
+      std::pair<iterator,bool> p=adapt_insert_return_type(
+        x.insert(std::move(value.get())));
+      if(!p.second)throw_exception(bad_archive_exception());
+      ar.reset_object_address(
+        std::addressof(*p.first),std::addressof(value.get()));
+      serialization_track(ar,p.first);
+    }
+  }
+};
+
+template<typename Map,bool IsSaving> struct load_or_save_unordered_map;
+
+template<typename Map> struct load_or_save_unordered_map<Map,true> /* save */
+{
+  template<typename Archive>
+  void operator()(Archive& ar,const Map& x,unsigned int)const
+  {
+    typedef typename std::remove_const<
+      typename Map::key_type>::type       key_type;
+    typedef typename std::remove_const<
+      typename Map::mapped_type>::type    mapped_type;
+    typedef typename Map::const_iterator  const_iterator;
+
+    const std::size_t                        s=x.size();
+    const serialization_version<key_type>    key_version;
+    const serialization_version<mapped_type> mapped_version;
+
+    ar<<core::make_nvp("count",s);
+    ar<<core::make_nvp("key_version",key_version);
+    ar<<core::make_nvp("mapped_version",mapped_version);
+
+    for(const_iterator first=x.begin(),last=x.end();first!=last;++first){
+      /* To remain lib-independent from Boost.Serialization and not rely on
+       * the user having included the serialization code for std::pair
+       * (boost/serialization/utility.hpp), we serialize the key and the
+       * mapped value separately.
+       */
+
+      core::save_construct_data_adl(
+        ar,std::addressof(first->first),key_version);
+      ar<<core::make_nvp("key",first->first);
+      core::save_construct_data_adl(
+        ar,std::addressof(first->second),mapped_version);
+      ar<<core::make_nvp("mapped",first->second);
+      serialization_track(ar,first);
+    }
+  }
+};
+
+template<typename Map> struct load_or_save_unordered_map<Map,false> /* load */
+{
+  template<typename Archive>
+  void operator()(Archive& ar,Map& x,unsigned int)const
+  {
+    typedef typename std::remove_const<
+      typename Map::key_type>::type       key_type;
+    typedef typename std::remove_const<
+      typename Map::mapped_type>::type    mapped_type;
+    typedef typename Map::iterator        iterator;
+
+    std::size_t                        s;
+    serialization_version<key_type>    key_version;
+    serialization_version<mapped_type> mapped_version;
+
+    ar>>core::make_nvp("count",s);
+    ar>>core::make_nvp("key_version",key_version);
+    ar>>core::make_nvp("mapped_version",mapped_version);
+
+    x.clear();
+    x.reserve(s); /* critical so that iterator tracking is stable */
+
+    for(std::size_t n=0;n<s;++n){
+      archive_constructed<key_type>    key("key",ar,key_version);
+      archive_constructed<mapped_type> mapped("mapped",ar,mapped_version);
+
+      std::pair<iterator,bool> p=adapt_insert_return_type(
+        x.emplace(std::move(key.get()),std::move(mapped.get())));
+      if(!p.second)throw_exception(bad_archive_exception());
+      ar.reset_object_address(
+        std::addressof(p.first->first),std::addressof(key.get()));
+      ar.reset_object_address(
+        std::addressof(p.first->second),std::addressof(mapped.get()));
+      serialization_track(ar,p.first);
+    }
+  }
+};
+
+template<typename Container,bool IsSet,bool IsSaving>
+struct load_or_save_container;
+  
+template<typename Set,bool IsSaving>
+struct load_or_save_container<Set,true,IsSaving>:
+  load_or_save_unordered_set<Set,IsSaving>{};
+
+template<typename Map,bool IsSaving>
+struct load_or_save_container<Map,false,IsSaving>:
+  load_or_save_unordered_map<Map,IsSaving>{};
+
+template<typename Archive,typename Container>
+void serialize_container(Archive& ar,Container& x,unsigned int version)
+{
+  load_or_save_container<
+    Container,
+    std::is_same<
+      typename Container::key_type,typename Container::value_type>::value,
+    Archive::is_saving::value>()(ar,x,version);
+}
+
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif