passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/intrusive_ptr.hpp

@@ -13,6 +13,7 @@
 //  See http://www.boost.org/libs/smart_ptr/ for documentation.
 //
 
+#include <boost/smart_ptr/detail/sp_cxx20_constexpr.hpp>
 #include <boost/smart_ptr/detail/sp_convertible.hpp>
 #include <boost/smart_ptr/detail/sp_noexcept.hpp>
 #include <boost/assert.hpp>
@@ -53,29 +54,29 @@ public:
     {
     }
 
-    intrusive_ptr( T * p, bool add_ref = true ): px( p )
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr( T * p, bool add_ref = true ): px( p )
     {
         if( px != 0 && add_ref ) intrusive_ptr_add_ref( px );
     }
 
     template<class U>
-    intrusive_ptr( intrusive_ptr<U> const & rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty() )
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr( intrusive_ptr<U> const & rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty() )
     : px( rhs.get() )
     {
         if( px != 0 ) intrusive_ptr_add_ref( px );
     }
 
-    intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px )
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px )
     {
         if( px != 0 ) intrusive_ptr_add_ref( px );
     }
 
-    ~intrusive_ptr()
+    BOOST_SP_CXX20_CONSTEXPR ~intrusive_ptr()
     {
         if( px != 0 ) intrusive_ptr_release( px );
     }
 
-    template<class U> intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
+    template<class U> BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(intrusive_ptr<U> const & rhs)
     {
         this_type(rhs).swap(*this);
         return *this;
@@ -83,12 +84,12 @@ public:
 
 // Move support
 
-    intrusive_ptr(intrusive_ptr && rhs) noexcept : px( rhs.px )
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr(intrusive_ptr && rhs) noexcept : px( rhs.px )
     {
         rhs.px = 0;
     }
 
-    intrusive_ptr & operator=(intrusive_ptr && rhs) noexcept
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(intrusive_ptr && rhs) noexcept
     {
         this_type( static_cast< intrusive_ptr && >( rhs ) ).swap(*this);
         return *this;
@@ -97,76 +98,76 @@ public:
     template<class U> friend class intrusive_ptr;
 
     template<class U>
-    intrusive_ptr(intrusive_ptr<U> && rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty())
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr(intrusive_ptr<U> && rhs, typename boost::detail::sp_enable_if_convertible<U,T>::type = boost::detail::sp_empty())
     : px( rhs.px )
     {
         rhs.px = 0;
     }
 
     template<class U>
-    intrusive_ptr & operator=(intrusive_ptr<U> && rhs) noexcept
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(intrusive_ptr<U> && rhs) noexcept
     {
         this_type( static_cast< intrusive_ptr<U> && >( rhs ) ).swap(*this);
         return *this;
     }
 
-    intrusive_ptr & operator=(intrusive_ptr const & rhs)
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(intrusive_ptr const & rhs)
     {
         this_type(rhs).swap(*this);
         return *this;
     }
 
-    intrusive_ptr & operator=(T * rhs)
+    BOOST_SP_CXX20_CONSTEXPR intrusive_ptr & operator=(T * rhs)
     {
         this_type(rhs).swap(*this);
         return *this;
     }
 
-    void reset()
+    BOOST_SP_CXX20_CONSTEXPR void reset()
     {
         this_type().swap( *this );
     }
 
-    void reset( T * rhs )
+    BOOST_SP_CXX20_CONSTEXPR void reset( T * rhs )
     {
         this_type( rhs ).swap( *this );
     }
 
-    void reset( T * rhs, bool add_ref )
+    BOOST_SP_CXX20_CONSTEXPR void reset( T * rhs, bool add_ref )
     {
         this_type( rhs, add_ref ).swap( *this );
     }
 
-    T * get() const noexcept
+    BOOST_SP_CXX20_CONSTEXPR T * get() const noexcept
     {
         return px;
     }
 
-    T * detach() noexcept
+    BOOST_SP_CXX20_CONSTEXPR T * detach() noexcept
     {
         T * ret = px;
         px = 0;
         return ret;
     }
 
-    T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
+    BOOST_SP_CXX20_CONSTEXPR T & operator*() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return *px;
     }
 
-    T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
+    BOOST_SP_CXX20_CONSTEXPR T * operator->() const BOOST_SP_NOEXCEPT_WITH_ASSERT
     {
         BOOST_ASSERT( px != 0 );
         return px;
     }
 
-    explicit operator bool () const noexcept
+    BOOST_SP_CXX20_CONSTEXPR explicit operator bool () const noexcept
     {
         return px != 0;
     }
 
-    void swap(intrusive_ptr & rhs) noexcept
+    BOOST_SP_CXX20_CONSTEXPR void swap(intrusive_ptr & rhs) noexcept
     {
         T * tmp = px;
         px = rhs.px;
@@ -178,101 +179,101 @@ private:
     T * px;
 };
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator==(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
 {
     return a.get() == b.get();
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=(intrusive_ptr<T> const & a, intrusive_ptr<U> const & b) noexcept
 {
     return a.get() != b.get();
 }
 
-template<class T, class U> inline bool operator==(intrusive_ptr<T> const & a, U * b) noexcept
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator==(intrusive_ptr<T> const & a, U * b) noexcept
 {
     return a.get() == b;
 }
 
-template<class T, class U> inline bool operator!=(intrusive_ptr<T> const & a, U * b) noexcept
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=(intrusive_ptr<T> const & a, U * b) noexcept
 {
     return a.get() != b;
 }
 
-template<class T, class U> inline bool operator==(T * a, intrusive_ptr<U> const & b) noexcept
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator==(T * a, intrusive_ptr<U> const & b) noexcept
 {
     return a == b.get();
 }
 
-template<class T, class U> inline bool operator!=(T * a, intrusive_ptr<U> const & b) noexcept
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=(T * a, intrusive_ptr<U> const & b) noexcept
 {
     return a != b.get();
 }
 
-template<class T> inline bool operator==( intrusive_ptr<T> const & p, std::nullptr_t ) noexcept
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator==( intrusive_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator==( std::nullptr_t, intrusive_ptr<T> const & p ) noexcept
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator==( std::nullptr_t, intrusive_ptr<T> const & p ) noexcept
 {
     return p.get() == 0;
 }
 
-template<class T> inline bool operator!=( intrusive_ptr<T> const & p, std::nullptr_t ) noexcept
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=( intrusive_ptr<T> const & p, std::nullptr_t ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator!=( std::nullptr_t, intrusive_ptr<T> const & p ) noexcept
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator!=( std::nullptr_t, intrusive_ptr<T> const & p ) noexcept
 {
     return p.get() != 0;
 }
 
-template<class T> inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) noexcept
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline bool operator<(intrusive_ptr<T> const & a, intrusive_ptr<T> const & b) noexcept
 {
     return std::less<T *>()(a.get(), b.get());
 }
 
-template<class T> void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) noexcept
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline void swap(intrusive_ptr<T> & lhs, intrusive_ptr<T> & rhs) noexcept
 {
     lhs.swap(rhs);
 }
 
 // mem_fn support
 
-template<class T> T * get_pointer(intrusive_ptr<T> const & p) noexcept
+template<class T> BOOST_SP_CXX20_CONSTEXPR inline T * get_pointer(intrusive_ptr<T> const & p) noexcept
 {
     return p.get();
 }
 
 // pointer casts
 
-template<class T, class U> intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> static_pointer_cast(intrusive_ptr<U> const & p)
 {
     return static_cast<T *>(p.get());
 }
 
-template<class T, class U> intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> const_pointer_cast(intrusive_ptr<U> const & p)
 {
     return const_cast<T *>(p.get());
 }
 
-template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> dynamic_pointer_cast(intrusive_ptr<U> const & p)
 {
     return dynamic_cast<T *>(p.get());
 }
 
-template<class T, class U> intrusive_ptr<T> static_pointer_cast( intrusive_ptr<U> && p ) noexcept
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> static_pointer_cast( intrusive_ptr<U> && p ) noexcept
 {
     return intrusive_ptr<T>( static_cast<T*>( p.detach() ), false );
 }
 
-template<class T, class U> intrusive_ptr<T> const_pointer_cast( intrusive_ptr<U> && p ) noexcept
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> const_pointer_cast( intrusive_ptr<U> && p ) noexcept
 {
     return intrusive_ptr<T>( const_cast<T*>( p.detach() ), false );
 }
 
-template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast( intrusive_ptr<U> && p ) noexcept
+template<class T, class U> BOOST_SP_CXX20_CONSTEXPR inline intrusive_ptr<T> dynamic_pointer_cast( intrusive_ptr<U> && p ) noexcept
 {
     T * p2 = dynamic_cast<T*>( p.get() );
 
@@ -285,7 +286,7 @@ template<class T, class U> intrusive_ptr<T> dynamic_pointer_cast( intrusive_ptr<
 
 // operator<<
 
-template<class Y> std::ostream & operator<< (std::ostream & os, intrusive_ptr<Y> const & p)
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, intrusive_ptr<Y> const & p)
 {
     os << p.get();
     return os;

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/scoped_array.hpp

@@ -22,15 +22,6 @@
 namespace boost
 {
 
-// Debug hooks
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_array_constructor_hook(void * p);
-void sp_array_destructor_hook(void * p);
-
-#endif
-
 //  scoped_array extends scoped_ptr to arrays. Deletion of the array pointed to
 //  is guaranteed, either on destruction of the scoped_array or via an explicit
 //  reset(). Use shared_array or std::vector if your needs are more complex.
@@ -55,16 +46,10 @@ public:
 
     explicit scoped_array( T * p = 0 ) noexcept : px( p )
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_array_constructor_hook( px );
-#endif
     }
 
     ~scoped_array() noexcept
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_array_destructor_hook( px );
-#endif
         boost::checked_array_delete( px );
     }
 

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/scoped_ptr.hpp

@@ -31,15 +31,6 @@
 namespace boost
 {
 
-// Debug hooks
-
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-
-void sp_scalar_constructor_hook(void * p);
-void sp_scalar_destructor_hook(void * p);
-
-#endif
-
 //  scoped_ptr mimics a built-in pointer except that it guarantees deletion
 //  of the object pointed to, either on destruction of the scoped_ptr or via
 //  an explicit reset(). scoped_ptr is a simple solution for simple needs;
@@ -65,27 +56,18 @@ public:
 
     explicit scoped_ptr( T * p = 0 ) noexcept : px( p )
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_constructor_hook( px );
-#endif
     }
 
 #ifndef BOOST_NO_AUTO_PTR
 
     explicit scoped_ptr( std::auto_ptr<T> p ) noexcept : px( p.release() )
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_constructor_hook( px );
-#endif
     }
 
 #endif
 
     ~scoped_ptr() noexcept
     {
-#if defined(BOOST_SP_ENABLE_DEBUG_HOOKS)
-        boost::sp_scalar_destructor_hook( px );
-#endif
         boost::checked_delete( px );
     }
 

data/src/cxx_supportlib/vendor-modified/boost/smart_ptr/shared_ptr.hpp

@@ -775,7 +775,7 @@ template<class T> inline typename shared_ptr<T>::element_type * get_pointer(shar
 
 // operator<<
 
-template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
+template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
 {
     os << p.get();
     return os;

data/src/cxx_supportlib/vendor-modified/boost/thread/future.hpp

@@ -4668,7 +4668,7 @@ namespace detail
       }
       run_it& operator=(BOOST_THREAD_RV_REF(run_it) x) BOOST_NOEXCEPT {
         if (this != &x) {
-          that_=x.that;
+          that_=x.that_;
           x.that_.reset();
         }
         return *this;

data/src/cxx_supportlib/vendor-modified/boost/tuple/detail/tuple_basic.hpp

@@ -37,6 +37,7 @@
 #include <cstddef> // for std::size_t
 
 #include <boost/core/invoke_swap.hpp>
+#include <boost/core/ref.hpp>
 #include <boost/type_traits/cv_traits.hpp>
 #include <boost/type_traits/function_traits.hpp>
 #include <boost/type_traits/integral_constant.hpp>

data/src/cxx_supportlib/vendor-modified/boost/type_traits/integral_constant.hpp

@@ -60,10 +60,11 @@ namespace boost{
       operator const mpl::integral_c<T, val>& ()const
       {
          static const char data[sizeof(long)] = { 0 };
-         static const void* pdata = data;
-         return *(reinterpret_cast<const mpl::integral_c<T, val>*>(pdata));
+         const void* const pdata = data;
+         return *static_cast<const mpl::integral_c<T, val>*>(pdata);
       }
-      BOOST_CONSTEXPR operator T()const { return val; }
+      BOOST_CONSTEXPR operator T()const BOOST_NOEXCEPT { return val; }
+      BOOST_CONSTEXPR T operator()()const BOOST_NOEXCEPT { return val; }
    };
 
    template <class T, T val>
@@ -80,10 +81,11 @@ namespace boost{
       operator const mpl::bool_<val>& ()const
       {
          static const char data[sizeof(long)] = { 0 };
-         static const void* pdata = data;
-         return *(reinterpret_cast<const mpl::bool_<val>*>(pdata));
+         const void* const pdata = data;
+         return *static_cast<const mpl::bool_<val>*>(pdata);
       }
-      BOOST_CONSTEXPR operator bool()const { return val; }
+      BOOST_CONSTEXPR operator bool()const BOOST_NOEXCEPT { return val; }
+      BOOST_CONSTEXPR bool operator()()const BOOST_NOEXCEPT { return val; }
    };
 
    template <bool val>

data/src/cxx_supportlib/vendor-modified/boost/type_traits/is_complete.hpp

@@ -27,11 +27,10 @@
  * DO NOT MAKE GENERAL USE OF THIS TRAIT, AS THE COMPLETENESS OF A TYPE
  * VARIES ACROSS TRANSLATION UNITS AS WELL AS WITHIN A SINGLE UNIT.
  *
-*/
+ */
 
 namespace boost {
 
-
 //
 // We will undef this if the trait isn't fully functional:
 //
@@ -39,7 +38,7 @@ namespace boost {
 
 #if !defined(BOOST_NO_SFINAE_EXPR) && !BOOST_WORKAROUND(BOOST_MSVC, <= 1900) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40600)
 
-   namespace detail{
+   namespace detail {
 
       template <std::size_t N>
       struct ok_tag { double d; char c[N]; };
@@ -48,15 +47,15 @@ namespace boost {
       ok_tag<sizeof(T)> check_is_complete(int);
       template <class T>
       char check_is_complete(...);
-   }
+
+   } // namespace detail
 
    template <class T> struct is_complete
       : public integral_constant<bool, ::boost::is_function<typename boost::remove_reference<T>::type>::value || (sizeof(boost::detail::check_is_complete<T>(0)) != sizeof(char))> {};
 
 #elif !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_CXX11_FUNCTION_TEMPLATE_DEFAULT_ARGS) && !BOOST_WORKAROUND(BOOST_GCC_VERSION, < 40500)
 
-   namespace detail
-   {
+   namespace detail {
 
       template <class T>
       struct is_complete_imp
@@ -70,7 +69,7 @@ namespace boost {
          static const bool value = sizeof(check<T>(0)) == sizeof(type_traits::yes_type);
       };
 
-} // namespace detail
+   } // namespace detail
 
 
    template <class T>
@@ -78,11 +77,33 @@ namespace boost {
    {};
    template <class T>
    struct is_complete<T&> : boost::is_complete<T> {};
-   
+
 #else
 
-      template <class T> struct is_complete
-         : public boost::integral_constant<bool, true> {};
+   namespace detail {
+
+      template <class T>
+      struct is_complete_impl : public boost::true_type {};
+
+      template < >
+      struct is_complete_impl<void> : public boost::false_type {};
+
+      template <class T>
+      struct is_complete_impl<T[]> : public boost::false_type {};
+
+      template <class T>
+      struct is_complete_impl<T&> : public is_complete_impl<T>::type {};
+
+   } // namespace detail
+
+   template <class T>
+   struct is_complete : public detail::is_complete_impl<T>::type {};
+   template <class T>
+   struct is_complete<const T> : public detail::is_complete_impl<T>::type {};
+   template <class T>
+   struct is_complete<volatile T> : public detail::is_complete_impl<T>::type {};
+   template <class T>
+   struct is_complete<const volatile T> : public detail::is_complete_impl<T>::type {};
 
 #undef BOOST_TT_HAS_WORKING_IS_COMPLETE
 

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

@@ -1,4 +1,4 @@
-// Copyright (C) 2022-2024 Joaquin M Lopez Munoz.
+// Copyright (C) 2022-2025 Joaquin M Lopez Munoz.
 // Copyright (C) 2022 Christian Mazakas
 //
 // Distributed under the Boost Software License, Version 1.0. (See accompanying
@@ -134,11 +134,37 @@ namespace boost {
   namespace unordered {
     namespace detail {
 
-      template <class ValueType, class VoidPtr> struct node
+      template <class ValueType, class VoidPtr> struct node;
+
+      // access to node::value_type and node::pointer for incomplete node
+
+      template<class Node> struct node_value_type_impl;
+
+      template <class ValueType, class VoidPtr>
+      struct node_value_type_impl<node<ValueType, VoidPtr>>
+      {
+        typedef ValueType type;
+      };
+
+      template<class Node> using node_value_type = 
+        typename node_value_type_impl<Node>::type;
+
+      template<class Node> struct node_pointer_impl;
+
+      template <class ValueType, class VoidPtr>
+      struct node_pointer_impl<node<ValueType, VoidPtr>>
       {
-        typedef ValueType value_type;
         typedef typename boost::pointer_traits<VoidPtr>::template rebind_to<
-          node>::type node_pointer;
+          node<ValueType, VoidPtr>>::type type;
+      };
+
+      template<class Node> using node_pointer = 
+        typename node_pointer_impl<Node>::type;
+
+      template <class ValueType, class VoidPtr> struct node
+      {
+        typedef node_value_type<node> value_type;
+        typedef detail::node_pointer<node> node_pointer;
 
         node_pointer next;
         opt_storage<value_type> buf;
@@ -304,10 +330,10 @@ namespace boost {
 
       template <class Node> struct grouped_local_bucket_iterator
       {
-        typedef typename Node::node_pointer node_pointer;
+        typedef detail::node_pointer<Node> node_pointer;
 
       public:
-        typedef typename Node::value_type value_type;
+        typedef detail::node_value_type<Node> value_type;
         typedef value_type element_type;
         typedef value_type* pointer;
         typedef value_type& reference;
@@ -370,10 +396,10 @@ namespace boost {
 
       template <class Node> struct const_grouped_local_bucket_iterator
       {
-        typedef typename Node::node_pointer node_pointer;
+        typedef detail::node_pointer<Node> node_pointer;
 
       public:
-        typedef typename Node::value_type const value_type;
+        typedef detail::node_value_type<Node> const value_type;
         typedef value_type const element_type;
         typedef value_type const* pointer;
         typedef value_type const& reference;

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

@@ -1,6 +1,6 @@
 /* Common base for Boost.Unordered open-addressing tables.
  *
- * Copyright 2022-2024 Joaquin M Lopez Munoz.
+ * Copyright 2022-2025 Joaquin M Lopez Munoz.
  * Copyright 2023 Christian Mazakas.
  * Copyright 2024 Braden Ganetsky.
  * Distributed under the Boost Software License, Version 1.0.
@@ -16,6 +16,7 @@
 #include <boost/assert.hpp>
 #include <boost/config.hpp>
 #include <boost/config/workaround.hpp>
+#include <boost/container_hash/hash_is_avalanching.hpp>
 #include <boost/core/allocator_traits.hpp>
 #include <boost/core/bit.hpp>
 #include <boost/core/empty_value.hpp>
@@ -28,8 +29,7 @@
 #include <boost/unordered/detail/mulx.hpp>
 #include <boost/unordered/detail/static_assert.hpp>
 #include <boost/unordered/detail/type_traits.hpp>
-#include <boost/unordered/hash_traits.hpp>
-#include <boost/unordered/unordered_printers.hpp>
+#include <boost/unordered/detail/unordered_printers.hpp>
 #include <climits>
 #include <cmath>
 #include <cstddef>
@@ -923,6 +923,8 @@ inline unsigned int unchecked_countr_zero(int x)
   unsigned long r;
   _BitScanForward(&r,(unsigned long)x);
   return (unsigned int)r;
+#elif defined(BOOST_GCC)||defined(BOOST_CLANG)
+  return (unsigned int)__builtin_ctz((unsigned int)x);
 #else
   BOOST_UNORDERED_ASSUME(x!=0);
   return (unsigned int)boost::core::countr_zero((unsigned int)x);
@@ -1426,7 +1428,7 @@ public:
   using size_policy=pow2_size_policy;
   using prober=pow2_quadratic_prober;
   using mix_policy=typename std::conditional<
-    hash_is_avalanching<Hash>::value,
+    boost::hash_is_avalanching<Hash>::value,
     no_mix,
     mulx_mix
   >::type;

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

@@ -1,6 +1,6 @@
 /* Fast open-addressing hash table.
  *
- * Copyright 2022-2024 Joaquin M Lopez Munoz.
+ * Copyright 2022-2025 Joaquin M Lopez Munoz.
  * Copyright 2023 Christian Mazakas.
  * Copyright 2024 Braden Ganetsky.
  * Distributed under the Boost Software License, Version 1.0.
@@ -495,6 +495,14 @@ public:
     else return 0;
   }
 
+  BOOST_FORCEINLINE init_type pull(const_iterator pos)
+  {
+    BOOST_ASSERT(pos!=end());
+    erase_on_exit e{*this,pos};
+    (void)e;
+    return type_policy::move(type_policy::value_from(*pos.p()));
+  }
+
   void swap(table& x)
     noexcept(noexcept(std::declval<super&>().swap(std::declval<super&>())))
   {