passenger 6.1.0 → 6.1.1

data/src/cxx_supportlib/vendor-modified/boost/container/detail/advanced_insert_int.hpp

@@ -272,7 +272,7 @@ struct insert_nonmovable_emplace_proxy
    {}
 
    template<class Iterator>
-   inline void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
@@ -303,7 +303,7 @@ struct insert_emplace_proxy
    {}
 
    template<class Iterator>
-   inline void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
@@ -327,6 +327,7 @@ struct insert_emplace_proxy
    }
 };
 
+
 //Specializations to avoid an unneeded temporary when emplacing from a single argument o type value_type
 template<class Allocator>
 struct insert_emplace_proxy<Allocator, typename boost::container::allocator_traits<Allocator>::value_type>

data/src/cxx_supportlib/vendor-modified/boost/container/detail/algorithm.hpp

@@ -22,6 +22,7 @@
 #endif
 
 #include <boost/intrusive/detail/algorithm.hpp>
+#include <boost/move/utility_core.hpp>
 
 namespace boost {
 namespace container {
@@ -179,6 +180,61 @@ ForwardIt1 search(ForwardIt1 first1, ForwardIt1 last1,
    }
 }
 
+template<class InpIt, class U>
+InpIt find(InpIt first, InpIt last, const U& value)
+{
+    for (; first != last; ++first)
+        if (*first == value)
+            return first;
+ 
+    return last;
+}
+
+
+template<class FwdIt, class U>
+FwdIt remove(FwdIt first, FwdIt last, const U& value)
+{
+    first = find(first, last, value);
+    if (first != last)
+        for (FwdIt i = first; ++i != last;)
+            if (!(*i == value))
+                *first++ = boost::move(*i);
+    return first;
+}
+
+template<class FwdIt, class Pred>
+FwdIt remove_if(FwdIt first, FwdIt last, Pred p)
+{
+    first = find_if(first, last, p);
+    if (first != last)
+        for (FwdIt i = first; ++i != last;)
+            if (!p(*i))
+                *first++ = boost::move(*i);
+    return first;
+}
+
+template <class Cont, class Pred>
+typename Cont::size_type container_erase_if(Cont& c, Pred p)
+{
+   typedef typename Cont::size_type size_type;
+   typedef typename Cont::iterator  it_t;
+
+   size_type prev_size = c.size();
+   it_t it         = c.begin();
+
+   //end() must be called each loop for non-node containers
+   while ( it != c.end() ) {
+      if (p(*it)) {
+         it = c.erase(it);
+      }
+      else {
+         ++it;
+      }
+   }
+
+   return prev_size - c.size();
+}
+
 }  //namespace container {
 }  //namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/container/detail/alloc_helpers.hpp

@@ -21,6 +21,7 @@
 // move
 #include <boost/move/adl_move_swap.hpp>
 #include <boost/move/utility_core.hpp>
+#include <boost/container/detail/mpl.hpp>
 
 namespace boost {
 namespace container {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/alloc_lib.h

@@ -254,17 +254,17 @@ int boost_cont_multialloc_arrays
 
 void boost_cont_multidealloc(boost_cont_memchain *pchain);
 
-size_t boost_cont_footprint();
+size_t boost_cont_footprint(void);
 
-size_t boost_cont_allocated_memory();
+size_t boost_cont_allocated_memory(void);
 
 size_t boost_cont_chunksize(const void *p);
 
-int boost_cont_all_deallocated();
+int boost_cont_all_deallocated(void);
 
-boost_cont_malloc_stats_t boost_cont_malloc_stats();
+boost_cont_malloc_stats_t boost_cont_malloc_stats(void);
 
-size_t boost_cont_in_use_memory();
+size_t boost_cont_in_use_memory(void);
 
 int boost_cont_trim(size_t pad);
 
@@ -279,7 +279,7 @@ int boost_cont_shrink
 void* boost_cont_alloc
    (size_t minbytes, size_t preferred_bytes, size_t *received_bytes);
 
-int boost_cont_malloc_check();
+int boost_cont_malloc_check(void);
 
 boost_cont_command_ret_t boost_cont_allocation_command
    ( allocation_type command
@@ -290,7 +290,7 @@ boost_cont_command_ret_t boost_cont_allocation_command
    , void *reuse_ptr
    );
 
-void *boost_cont_sync_create();
+void *boost_cont_sync_create(void);
 
 void boost_cont_sync_destroy(void *sync);
 
@@ -298,9 +298,9 @@ int boost_cont_sync_lock(void *sync);
 
 void boost_cont_sync_unlock(void *sync);
 
-int boost_cont_global_sync_lock();
+int boost_cont_global_sync_lock(void);
 
-void boost_cont_global_sync_unlock();
+void boost_cont_global_sync_unlock(void);
 
 #ifdef __cplusplus
 }  //extern "C" {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/compare_functors.hpp

@@ -36,8 +36,29 @@ class equal_to_value
       :  t_(t)
    {}
 
-   inline bool operator()(const value_type &t)const
-   {  return t_ == t;   }
+   template <class U>
+   inline bool operator()(const U &t)const
+   {
+      return t_ == t;
+   }
+};
+
+template<class ValueType>
+class equal_to_value_first
+{
+   typedef ValueType value_type;
+   const value_type &t_;
+
+   public:
+   inline explicit equal_to_value_first(const value_type &t)
+      :  t_(t)
+   {}
+
+   template <class U>
+   inline bool operator()(const U &t)const
+   {
+      return t_ == t.first;
+   }
 };
 
 template<class Node, class Pred, class Ret = bool>

data/src/cxx_supportlib/vendor-modified/boost/container/detail/config_begin.hpp

@@ -19,7 +19,6 @@
    #pragma warning (push)
    #pragma warning (disable : 4619) // there is no warning number 'XXXX'
    #pragma warning (disable : 4127) // conditional expression is constant
-   #pragma warning (disable : 4146) // unary minus operator applied to unsigned type, result still unsigned
    #pragma warning (disable : 4197) // top-level volatile in cast is ignored
    #pragma warning (disable : 4251) // "identifier" : class "type" needs to have dll-interface to be used by clients of class "type2"
    #pragma warning (disable : 4275) // non DLL-interface classkey "identifier" used as base for DLL-interface classkey "identifier"

data/src/cxx_supportlib/vendor-modified/boost/container/detail/copy_move_algo.hpp

@@ -228,7 +228,7 @@ inline F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
    const value_type *const end_raw = boost::movelib::iterator_to_raw_pointer(l);
    if(BOOST_LIKELY(beg_raw != end_raw && dest_raw && beg_raw)){
       const std::size_t n = std::size_t(end_raw - beg_raw)   ;
-      std::memmove(dest_raw, beg_raw, sizeof(value_type)*n);
+      std::memmove(reinterpret_cast<void *>(dest_raw), beg_raw, sizeof(value_type)*n);
       r += static_cast<r_difference_type>(n);
    }
    return r;
@@ -800,10 +800,9 @@ inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
 
 template
 <typename I,   // I models InputIterator
-typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
-   copy_n(I f, U n, F r)
+   copy_n(I f, std::size_t n, F r)
 {
    while (n) {
       --n;
@@ -815,10 +814,9 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
 
 template
 <typename I,   // I models InputIterator
-typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
-   copy_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   copy_n(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -829,10 +827,9 @@ inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
 
 template
 <typename I,   // I models InputIterator
-typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
-   copy_n_source(I f, U n, F r)
+   copy_n_source(I f, std::size_t n, F r)
 {
    while (n) {
       --n;
@@ -910,10 +907,9 @@ inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
 
 template
 <typename I,   // I models InputIterator
-typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
-   move_n(I f, U n, F r)
+   move_n(I f, std::size_t n, F r)
 {
    while (n) {
       --n;
@@ -925,13 +921,11 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
 
 template
 <typename I,   // I models InputIterator
-typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
-   move_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   move_n(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n(f, n, r); }
 
-
 //////////////////////////////////////////////////////////////////////////////
 //
 //                         move_backward
@@ -961,11 +955,86 @@ inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
    const std::size_t n = boost::container::iterator_udistance(f, l);
    if (BOOST_LIKELY(n != 0)){
       r -= n;
-      std::memmove((boost::movelib::iterator_to_raw_pointer)(r), (boost::movelib::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+      std::memmove(reinterpret_cast<void *>((boost::movelib::iterator_to_raw_pointer)(r)), (boost::movelib::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
+   }
+   return r;
+}
+
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         move_backward_n
+//
+//////////////////////////////////////////////////////////////////////////////
+
+template
+<typename I,   // I models BidirectionalIterator
+typename F>    // F models ForwardIterator
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
+   move_backward_n(I l, std::size_t n, F r)
+{
+   while (n) {
+      --n;
+      --l; --r;
+      *r = ::boost::move(*l);
+   }
+   return r;
+}
+
+template
+<typename I,   // I models InputIterator
+typename F>   // F models ForwardIterator
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
+   move_backward_n(I l, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+{
+   typedef typename boost::container::iter_value<I>::type value_type;
+   if (BOOST_LIKELY(n != 0)){
+      r -= n;
+      std::memmove (reinterpret_cast<void *>((boost::movelib::iterator_to_raw_pointer)(r))
+                  , reinterpret_cast<const void *>((boost::movelib::iterator_to_raw_pointer)(l) - n)
+                  , sizeof(value_type)*n);
    }
    return r;
 }
 
+//////////////////////////////////////////////////////////////////////////////
+//
+//                         move_backward_n_source
+//
+//////////////////////////////////////////////////////////////////////////////
+
+template
+<typename I,   // I models BidirectionalIterator
+typename F>    // F models ForwardIterator
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
+   move_backward_n_source(I l, std::size_t n, F r)
+{
+   while (n) {
+      --n;
+      --l; --r;
+      *r = ::boost::move(*l);
+   }
+   return l;
+}
+
+template
+<typename I,   // I models InputIterator
+typename F>   // F models ForwardIterator
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
+   move_backward_n_source(I l, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+{
+   typedef typename boost::container::iter_value<I>::type value_type;
+   
+   if (BOOST_LIKELY(n != 0)){
+      r -= n;
+      l -= n;
+      std::memmove( reinterpret_cast<void *>((boost::movelib::iterator_to_raw_pointer)(r))
+                  , l
+                  , sizeof(value_type)*n);
+   }
+   return l;
+}
+
+
 //////////////////////////////////////////////////////////////////////////////
 //
 //                         move_n_source_dest
@@ -974,10 +1043,9 @@ inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
 
 template
 <typename I    // I models InputIterator
-,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
-   move_n_source_dest(I f, U n, F &r)
+   move_n_source_dest(I f, std::size_t n, F &r)
 {
    while (n) {
       --n;
@@ -1002,10 +1070,9 @@ inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
 
 template
 <typename I    // I models InputIterator
-,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
-   move_n_source(I f, U n, F r)
+   move_n_source(I f, std::size_t n, F r)
 {
    while (n) {
       --n;
@@ -1043,10 +1110,9 @@ inline B move_backward_overlapping(B f, B l, B rl)
 
 template
    <typename Allocator
-   ,typename I   // I models InputIterator
-   ,typename U>  // U models unsigned integral constant
+   ,typename I>  // I models InputIterator
 inline typename dtl::disable_if_trivially_destructible<I, void>::type
-   destroy_alloc_n(Allocator &a, I f, U n)
+   destroy_alloc_n(Allocator &a, I f, std::size_t n)
 {
    while(n){
       --n;
@@ -1057,10 +1123,9 @@ inline typename dtl::disable_if_trivially_destructible<I, void>::type
 
 template
    <typename Allocator
-   ,typename I   // I models InputIterator
-   ,typename U>  // U models unsigned integral constant
+   ,typename I>   // I models InputIterator
 inline typename dtl::enable_if_trivially_destructible<I, void>::type
-   destroy_alloc_n(Allocator &, I, U)
+   destroy_alloc_n(Allocator &, I, std::size_t)
 {}
 
 //////////////////////////////////////////////////////////////////////////////

data/src/cxx_supportlib/vendor-modified/boost/container/detail/flat_tree.hpp

@@ -1175,8 +1175,9 @@ class flat_tree
       !dtl::is_convertible<K, iterator>::value &&     //not convertible to iterator
       !dtl::is_convertible<K, const_iterator>::value  //not convertible to const_iterator
       , size_type>::type
-      erase(const K& k)
+      erase(BOOST_FWD_REF(K) key)
    {
+      const typename remove_cvref<K>::type & k = key;  //Support emulated rvalue references
       std::pair<iterator, iterator > itp = this->equal_range(k);
       size_type ret = static_cast<size_type>(itp.second - itp.first);
       if (ret) {

data/src/cxx_supportlib/vendor-modified/boost/container/detail/node_pool_impl.hpp

@@ -173,7 +173,7 @@ class private_node_pool_impl
             //Unlink the nodes
             free_nodes.clear();
             it = m_blocklist.erase_after(bit);
-            mp_segment_mngr_base->deallocate((void*)addr);
+            mp_segment_mngr_base->deallocate(const_cast<void*>(addr));
          }
          //Otherwise, insert them in the backup list, since the
          //next "remove_if" does not need to check them again.
@@ -221,7 +221,7 @@ class private_node_pool_impl
       while(!m_blocklist.empty()){
          void *addr = get_block_from_hook(&m_blocklist.front(), blocksize);
          m_blocklist.pop_front();
-         mp_segment_mngr_base->deallocate((void*)addr);
+         mp_segment_mngr_base->deallocate(const_cast<void*>(addr));
       }
       //Just clear free node list
       m_freelist.clear();

data/src/cxx_supportlib/vendor-modified/boost/container/detail/operator_new_helpers.hpp

@@ -0,0 +1,68 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2025-2025. 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 http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_DETAIL_OPERATOR_NEW_HELPERS_HPP
+#define BOOST_CONTAINER_DETAIL_OPERATOR_NEW_HELPERS_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/std_fwd.hpp>
+#include <boost/container/throw_exception.hpp>
+
+namespace boost {
+namespace container {
+namespace dtl {
+
+template <class T>
+T* operator_new_allocate(std::size_t count)
+{
+   const std::size_t max_count = std::size_t(-1)/(2*sizeof(T));
+   if(BOOST_UNLIKELY(count > max_count))
+      throw_bad_alloc();
+   #if defined(__cpp_aligned_new)
+   BOOST_IF_CONSTEXPR(__STDCPP_DEFAULT_NEW_ALIGNMENT__ < alignof(T)) {
+      return static_cast<T*>(::operator new(count*sizeof(T), std::align_val_t(alignof(T))));
+   }
+   #endif
+   return static_cast<T*>(::operator new(count*sizeof(T)));
+}
+
+template <class T>
+void operator_delete_deallocate(T* ptr, std::size_t n) BOOST_NOEXCEPT_OR_NOTHROW
+{
+   (void)n;
+   #ifdef __cpp_aligned_new
+   BOOST_IF_CONSTEXPR(__STDCPP_DEFAULT_NEW_ALIGNMENT__ < alignof(T)) {
+      # if defined(__cpp_sized_deallocation)
+      ::operator delete((void*)ptr, n * sizeof(T), std::align_val_t(alignof(T)));
+      #else
+      ::operator delete((void*)ptr, std::align_val_t(alignof(T)));
+      # endif
+      return;
+   }
+   #endif
+
+   # if defined(__cpp_sized_deallocation)
+   ::operator delete((void*)ptr, n * sizeof(T));
+   #else
+   ::operator delete((void*)ptr);
+   # endif
+}
+
+}  //namespace dtl {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //#ifndef BOOST_CONTAINER_DETAIL_OPERATOR_NEW_HELPERS_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/detail/pair.hpp

@@ -548,44 +548,84 @@ struct is_class< std::pair<T1, T2> >
 
 
 //Triviality of pair
+
+//
+// is_trivially_copy_assignable
+//
+
 template<class T>
-struct is_trivially_copy_constructible;
+struct is_trivially_copy_assignable;
 
 template<class A, class B>
-struct is_trivially_copy_assignable
-   <boost::container::dtl::pair<A,B> >
+struct is_trivially_copy_assignable<boost::container::dtl::pair<A,B> >
 {
-   BOOST_STATIC_CONSTEXPR bool value = false ;
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_copy_assignable<A>::value &&
+                                       boost::move_detail::is_trivially_copy_assignable<B>::value;
 };
 
+template<class A, class B>
+struct is_trivially_copy_assignable<std::pair<A,B> >
+   : is_trivially_copy_assignable<boost::container::dtl::pair<A,B> >
+{};
+
+//
+// is_trivially_move_assignable
+//
+
 template<class T>
-struct is_trivially_move_constructible;
+struct is_trivially_move_assignable;
 
 template<class A, class B>
-struct is_trivially_move_assignable
-   <boost::container::dtl::pair<A,B> >
+struct is_trivially_move_assignable<boost::container::dtl::pair<A,B> >
 {
-   BOOST_STATIC_CONSTEXPR bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_move_assignable<A>::value &&
+                                       boost::move_detail::is_trivially_move_assignable<B>::value;
 };
 
+template<class A, class B>
+struct is_trivially_move_assignable<std::pair<A,B> >
+   : is_trivially_move_assignable<boost::container::dtl::pair<A,B> >
+{};
+
+
+//
+// is_trivially_copy_constructible
+//
+
 template<class T>
-struct is_trivially_copy_assignable;
+struct is_trivially_copy_constructible;
 
 template<class A, class B>
 struct is_trivially_copy_constructible<boost::container::dtl::pair<A,B> >
 {
-   BOOST_STATIC_CONSTEXPR bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_copy_constructible<A>::value &&
+                                       boost::move_detail::is_trivially_copy_constructible<B>::value;
 };
 
+template<class A, class B>
+struct is_trivially_copy_constructible<std::pair<A,B> >
+   : is_trivially_copy_constructible<boost::container::dtl::pair<A,B> >
+{};
+
+//
+// is_trivially_move_constructible
+//
+
 template<class T>
-struct is_trivially_move_assignable;
+struct is_trivially_move_constructible;
 
 template<class A, class B>
 struct is_trivially_move_constructible<boost::container::dtl::pair<A,B> >
 {
-   BOOST_STATIC_CONSTEXPR bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_move_constructible<A>::value &&
+                                       boost::move_detail::is_trivially_move_constructible<B>::value;
 };
 
+template<class A, class B>
+struct is_trivially_move_constructible<std::pair<A,B> >
+   : is_trivially_move_constructible<boost::container::dtl::pair<A,B> >
+{};
+
 template<class T>
 struct is_trivially_destructible;
 
@@ -593,12 +633,31 @@ template<class A, class B>
 struct is_trivially_destructible<boost::container::dtl::pair<A,B> >
 {
    BOOST_STATIC_CONSTEXPR bool value = boost::move_detail::is_trivially_destructible<A>::value &&
-                             boost::move_detail::is_trivially_destructible<B>::value ;
+                                       boost::move_detail::is_trivially_destructible<B>::value;
 };
 
+template<class A, class B>
+struct is_trivially_destructible<std::pair<A,B> >
+   : is_trivially_destructible<boost::container::dtl::pair<A,B> >
+{};
 
 }  //namespace move_detail{
 
+template<class T>
+struct has_trivial_destructor_after_move;
+
+template<class A, class B>
+struct has_trivial_destructor_after_move<boost::container::dtl::pair<A,B> >
+{
+   BOOST_STATIC_CONSTEXPR bool value = boost::has_trivial_destructor_after_move<A>::value &&
+                                       boost::has_trivial_destructor_after_move<B>::value;
+};
+
+template<class A, class B>
+struct has_trivial_destructor_after_move<std::pair<A,B> >
+   : has_trivial_destructor_after_move<boost::container::dtl::pair<A,B> >
+{};
+
 }  //namespace boost {
 
 #include <boost/container/detail/config_end.hpp>

data/src/cxx_supportlib/vendor-modified/boost/container/detail/std_fwd.hpp

@@ -23,6 +23,8 @@
 //                        Standard predeclarations
 //////////////////////////////////////////////////////////////////////////////
 
+#include <cstddef>
+
 #include <boost/move/detail/std_ns_begin.hpp>
 BOOST_MOVE_STD_NS_BEG
 
@@ -59,4 +61,15 @@ struct pointer_traits;
 BOOST_MOVE_STD_NS_END
 #include <boost/move/detail/std_ns_end.hpp>
 
+#if defined(__cpp_aligned_new)
+
+//align_val_t is not usually in an inline namespace
+namespace std {
+
+enum class align_val_t : std::size_t;
+
+}  //namespace std
+
+#endif
+
 #endif //#ifndef BOOST_CONTAINER_DETAIL_STD_FWD_HPP