passenger 6.0.20 → 6.0.21

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

@@ -0,0 +1,156 @@
+/* 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_FCA_CONTAINER_HPP
+#define BOOST_UNORDERED_DETAIL_SERIALIZE_FCA_CONTAINER_HPP
+
+#include <boost/unordered/detail/serialize_container.hpp>
+
+#if defined(BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0)
+
+#define BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER \
+  <boost/serialization/archive_input_unordered_map.hpp>
+#include BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER
+#undef BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER
+#define BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER \
+  <boost/serialization/archive_input_unordered_set.hpp>
+#include BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER
+#undef BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER
+#define BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER \
+  <boost/serialization/unordered_collections_load_imp.hpp>
+#include BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER
+#undef BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER
+#define BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER \
+  <boost/serialization/utility.hpp>
+#include BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER
+#undef BOOST_UNORDERED_BLOCK_BOOSTDEP_HEADER
+
+#include <boost/unordered/unordered_map_fwd.hpp>
+#include <boost/unordered/unordered_set_fwd.hpp>
+
+#else
+
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+
+#endif
+
+namespace boost{
+namespace unordered{
+namespace detail{
+
+/* Support for boost::unordered_[multi](map|set) loading from legacy archives.
+ * Until Boost 1.84, serialization of these containers was provided from
+ * Boost.Serialization via boost/serialization/boost_unordered_(map|set).hpp,
+ * from that release on support is native in Boost.Unordered. To enable legacy
+ * archive loading, BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0
+ * must be defined (it implies header dependency from Boost.Serialization).
+ */
+
+#if defined(BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0)
+
+template<typename Archive,typename Container>
+struct archive_input;
+
+template<
+  typename Archive,typename K,typename T,typename H,typename P,typename A
+>
+struct archive_input<Archive,boost::unordered_map<K,T,H,P,A> >:
+  boost::serialization::stl::archive_input_unordered_map<
+    Archive,
+    boost::unordered_map<K,T,H,P,A>
+  >
+{};
+
+template<
+  typename Archive,typename K,typename T,typename H,typename P,typename A
+>
+struct archive_input<Archive,boost::unordered_multimap<K,T,H,P,A> >:
+  boost::serialization::stl::archive_input_unordered_multimap<
+    Archive,
+    boost::unordered_multimap<K,T,H,P,A>
+  >
+{};
+
+template<
+  typename Archive,typename K,typename H,typename P,typename A
+>
+struct archive_input<Archive,boost::unordered_set<K,H,P,A> >:
+  boost::serialization::stl::archive_input_unordered_set<
+    Archive,
+    boost::unordered_set<K,H,P,A>
+  >
+{};
+
+template<
+  typename Archive,typename K,typename H,typename P,typename A
+>
+struct archive_input<Archive,boost::unordered_multiset<K,H,P,A> >:
+  boost::serialization::stl::archive_input_unordered_multiset<
+    Archive,
+    boost::unordered_multiset<K,H,P,A>
+  >
+{};
+
+#else
+
+struct legacy_archive_exception:std::runtime_error
+{
+  legacy_archive_exception():std::runtime_error(
+    "Legacy archive detected, define "
+    "BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0 to load"){}
+};
+
+#endif
+
+template<typename Container,bool IsSaving>
+struct load_or_save_fca_container;
+
+template<typename Container>
+struct load_or_save_fca_container<Container,true> /* save */
+{
+  template<typename Archive>
+  void operator()(Archive& ar,Container& x,unsigned int version)const
+  {
+    serialize_container(ar,x,version);
+  }
+};
+
+template<typename Container>
+struct load_or_save_fca_container<Container,false> /* load */
+{
+  template<typename Archive>
+  void operator()(Archive& ar,Container& x,unsigned int version)const
+  {
+    if(version==0){
+#if defined(BOOST_UNORDERED_ENABLE_SERIALIZATION_COMPATIBILITY_V0)
+      boost::serialization::stl::load_unordered_collection<
+        Archive,Container,archive_input<Archive,Container>
+      >(ar,x);
+#else
+      throw_exception(legacy_archive_exception());
+#endif
+    }
+    else{
+      serialize_container(ar,x,version);
+    }
+  }
+};
+
+template<typename Archive,typename Container>
+void serialize_fca_container(Archive& ar,Container& x,unsigned int version)
+{
+  load_or_save_fca_container<Container,Archive::is_saving::value>()(
+    ar,x,version);
+}
+
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif

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

@@ -0,0 +1,104 @@
+/* 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_TRACKED_ADDRESS_HPP
+#define BOOST_UNORDERED_DETAIL_SERIALIZE_TRACKED_ADDRESS_HPP
+
+#include <boost/unordered/detail/bad_archive_exception.hpp>
+
+#include <boost/core/pointer_traits.hpp>
+#include <boost/core/serialization.hpp>
+#include <boost/throw_exception.hpp>
+
+#include <type_traits>
+
+namespace boost{
+namespace unordered{
+namespace detail{
+
+/* Tracked address serialization to support iterator serialization as described
+ * in serialize_container.hpp. The underlying technique is to reinterpret_cast
+ * T pointers to serialization_tracker<T> pointers, which, when dereferenced
+ * and serialized, do not emit any serialization payload to the
+ * archive, but activate object tracking on the relevant addresses for later
+ * use with serialize_tracked_address().
+ */
+
+template<typename T>
+struct serialization_tracker
+{
+  /* An attempt to construct a serialization_tracker means a stray address
+   * in the archive, that is, one without a previously tracked address.
+   */
+  serialization_tracker(){throw_exception(bad_archive_exception());}
+
+  template<typename Archive>
+  void serialize(Archive&,unsigned int){} /* no data emitted */
+};
+
+template<typename Archive,typename Ptr>
+void track_address(Archive& ar,Ptr p)
+{
+  typedef typename boost::pointer_traits<Ptr> ptr_traits;
+  typedef typename std::remove_const<
+    typename ptr_traits::element_type>::type  element_type;
+
+  if(p){
+    ar&core::make_nvp(
+      "address",
+      *reinterpret_cast<serialization_tracker<element_type>*>(
+        const_cast<element_type*>(
+          boost::to_address(p))));
+  }
+}
+
+template<typename Archive,typename Ptr>
+void serialize_tracked_address(Archive& ar,Ptr& p,std::true_type /* save */)
+{
+  typedef typename boost::pointer_traits<Ptr> ptr_traits;
+  typedef typename std::remove_const<
+    typename ptr_traits::element_type>::type  element_type;
+  typedef serialization_tracker<element_type> tracker;
+
+  tracker* pt=
+    const_cast<tracker*>(
+      reinterpret_cast<const tracker*>(
+        const_cast<const element_type*>(
+          boost::to_address(p))));
+  ar<<core::make_nvp("pointer",pt);
+}
+
+template<typename Archive,typename Ptr>
+void serialize_tracked_address(Archive& ar,Ptr& p,std::false_type /* load */)
+{
+  typedef typename boost::pointer_traits<Ptr> ptr_traits;
+  typedef typename std::remove_const<
+    typename ptr_traits::element_type>::type  element_type;
+  typedef serialization_tracker<element_type> tracker;
+
+  tracker* pt;
+  ar>>core::make_nvp("pointer",pt);
+  element_type* pn=const_cast<element_type*>(
+    reinterpret_cast<const element_type*>(
+      const_cast<const tracker*>(pt)));
+  p=pn?ptr_traits::pointer_to(*pn):0;
+}
+
+template<typename Archive,typename Ptr>
+void serialize_tracked_address(Archive& ar,Ptr& p)
+{
+  serialize_tracked_address(
+    ar,p,
+    std::integral_constant<bool,Archive::is_saving::value>());
+}
+
+} /* namespace detail */
+} /* namespace unordered */
+} /* namespace boost */
+
+#endif

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

@@ -0,0 +1,16 @@
+// Copyright 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#ifndef BOOST_UNORDERED_DETAIL_STATIC_ASSERT_HPP
+#define BOOST_UNORDERED_DETAIL_STATIC_ASSERT_HPP
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#define BOOST_UNORDERED_STATIC_ASSERT(...)                                     \
+  static_assert(__VA_ARGS__, #__VA_ARGS__)
+
+#endif // BOOST_UNORDERED_DETAIL_STATIC_ASSERT_HPP

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

@@ -0,0 +1,30 @@
+// Copyright (C) 2023 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)
+
+#ifndef BOOST_UNORDERED_DETAIL_THROW_EXCEPTION_HPP
+#define BOOST_UNORDERED_DETAIL_THROW_EXCEPTION_HPP
+
+#include <boost/config.hpp>
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#pragma once
+#endif
+
+#include <boost/throw_exception.hpp>
+#include <stdexcept>
+
+namespace boost {
+  namespace unordered {
+    namespace detail {
+
+      BOOST_NOINLINE BOOST_NORETURN inline void throw_out_of_range(
+        char const* message)
+      {
+        boost::throw_exception(std::out_of_range(message));
+      }
+
+    } // namespace detail
+  } // namespace unordered
+} // namespace boost
+
+#endif // BOOST_UNORDERED_DETAIL_THROW_EXCEPTION_HPP

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

@@ -1,4 +1,5 @@
-// Copyright (C) 2022 Christian Mazakas
+// Copyright (C) 2022-2023 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)
@@ -11,20 +12,15 @@
 #pragma once
 #endif
 
-#include <boost/type_traits/integral_constant.hpp>
-#include <boost/type_traits/is_convertible.hpp>
-#include <boost/type_traits/make_void.hpp>
-#include <boost/type_traits/type_identity.hpp>
+#include <boost/config/workaround.hpp>
 
 #if !defined(BOOST_NO_CXX17_DEDUCTION_GUIDES)
-#include <boost/type_traits/enable_if.hpp>
-#include <boost/type_traits/is_integral.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
 #include <iterator>
-#include <utility>
 #endif
 
+#include <type_traits>
+#include <utility>
+
 // BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
 
 #if !defined(BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES)
@@ -40,19 +36,110 @@
 namespace boost {
   namespace unordered {
     namespace detail {
+
+      template <class T> struct type_identity
+      {
+        using type = T;
+      };
+
+      template <typename... Ts> struct make_void
+      {
+        typedef void type;
+      };
+
+      template <typename... Ts> using void_t = typename make_void<Ts...>::type;
+
+      template <class T, class = void> struct is_complete : std::false_type
+      {
+      };
+
+      template <class T>
+      struct is_complete<T, void_t<int[sizeof(T)]> > : std::true_type
+      {
+      };
+
+      template <class T>
+      using is_complete_and_move_constructible =
+        typename std::conditional<is_complete<T>::value,
+          std::is_move_constructible<T>, std::false_type>::type;
+
+#if BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 50000)
+      /* std::is_trivially_default_constructible not provided */
+      template <class T>
+      struct is_trivially_default_constructible
+          : public std::integral_constant<bool,
+              std::is_default_constructible<T>::value &&
+                std::has_trivial_default_constructor<T>::value>
+      {
+      };
+#else
+      using std::is_trivially_default_constructible;
+#endif
+
+#if BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 50000)
+      /* std::is_trivially_copy_constructible not provided */
+      template <class T>
+      struct is_trivially_copy_constructible
+          : public std::integral_constant<bool,
+              std::is_copy_constructible<T>::value &&
+                std::has_trivial_copy_constructor<T>::value>
+      {
+      };
+#else
+      using std::is_trivially_copy_constructible;
+#endif
+
+#if BOOST_WORKAROUND(BOOST_LIBSTDCXX_VERSION, < 50000)
+      /* std::is_trivially_copy_assignable not provided */
+      template <class T>
+      struct is_trivially_copy_assignable
+          : public std::integral_constant<bool,
+              std::is_copy_assignable<T>::value &&
+                std::has_trivial_copy_assign<T>::value>
+      {
+      };
+#else
+      using std::is_trivially_copy_assignable;
+#endif
+
+      namespace type_traits_detail {
+        using std::swap;
+
+        template <class T, class = void> struct is_nothrow_swappable_helper
+        {
+          constexpr static bool const value = false;
+        };
+
+        template <class T>
+        struct is_nothrow_swappable_helper<T,
+          void_t<decltype(swap(std::declval<T&>(), std::declval<T&>()))> >
+        {
+          constexpr static bool const value =
+            noexcept(swap(std::declval<T&>(), std::declval<T&>()));
+        };
+
+      } // namespace type_traits_detail
+
+      template <class T>
+      struct is_nothrow_swappable
+          : public std::integral_constant<bool,
+              type_traits_detail::is_nothrow_swappable_helper<T>::value>
+      {
+      };
+
       ////////////////////////////////////////////////////////////////////////////
       // Type checkers used for the transparent member functions added by C++20
       // and up
 
       template <class, class = void>
-      struct is_transparent : public boost::false_type
+      struct is_transparent : public std::false_type
       {
       };
 
       template <class T>
       struct is_transparent<T,
-        typename boost::make_void<typename T::is_transparent>::type>
-          : public boost::true_type
+        boost::unordered::detail::void_t<typename T::is_transparent> >
+          : public std::true_type
       {
       };
 
@@ -71,8 +158,25 @@ namespace boost {
 
         static bool const value =
           are_transparent<Key, hash, key_equal>::value &&
-          !boost::is_convertible<Key, iterator>::value &&
-          !boost::is_convertible<Key, const_iterator>::value;
+          !std::is_convertible<Key, iterator>::value &&
+          !std::is_convertible<Key, const_iterator>::value;
+      };
+
+      template <class T>
+      using remove_cvref_t =
+        typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+      template <class T, class U>
+      using is_similar = std::is_same<remove_cvref_t<T>, remove_cvref_t<U> >;
+
+      template <class, class...> struct is_similar_to_any : std::false_type
+      {
+      };
+      template <class T, class U, class... Us>
+      struct is_similar_to_any<T, U, Us...>
+          : std::conditional<is_similar<T, U>::value, is_similar<T, U>,
+              is_similar_to_any<T, Us...> >::type
+      {
       };
 
 #if BOOST_UNORDERED_TEMPLATE_DEDUCTION_GUIDES
@@ -81,7 +185,7 @@ namespace boost {
 
       template <class InputIterator>
       constexpr bool const is_input_iterator_v =
-        !boost::is_integral<InputIterator>::value;
+        !std::is_integral<InputIterator>::value;
 
       template <class A, class = void> struct is_allocator
       {
@@ -90,7 +194,7 @@ namespace boost {
 
       template <class A>
       struct is_allocator<A,
-        boost::void_t<typename A::value_type,
+        boost::unordered::detail::void_t<typename A::value_type,
           decltype(std::declval<A&>().allocate(std::size_t{}))> >
       {
         constexpr static bool const value = true;
@@ -101,7 +205,7 @@ namespace boost {
 
       template <class H>
       constexpr bool const is_hash_v =
-        !boost::is_integral<H>::value && !is_allocator_v<H>;
+        !std::is_integral<H>::value && !is_allocator_v<H>;
 
       template <class P> constexpr bool const is_pred_v = !is_allocator_v<P>;
 
@@ -116,7 +220,7 @@ namespace boost {
         typename std::pair<iter_key_t<T> const, iter_val_t<T> >;
 #endif
     } // namespace detail
-  }   // namespace unordered
+  } // namespace unordered
 } // namespace boost
 
 #endif // BOOST_UNORDERED_DETAIL_TYPE_TRAITS_HPP

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

@@ -11,8 +11,7 @@
 #ifndef BOOST_UNORDERED_HASH_TRAITS_HPP
 #define BOOST_UNORDERED_HASH_TRAITS_HPP
 
-#include <boost/type_traits/make_void.hpp>
-#include <boost/type_traits/integral_constant.hpp>
+#include <boost/unordered/detail/type_traits.hpp>
 
 namespace boost{
 namespace unordered{
@@ -20,12 +19,12 @@ namespace unordered{
 namespace detail{
 
 template<typename Hash,typename=void>
-struct hash_is_avalanching_impl: boost::false_type{};
+struct hash_is_avalanching_impl: std::false_type{};
 
 template<typename Hash>
 struct hash_is_avalanching_impl<Hash,
-  typename boost::make_void<typename Hash::is_avalanching>::type>:
-    boost::true_type{};
+  boost::unordered::detail::void_t<typename Hash::is_avalanching> >:
+    std::true_type{};
 
 } /* namespace detail */