passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/container/set.hpp

@@ -27,6 +27,7 @@
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/tree.hpp>
 #include <boost/container/new_allocator.hpp> //new_allocator
+#include <boost/container/detail/algorithm.hpp>
 // intrusive/detail
 #include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>//less, equal
@@ -957,6 +958,15 @@ class set
    #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class C, class A, class O, class Pred>
+inline typename set<K, C, A, O>::size_type erase_if(set<K, C, A, O>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>
@@ -1612,6 +1622,15 @@ class multiset
    #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 };
 
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class K, class C, class A, class O, class Pred>
+inline typename multiset<K, C, A, O>::size_type erase_if(multiset<K, C, A, O>& c, Pred pred)
+{
+   return container_erase_if(c, pred);
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InputIterator>

data/src/cxx_supportlib/vendor-modified/boost/container/slist.hpp

@@ -94,7 +94,7 @@ struct intrusive_slist_type
       , dtl::bi::size_type
          <typename allocator_traits_type::size_type>
       >::type                                   container_type;
-   typedef container_type                       type ;
+   typedef container_type                       type;
 };
 
 }  //namespace dtl {
@@ -1629,8 +1629,8 @@ class slist
       Icont &icont_;
       typedef typename Icont::iterator       iiterator;
       typedef typename Icont::const_iterator iconst_iterator;
-      const iconst_iterator prev_;
-      iiterator   ret_;
+      iconst_iterator prev_;
+      iiterator ret_;
 
       public:
       insertion_functor(Icont &icont, typename Icont::const_iterator prev)
@@ -1639,11 +1639,16 @@ class slist
 
       void operator()(Node &n)
       {
-         ret_ = this->icont_.insert_after(prev_, n);
+         prev_ = this->icont_.insert_after(prev_, n);
+         if(!ret_)
+            ret_ = prev_.unconst();
       }
 
       iiterator inserted_first() const
-      {  return ret_;   }
+      {
+         iiterator f(ret_);
+         return ++f;
+      }
    };
 
    //Functors for member algorithm defaults
@@ -1653,6 +1658,28 @@ class slist
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };
 
+//! <b>Effects</b>: Erases all elements that compare equal to v from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class U>
+inline typename slist<T, A>::size_type erase(slist<T, A>& c, const U& v)
+{
+   typename slist<T, A>::size_type old_size = c.size();
+   c.remove_if(equal_to_value<U>(v));
+   return old_size - c.size();
+}
+
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class Pred>
+inline typename slist<T, A>::size_type erase_if(slist<T, A>& c, Pred pred)
+{
+   typename slist<T, A>::size_type old_size = c.size();
+   c.remove_if(pred);
+   return old_size - c.size();
+}
+
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
 
 template <typename InpIt>

data/src/cxx_supportlib/vendor-modified/boost/container/small_vector.hpp

@@ -127,10 +127,11 @@ class small_vector_allocator
 {
    typedef unsigned int allocation_type;
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   private:
 
+   public:
    typedef typename allocator_traits<VoidAlloc>::template portable_rebind_alloc<T>::type allocator_type;
 
+   private:
    BOOST_COPYABLE_AND_MOVABLE(small_vector_allocator)
 
    inline const allocator_type &as_base() const BOOST_NOEXCEPT
@@ -353,7 +354,8 @@ class small_vector_base
    typedef typename real_allocator<T, SecAlloc>::type                     underlying_allocator_t;
    typedef typename allocator_traits<underlying_allocator_t>::
       template portable_rebind_alloc<void>::type                          void_underlying_allocator_t;
-   typedef small_vector_allocator<T, void_underlying_allocator_t, Options>allocator_type;
+   typedef typename small_vector_allocator
+      <T, void_underlying_allocator_t, Options>::allocator_type           allocator_type;
    typedef typename dtl::get_small_vector_opt<Options>::type              options_t;
    typedef typename dtl::vector_for_small_vector
       <T, SecAlloc, Options>::type                                        base_type;
@@ -548,6 +550,7 @@ class small_vector
    BOOST_COPYABLE_AND_MOVABLE(small_vector)
 
    public:
+   typedef dtl::true_type is_partially_propagable;
    typedef small_vector_base<T, Allocator, Options>   base_type;
    typedef typename base_type::allocator_type         allocator_type;
    typedef typename base_type::size_type              size_type;
@@ -672,6 +675,28 @@ class small_vector
    {  this->base_type::prot_shrink_to_fit_small(this->internal_capacity());   }
 };
 
+//! <b>Effects</b>: Erases all elements that compare equal to v from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, std::size_t N, class A, class O, class U>
+inline typename small_vector<T, N, A, O>::size_type erase(small_vector<T, N, A, O>& c, const U& v)
+{
+   typename small_vector<T, N, A, O>::size_type old_size = c.size();
+   c.erase(boost::container::remove(c.begin(), c.end(), v), c.end());
+   return old_size - c.size();
+}
+
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, std::size_t N, class A, class O, class Pred>
+inline typename small_vector<T, N, A, O>::size_type erase_if(small_vector<T, N, A, O>& c, Pred pred)
+{
+   typename small_vector<T, N, A, O>::size_type old_size = c.size();
+   c.erase(boost::container::remove_if(c.begin(), c.end(), pred), c.end());
+   return old_size - c.size();
+}
+
 }}
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

data/src/cxx_supportlib/vendor-modified/boost/container/stable_vector.hpp

@@ -2251,6 +2251,28 @@ stable_vector(InputIterator, InputIterator, Allocator const&) ->
 
 #undef BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT
 
+//! <b>Effects</b>: Erases all elements that compare equal to v from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class U>
+inline typename stable_vector<T, A>::size_type erase(stable_vector<T, A>& c, const U& v)
+{
+   typename stable_vector<T, A>::size_type old_size = c.size();
+   c.erase(boost::container::remove(c.begin(), c.end(), v), c.end());
+   return old_size - c.size();
+}
+
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class Pred>
+inline typename stable_vector<T, A>::size_type erase_if(stable_vector<T, A>& c, Pred pred)
+{
+   typename stable_vector<T, A>::size_type old_size = c.size();
+   c.erase(boost::container::remove_if(c.begin(), c.end(), pred), c.end());
+   return old_size - c.size();
+}
+
 }  //namespace container {
 
 //!has_trivial_destructor_after_move<> == true_type

data/src/cxx_supportlib/vendor-modified/boost/container/static_vector.hpp

@@ -63,8 +63,19 @@ class static_storage_allocator
    inline static_storage_allocator & operator=(const static_storage_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return *this;  }
 
-   inline T* internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
-   {  return move_detail::launder_cast<T*>(&storage);  }
+   //GCC in C++03 regressions fails, due to a bug in strict-aliasing optimizations
+   #if defined(BOOST_GCC) && (BOOST_GCC >= 120000) && (BOOST_CXX_VERSION < 201103L)
+   #pragma GCC push_options
+   #pragma GCC optimize("no-strict-aliasing")
+   #endif
+
+   BOOST_CONTAINER_FORCEINLINE T* internal_storage() const BOOST_NOEXCEPT_OR_NOTHROW
+   //Avoiding launder due to performance regressions, see https://github.com/boostorg/container/issues/309
+   {  return const_cast<T*>(static_cast<const T*>(static_cast<const void*>(storage.data)));  }
+
+   #if defined(BOOST_GCC) && (BOOST_GCC >= 120000) && (BOOST_CXX_VERSION < 201103L)
+   #pragma GCC pop_options
+   #endif
 
    BOOST_STATIC_CONSTEXPR std::size_t internal_capacity = N;
 
@@ -819,7 +830,8 @@ public:
     //!   Nothing.
     //!
     //! @par Complexity
-    //!   Constant O(1).
+    //!   @li If \c is_trivially_destructible<T>::value is \c true Constant O(1).
+    //!   @li If \c is_trivially_destructible<T>::value is \c false Linear O(N).
     void clear()  BOOST_NOEXCEPT_OR_NOTHROW;
 
     //! @pre <tt>i < size()</tt>
@@ -1226,8 +1238,6 @@ public:
 
 //! @brief Checks if contents of two static_vectors are equal.
 //!
-//! @ingroup static_vector_non_member
-//!
 //! @param x    The first static_vector.
 //! @param y    The second static_vector.
 //!
@@ -1240,8 +1250,6 @@ bool operator== (static_vector<V, C1, O1> const& x, static_vector<V, C2, O2> con
 
 //! @brief Checks if contents of two static_vectors are not equal.
 //!
-//! @ingroup static_vector_non_member
-//!
 //! @param x    The first static_vector.
 //! @param y    The second static_vector.
 //!
@@ -1254,8 +1262,6 @@ bool operator!= (static_vector<V, C1, O1> const& x, static_vector<V, C2, O2> con
 
 //! @brief Lexicographically compares static_vectors.
 //!
-//! @ingroup static_vector_non_member
-//!
 //! @param x    The first static_vector.
 //! @param y    The second static_vector.
 //!
@@ -1268,8 +1274,6 @@ bool operator< (static_vector<V, C1, O1> const& x, static_vector<V, C2, O2> cons
 
 //! @brief Lexicographically compares static_vectors.
 //!
-//! @ingroup static_vector_non_member
-//!
 //! @param x    The first static_vector.
 //! @param y    The second static_vector.
 //!
@@ -1282,8 +1286,6 @@ bool operator> (static_vector<V, C1, O1> const& x, static_vector<V, C2, O2> cons
 
 //! @brief Lexicographically compares static_vectors.
 //!
-//! @ingroup static_vector_non_member
-//!
 //! @param x    The first static_vector.
 //! @param y    The second static_vector.
 //!
@@ -1296,8 +1298,6 @@ bool operator<= (static_vector<V, C1, O1> const& x, static_vector<V, C2, O2> con
 
 //! @brief Lexicographically compares static_vectors.
 //!
-//! @ingroup static_vector_non_member
-//!
 //! @param x    The first static_vector.
 //! @param y    The second static_vector.
 //!
@@ -1312,8 +1312,6 @@ bool operator>= (static_vector<V, C1, O1> const& x, static_vector<V, C2, O2> con
 //!
 //! This function calls static_vector::swap().
 //!
-//! @ingroup static_vector_non_member
-//!
 //! @param x    The first static_vector.
 //! @param y    The second static_vector.
 //!
@@ -1335,6 +1333,28 @@ inline void swap(static_vector<V, C1, O1> & x, static_vector<V, C2, O2> & y
 
 #endif // BOOST_CONTAINER_DOXYGEN_INVOKED
 
+//! <b>Effects</b>: Erases all elements that compare equal to v from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, std::size_t N, class O, class U>
+inline typename static_vector<T, N, O>::size_type erase(static_vector<T, N, O>& c, const U& v)
+{
+   typename static_vector<T, N, O>::size_type old_size = c.size();
+   c.erase(boost::container::remove(c.begin(), c.end(), v), c.end());
+   return old_size - c.size();
+}
+
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, std::size_t N, class O, class Pred>
+inline typename static_vector<T, N, O>::size_type erase_if(static_vector<T, N, O>& c, Pred pred)
+{
+   typename static_vector<T, N, O>::size_type old_size = c.size();
+   c.erase(boost::container::remove_if(c.begin(), c.end(), pred), c.end());
+   return old_size - c.size();
+}
+
 }} // namespace boost::container
 
 #include <boost/container/detail/config_end.hpp>

data/src/cxx_supportlib/vendor-modified/boost/container/string.hpp

@@ -274,7 +274,7 @@ class basic_string_base
       //active representation is short or long
       short_header hdr;
       BOOST_CONTAINER_STATIC_ASSERT((sizeof(short_header) == 1));
-      *(unsigned char*)&hdr = *(unsigned char*)&this->members_.m_repr;
+      *(unsigned char*)&hdr = *static_cast<const unsigned char*>(static_cast<const void *>(&this->members_.m_repr));
       return hdr.is_short != 0;
    }
 
@@ -3550,6 +3550,28 @@ getline(std::basic_istream<CharT, Traits>& is, basic_string<CharT,Traits,Allocat
    return getline(is, s, '\n');
 }
 
+//! <b>Effects</b>: Erases all elements that compare equal to v from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class Tr, class A, class U>
+inline typename basic_string<T, Tr, A>::size_type erase(basic_string<T, Tr, A>& c, const U& v)
+{
+   typename basic_string<T, Tr, A>::size_type old_size = c.size();
+   c.erase(boost::container::remove(c.begin(), c.end(), v), c.end());
+   return old_size - c.size();
+}
+
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class Tr, class A, class Pred>
+inline typename basic_string<T, Tr, A>::size_type erase_if(basic_string<T, Tr, A>& c, Pred pred)
+{
+   typename basic_string<T, Tr, A>::size_type old_size = c.size();
+   c.erase(boost::container::remove_if(c.begin(), c.end(), pred), c.end());
+   return old_size - c.size();
+}
+
 }}
 
 //GCC 12 has a regression for array-bounds warnings

data/src/cxx_supportlib/vendor-modified/boost/container/vector.hpp

@@ -454,16 +454,16 @@ struct vector_alloc_holder
       }
    }
 
-   inline void set_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void set_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_size = static_cast<stored_size_type>(s);   }
 
-   inline void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_size = static_cast<stored_size_type>(this->m_size - s);   }
 
-   inline void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_size = static_cast<stored_size_type>(this->m_size + s);   }
 
-   inline void set_stored_capacity(size_type c) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void set_stored_capacity(size_type c) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_capacity = static_cast<stored_size_type>(c);  }
 
    inline pointer allocation_command(boost::container::allocation_type command,
@@ -546,13 +546,13 @@ struct vector_alloc_holder
    inline const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return *this;  }
 
-   inline pointer   start() const     BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE pointer   start() const     BOOST_NOEXCEPT_OR_NOTHROW
       {  return m_start;  }
-   inline       size_type capacity() const     BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type capacity() const     BOOST_NOEXCEPT_OR_NOTHROW
       {  return m_capacity;  }
-   inline void start(const pointer &p)       BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void start(const pointer &p)       BOOST_NOEXCEPT_OR_NOTHROW
       {  m_start = p;  }
-   inline void capacity(const size_type &c)  BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE void capacity(const size_type &c)  BOOST_NOEXCEPT_OR_NOTHROW
       {  BOOST_ASSERT( c <= stored_size_type(-1)); this->set_stored_capacity(c);  }
 
    static inline void on_capacity_overflow()
@@ -729,13 +729,13 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
    inline const allocator_type &alloc() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return *this;  }
 
-   inline bool try_expand_fwd(size_type at_least)
+   BOOST_CONTAINER_FORCEINLINE bool try_expand_fwd(size_type at_least)
    {  return !at_least;  }
 
-   inline pointer start() const       BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE pointer start() const       BOOST_NOEXCEPT_OR_NOTHROW
    {  return allocator_type::internal_storage();  }
    
-   inline size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE size_type capacity() const BOOST_NOEXCEPT_OR_NOTHROW
    {  return allocator_type::internal_capacity;  }
    
    stored_size_type m_size;
@@ -2100,8 +2100,8 @@ private:
          >::type * = 0
       )
    {
-      typedef typename iter_size<FwdIt>::type it_size_type;
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
+      typedef typename iter_size<FwdIt>::type it_size_type;
       const it_size_type sz = boost::container::iterator_udistance(first, last);
       if (BOOST_UNLIKELY(sz > size_type(-1))){
          boost::container::throw_length_error("vector::insert, FwdIt's max length reached");
@@ -2573,7 +2573,7 @@ private:
       new_values_destroyer.release();
    }
 
-   inline bool room_enough() const
+   BOOST_CONTAINER_FORCEINLINE bool room_enough() const
    {  return this->m_holder.m_size != this->m_holder.capacity();   }
 
    inline pointer back_ptr() const
@@ -2897,13 +2897,13 @@ private:
    }
 
    template<class U>
-   inline iterator priv_insert(const const_iterator &p, BOOST_FWD_REF(U) u)
+   BOOST_CONTAINER_FORCEINLINE iterator priv_insert(const const_iterator &p, BOOST_FWD_REF(U) u)
    {
       return this->emplace(p, ::boost::forward<U>(u));
    }
 
    template <class U>
-   inline void priv_push_back(BOOST_FWD_REF(U) u)
+   BOOST_CONTAINER_FORCEINLINE void priv_push_back(BOOST_FWD_REF(U) u)
    {
       this->emplace_back(::boost::forward<U>(u));
    }
@@ -3014,6 +3014,7 @@ private:
    {
       return alloc_holder_t::on_capacity_overflow(), iterator();
    }
+
    #ifdef _MSC_VER
    #pragma warning (pop)
    #endif
@@ -3022,15 +3023,14 @@ private:
    BOOST_CONTAINER_NOINLINE iterator priv_insert_forward_range_no_capacity
       (T *const raw_pos, const size_type n, const InsertionProxy insert_range_proxy, version_1)
    {
-      //Check if we have enough memory or try to expand current memory
-      const size_type n_pos = static_cast<size_type>(raw_pos - this->priv_raw_begin());
-
       const size_type new_cap = this->m_holder.template next_capacity<growth_factor_type>(n);
       //Pass the hint so that allocators can take advantage of this.
       T * const new_buf = boost::movelib::to_raw_pointer(this->m_holder.allocate(new_cap));
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       ++this->num_alloc;
       #endif
+      //Check if we have enough memory or try to expand current memory
+      const size_type n_pos = static_cast<size_type>(raw_pos - this->priv_raw_begin());
       this->priv_insert_forward_range_new_allocation(new_buf, new_cap, raw_pos, n, insert_range_proxy);
       return iterator(this->m_holder.start() + difference_type(n_pos));
    }
@@ -3221,10 +3221,10 @@ private:
    }
 
    private:
-   inline T *priv_raw_begin() const
+   BOOST_CONTAINER_FORCEINLINE T *priv_raw_begin() const
    {  return boost::movelib::to_raw_pointer(m_holder.start());  }
 
-   inline T* priv_raw_end() const
+   BOOST_CONTAINER_FORCEINLINE T* priv_raw_end() const
    {  return this->priv_raw_begin() + this->m_holder.m_size;  }
 
    template <class InsertionProxy>  //inline single-element version as it is significantly smaller
@@ -3351,6 +3351,27 @@ vector(InputIterator, InputIterator, Allocator const&) ->
 
 #endif
 
+//! <b>Effects</b>: Erases all elements that compare equal to v from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class O, class U>
+inline typename vector<T, A, O>::size_type erase(vector<T, A, O>& c, const U& v)
+{
+  typename vector<T, A, O>::size_type old_size = c.size();
+  c.erase(boost::container::remove(c.begin(), c.end(), v), c.end());
+  return old_size - c.size();
+}
+
+//! <b>Effects</b>: Erases all elements that satisfy the predicate pred from the container c.
+//!
+//! <b>Complexity</b>: Linear.
+template <class T, class A, class O, class Pred>
+inline typename vector<T, A, O>::size_type erase_if(vector<T, A, O>& c, Pred pred)
+{
+   typename vector<T, A, O>::size_type old_size = c.size();
+   c.erase(boost::container::remove_if(c.begin(), c.end(), pred), c.end());
+   return old_size - c.size();
+}
 
 }} //namespace boost::container
 

data/src/cxx_supportlib/vendor-modified/boost/container_hash/hash.hpp

@@ -1,5 +1,5 @@
 // Copyright 2005-2014 Daniel James.
-// Copyright 2021, 2022 Peter Dimov.
+// Copyright 2021, 2022, 2025 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -11,6 +11,7 @@
 #define BOOST_FUNCTIONAL_HASH_HASH_HPP
 
 #include <boost/container_hash/hash_fwd.hpp>
+#include <boost/container_hash/hash_is_avalanching.hpp>
 #include <boost/container_hash/is_range.hpp>
 #include <boost/container_hash/is_contiguous_range.hpp>
 #include <boost/container_hash/is_unordered_range.hpp>
@@ -557,19 +558,15 @@ namespace boost
 
 #endif
 
-    // boost::unordered::hash_is_avalanching
+    // hash_is_avalanching
 
-    namespace unordered
-    {
-        template<class T> struct hash_is_avalanching;
-        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: std::is_integral<Ch> {};
+    template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string<Ch> > >: std::is_integral<Ch> {};
 
 #if !defined(BOOST_NO_CXX17_HDR_STRING_VIEW)
 
-        template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: std::is_integral<Ch> {};
+    template<class Ch> struct hash_is_avalanching< boost::hash< std::basic_string_view<Ch> > >: std::is_integral<Ch> {};
 
 #endif
-    } // namespace unordered
 
 } // namespace boost
 

data/src/cxx_supportlib/vendor-modified/boost/container_hash/hash_fwd.hpp

@@ -1,5 +1,5 @@
 // Copyright 2005-2009 Daniel James.
-// Copyright 2021, 2022 Peter Dimov.
+// Copyright 2021, 2022, 2025 Peter Dimov.
 // Distributed under the Boost Software License, Version 1.0.
 // https://www.boost.org/LICENSE_1_0.txt
 
@@ -32,6 +32,8 @@ template<class It> std::size_t hash_range( It, It );
 template<class It> void hash_unordered_range( std::size_t&, It, It );
 template<class It> std::size_t hash_unordered_range( It, It );
 
+template<class Hash> struct hash_is_avalanching;
+
 } // namespace boost
 
 #endif // #ifndef BOOST_FUNCTIONAL_HASH_FWD_HPP

data/src/cxx_supportlib/vendor-modified/boost/container_hash/hash_is_avalanching.hpp

@@ -0,0 +1,57 @@
+// Copyright 2025 Joaquin M Lopez Munoz.
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_HASH_HASH_IS_AVALANCHING_HPP_INCLUDED
+#define BOOST_HASH_HASH_IS_AVALANCHING_HPP_INCLUDED
+
+#include <type_traits>
+
+namespace boost
+{
+namespace hash_detail
+{
+
+template<class... Ts> struct make_void
+{
+    using type = void;
+};
+
+template<class... Ts> using void_t = typename make_void<Ts...>::type;
+
+template<class IsAvalanching> struct avalanching_value
+{
+    static constexpr bool value = IsAvalanching::value;
+};
+
+// may be explicitly marked as BOOST_DEPRECATED in the future
+template<> struct avalanching_value<void>
+{
+    static constexpr bool value = true;
+};
+
+template<class Hash, class = void> struct hash_is_avalanching_impl: std::false_type
+{
+};
+
+template<class Hash> struct hash_is_avalanching_impl<Hash, void_t<typename Hash::is_avalanching> >:
+    std::integral_constant<bool, avalanching_value<typename Hash::is_avalanching>::value>
+{
+};
+
+template<class Hash>
+struct hash_is_avalanching_impl<Hash, typename std::enable_if< ((void)Hash::is_avalanching, true) >::type>
+{
+  // Hash::is_avalanching is not a type: we don't define value to produce
+  // a compile error downstream
+};
+
+} // namespace hash_detail
+
+template<class Hash> struct hash_is_avalanching: hash_detail::hash_is_avalanching_impl<Hash>::type
+{
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_HASH_HASH_IS_AVALANCHING_HPP_INCLUDED