passenger 6.0.22 → 6.0.24

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

@@ -76,7 +76,7 @@ class private_adaptive_node_pool
    private_adaptive_node_pool &operator=(const private_adaptive_node_pool &);
 
    public:
-   static const std::size_t nodes_per_block = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block = NodesPerBlock;
 
    //!Constructor. Never throws
    private_adaptive_node_pool()

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

@@ -49,10 +49,10 @@ namespace container {
 
 namespace adaptive_pool_flag {
 
-static const unsigned int none            = 0u;
-static const unsigned int align_only      = 1u << 0u;
-static const unsigned int size_ordered    = 1u << 1u;
-static const unsigned int address_ordered = 1u << 2u;
+BOOST_CONTAINER_CONSTANT_VAR unsigned int none            = 0u;
+BOOST_CONTAINER_CONSTANT_VAR unsigned int align_only      = 1u << 0u;
+BOOST_CONTAINER_CONSTANT_VAR unsigned int size_ordered    = 1u << 1u;
+BOOST_CONTAINER_CONSTANT_VAR unsigned int address_ordered = 1u << 2u;
 
 }  //namespace adaptive_pool_flag{
 
@@ -213,11 +213,11 @@ template<class MultiallocationChain, class VoidPointer, class SizeType, unsigned
 struct adaptive_pool_types
 {
    typedef VoidPointer void_pointer;
-   static const unsigned ordered = (Flags & (adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered));
+   BOOST_STATIC_CONSTEXPR unsigned ordered = (Flags & (adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered));
    typedef block_container_traits<VoidPointer, SizeType, ordered> block_container_traits_t;
    typedef typename block_container_traits_t::hook_t hook_t;
    typedef hdr_offset_holder_t<SizeType> hdr_offset_holder;
-   static const unsigned int order_flags = Flags & (adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered);
+   BOOST_STATIC_CONSTEXPR unsigned int order_flags = Flags & (adaptive_pool_flag::size_ordered | adaptive_pool_flag::address_ordered);
    typedef MultiallocationChain free_nodes_t;
 
    struct block_info_t
@@ -253,11 +253,11 @@ template< std::size_t alignment
         , std::size_t overhead_percent>
 struct candidate_power_of_2_ct_helper
 {
-   static const std::size_t hdr_subblock_elements_alone = (alignment - hdr_size - payload_per_allocation)/real_node_size;
-   static const std::size_t hdr_subblock_elements_first = (alignment - hdr_size - payload_per_allocation)/real_node_size;
-   static const std::size_t elements_per_b_subblock_mid = (alignment - hdr_offset_size)/real_node_size;
-   static const std::size_t elements_per_b_subblock_end = (alignment - hdr_offset_size - payload_per_allocation)/real_node_size;
-   static const std::size_t num_b_subblock =
+   BOOST_STATIC_CONSTEXPR std::size_t hdr_subblock_elements_alone = (alignment - hdr_size - payload_per_allocation)/real_node_size;
+   BOOST_STATIC_CONSTEXPR std::size_t hdr_subblock_elements_first = (alignment - hdr_size - payload_per_allocation)/real_node_size;
+   BOOST_STATIC_CONSTEXPR std::size_t elements_per_b_subblock_mid = (alignment - hdr_offset_size)/real_node_size;
+   BOOST_STATIC_CONSTEXPR std::size_t elements_per_b_subblock_end = (alignment - hdr_offset_size - payload_per_allocation)/real_node_size;
+   BOOST_STATIC_CONSTEXPR std::size_t num_b_subblock =
       hdr_subblock_elements_alone >= min_elements_per_block
          ? 0
          : (   ((hdr_subblock_elements_first + elements_per_b_subblock_end) >= min_elements_per_block)
@@ -266,18 +266,18 @@ struct candidate_power_of_2_ct_helper
             )
          ;
 
-   static const std::size_t num_b_subblock_mid = (num_b_subblock > 1) ? (num_b_subblock - 1) : 0;
+   BOOST_STATIC_CONSTEXPR std::size_t num_b_subblock_mid = (num_b_subblock > 1) ? (num_b_subblock - 1) : 0;
 
-   static const std::size_t total_nodes = (num_b_subblock == 0)
+   BOOST_STATIC_CONSTEXPR std::size_t total_nodes = (num_b_subblock == 0)
                                          ? hdr_subblock_elements_alone
                                          : ( (num_b_subblock == 1)
                                            ? (hdr_subblock_elements_first + elements_per_b_subblock_end)
                                            : (hdr_subblock_elements_first + num_b_subblock_mid*elements_per_b_subblock_mid + elements_per_b_subblock_end)
                                            )
                                          ;
-   static const std::size_t total_data = total_nodes*real_node_size;
-   static const std::size_t total_size = alignment*(num_b_subblock+1);
-   static const bool overhead_satisfied = (total_size - total_data)*100/total_size < overhead_percent;
+   BOOST_STATIC_CONSTEXPR std::size_t total_data = total_nodes*real_node_size;
+   BOOST_STATIC_CONSTEXPR std::size_t total_size = alignment*(num_b_subblock+1);
+   BOOST_STATIC_CONSTEXPR bool overhead_satisfied = (total_size - total_data)*100/total_size < overhead_percent;
 };
 
 template< std::size_t initial_alignment
@@ -299,7 +299,7 @@ struct candidate_power_of_2_ct
         , hdr_offset_size
         , overhead_percent> helper_t;
 
-   static const std::size_t candidate_power_of_2 = initial_alignment << std::size_t(!helper_t::overhead_satisfied);
+   BOOST_STATIC_CONSTEXPR std::size_t candidate_power_of_2 = initial_alignment << std::size_t(!helper_t::overhead_satisfied);
 
    typedef typename candidate_power_of_2_ct
       < candidate_power_of_2
@@ -312,9 +312,9 @@ struct candidate_power_of_2_ct
       , !helper_t::overhead_satisfied
       >::type type;
 
-   static const std::size_t alignment     = type::alignment;
-   static const std::size_t num_subblocks = type::num_subblocks;
-   static const std::size_t real_num_node = type::real_num_node;
+   BOOST_STATIC_CONSTEXPR std::size_t alignment     = type::alignment;
+   BOOST_STATIC_CONSTEXPR std::size_t num_subblocks = type::num_subblocks;
+   BOOST_STATIC_CONSTEXPR std::size_t real_num_node = type::real_num_node;
 };
 
 template< std::size_t initial_alignment
@@ -354,9 +354,9 @@ struct candidate_power_of_2_ct
         , hdr_offset_size
         , overhead_percent> helper_t;
 
-   static const std::size_t alignment = initial_alignment;
-   static const std::size_t num_subblocks = helper_t::num_b_subblock+1;
-   static const std::size_t real_num_node = helper_t::total_nodes;
+   BOOST_STATIC_CONSTEXPR std::size_t alignment = initial_alignment;
+   BOOST_STATIC_CONSTEXPR std::size_t num_subblocks = helper_t::num_b_subblock+1;
+   BOOST_STATIC_CONSTEXPR std::size_t real_num_node = helper_t::total_nodes;
 };
 
 /////////////////////////////////////////////
@@ -429,13 +429,13 @@ class private_adaptive_node_pool_impl_common
    typedef typename SegmentManagerBase::size_type                    size_type;
    //Flags
    //align_only
-   static const bool AlignOnly      = (Flags & adaptive_pool_flag::align_only) != 0;
+   BOOST_STATIC_CONSTEXPR bool AlignOnly      = (Flags & adaptive_pool_flag::align_only) != 0;
    typedef bool_<AlignOnly>            IsAlignOnly;
    typedef true_                       AlignOnlyTrue;
    typedef false_                      AlignOnlyFalse;
 
    typedef typename SegmentManagerBase::void_pointer void_pointer;
-   static const typename SegmentManagerBase::
+   BOOST_STATIC_CONSTEXPR typename SegmentManagerBase::
       size_type PayloadPerAllocation = SegmentManagerBase::PayloadPerAllocation;
 
    typedef typename boost::intrusive::pointer_traits
@@ -453,9 +453,9 @@ class private_adaptive_node_pool_impl_common
    typedef typename adaptive_pool_types_t::hdr_offset_holder         hdr_offset_holder;
    typedef private_adaptive_node_pool_impl_common                    this_type;
 
-   static const size_type MaxAlign = alignment_of<void_pointer>::value;
-   static const size_type HdrSize  = ((sizeof(block_info_t)-1)/MaxAlign+1)*MaxAlign;
-   static const size_type HdrOffsetSize = ((sizeof(hdr_offset_holder)-1)/MaxAlign+1)*MaxAlign;
+   BOOST_STATIC_CONSTEXPR size_type MaxAlign = alignment_of<void_pointer>::value;
+   BOOST_STATIC_CONSTEXPR size_type HdrSize  = ((sizeof(block_info_t)-1)/MaxAlign+1)*MaxAlign;
+   BOOST_STATIC_CONSTEXPR size_type HdrOffsetSize = ((sizeof(hdr_offset_holder)-1)/MaxAlign+1)*MaxAlign;
 
    segment_mngr_base_ptr_t             mp_segment_mngr_base;   //Segment manager
    block_container_t                   m_block_container;      //Intrusive block list
@@ -981,9 +981,9 @@ template< class SizeType
         , bool AlignOnly>
 struct calculate_alignment_ct
 {
-   static const std::size_t alignment     = upper_power_of_2_ct<SizeType, HdrSize + RealNodeSize*NodesPerBlock>::value;
-   static const std::size_t num_subblocks = 0;
-   static const std::size_t real_num_node = (alignment - PayloadPerAllocation - HdrSize)/RealNodeSize;
+   BOOST_STATIC_CONSTEXPR std::size_t alignment     = upper_power_of_2_ct<SizeType, HdrSize + RealNodeSize*NodesPerBlock>::value;
+   BOOST_STATIC_CONSTEXPR std::size_t num_subblocks = 0;
+   BOOST_STATIC_CONSTEXPR std::size_t real_num_node = (alignment - PayloadPerAllocation - HdrSize)/RealNodeSize;
 };
 
 template< class SizeType
@@ -1013,9 +1013,9 @@ struct calculate_alignment_ct
       , OverheadPercent
       >::type type;
 
-   static const std::size_t alignment     = type::alignment;
-   static const std::size_t num_subblocks = type::num_subblocks;
-   static const std::size_t real_num_node = type::real_num_node;
+   BOOST_STATIC_CONSTEXPR std::size_t alignment     = type::alignment;
+   BOOST_STATIC_CONSTEXPR std::size_t num_subblocks = type::num_subblocks;
+   BOOST_STATIC_CONSTEXPR std::size_t real_num_node = type::real_num_node;
 };
 
 
@@ -1046,17 +1046,17 @@ class private_adaptive_node_pool_impl_ct
    typedef typename base_t::multiallocation_chain     multiallocation_chain;
    typedef typename base_t::segment_manager_base_type segment_manager_base_type;
 
-   static const typename base_t::size_type PayloadPerAllocation = base_t::PayloadPerAllocation;
+   BOOST_STATIC_CONSTEXPR typename base_t::size_type PayloadPerAllocation = base_t::PayloadPerAllocation;
 
    //align_only
-   static const bool AlignOnly      = base_t::AlignOnly;
+   BOOST_STATIC_CONSTEXPR bool AlignOnly      = base_t::AlignOnly;
 
    private:
-   static const size_type MaxAlign = base_t::MaxAlign;
-   static const size_type HdrSize  = base_t::HdrSize;
-   static const size_type HdrOffsetSize = base_t::HdrOffsetSize;
+   BOOST_STATIC_CONSTEXPR size_type MaxAlign = base_t::MaxAlign;
+   BOOST_STATIC_CONSTEXPR size_type HdrSize  = base_t::HdrSize;
+   BOOST_STATIC_CONSTEXPR size_type HdrOffsetSize = base_t::HdrOffsetSize;
 
-   static const size_type RealNodeSize = lcm_ct<NodeSize, alignment_of<void_pointer>::value>::value;
+   BOOST_STATIC_CONSTEXPR size_type RealNodeSize = lcm_ct<NodeSize, alignment_of<void_pointer>::value>::value;
 
    typedef calculate_alignment_ct
       < size_type, HdrSize, PayloadPerAllocation
@@ -1065,9 +1065,9 @@ class private_adaptive_node_pool_impl_ct
    //Round the size to a power of two value.
    //This is the total memory size (including payload) that we want to
    //allocate from the general-purpose allocator
-   static const size_type NumSubBlocks       = data_t::num_subblocks;
-   static const size_type RealNumNode        = data_t::real_num_node;
-   static const size_type RealBlockAlignment = data_t::alignment;
+   BOOST_STATIC_CONSTEXPR size_type NumSubBlocks       = data_t::num_subblocks;
+   BOOST_STATIC_CONSTEXPR size_type RealNumNode        = data_t::real_num_node;
+   BOOST_STATIC_CONSTEXPR size_type RealBlockAlignment = data_t::alignment;
 
    public:
 
@@ -1165,14 +1165,14 @@ class private_adaptive_node_pool_impl_rt
    typedef typename impl_t::size_type              size_type;
    typedef typename impl_t::multiallocation_chain  multiallocation_chain;
 
-   static const typename impl_t::size_type PayloadPerAllocation = impl_t::PayloadPerAllocation;
+   BOOST_STATIC_CONSTEXPR typename impl_t::size_type PayloadPerAllocation = impl_t::PayloadPerAllocation;
 
    //Flags
    //align_only
-   static const bool AlignOnly      = impl_t::AlignOnly;
+   BOOST_STATIC_CONSTEXPR bool AlignOnly      = impl_t::AlignOnly;
 
-   static const size_type HdrSize  = impl_t::HdrSize;
-   static const size_type HdrOffsetSize = impl_t::HdrOffsetSize;
+   BOOST_STATIC_CONSTEXPR size_type HdrSize  = impl_t::HdrSize;
+   BOOST_STATIC_CONSTEXPR size_type HdrOffsetSize = impl_t::HdrOffsetSize;
 
    public:
 

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

@@ -39,6 +39,7 @@
 
 #include <boost/move/utility_core.hpp>
 #include <boost/move/detail/force_ptr.hpp>
+#include <boost/move/detail/launder.hpp>
 // other
 #include <boost/assert.hpp>
 
@@ -138,8 +139,8 @@ struct insert_value_initialized_n_proxy
       while (n){
          --n;
          storage_t v;
-         alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v));
-         value_type *vp = move_detail::force_ptr<value_type *>(&v);
+         alloc_traits::construct(a, (value_type*)&v);
+         value_type *vp = move_detail::launder_cast<value_type *>(&v);
          value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
          *p = ::boost::move(*vp);
          ++p;
@@ -165,8 +166,8 @@ struct insert_default_initialized_n_proxy
          while (n){
             --n;
             typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
-            alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v), default_init);
-            value_type *vp = move_detail::force_ptr<value_type *>(&v);
+            alloc_traits::construct(a, (value_type*)&v, default_init);
+            value_type *vp = move_detail::launder_cast<value_type *>(&v);
             value_destructor<Allocator> on_exit(a, *vp); (void)on_exit;
             *p = ::boost::move(*vp);
             ++p;
@@ -181,7 +182,7 @@ struct insert_copy_proxy
    typedef boost::container::allocator_traits<Allocator> alloc_traits;
    typedef typename alloc_traits::value_type value_type;
 
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_copy_proxy(const value_type &v)
       :  v_(v)
@@ -211,7 +212,7 @@ struct insert_move_proxy
    typedef boost::container::allocator_traits<Allocator> alloc_traits;
    typedef typename alloc_traits::value_type value_type;
 
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_move_proxy(value_type &v)
       :  v_(v)
@@ -264,7 +265,7 @@ struct insert_nonmovable_emplace_proxy
    typedef typename alloc_traits::value_type       value_type;
    typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;
 
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_nonmovable_emplace_proxy(BOOST_FWD_REF(Args)... args)
       : args_(args...)
@@ -295,7 +296,7 @@ struct insert_emplace_proxy
    typedef typename base_t::value_type             value_type;
    typedef typename base_t::index_tuple_t          index_tuple_t;
 
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy(BOOST_FWD_REF(Args)... args)
       : base_t(::boost::forward<Args>(args)...)
@@ -312,8 +313,8 @@ struct insert_emplace_proxy
    {
       BOOST_ASSERT(n ==1); (void)n;
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
-      alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(get<IdxPack>(this->args_))...);
-      value_type *vp = move_detail::force_ptr<value_type *>(&v);
+      alloc_traits::construct(a, (value_type*)&v, ::boost::forward<Args>(get<IdxPack>(this->args_))...);
+      value_type *vp = move_detail::launder_cast<value_type *>(&v);
       BOOST_CONTAINER_TRY{
          *p = ::boost::move(*vp);
       }
@@ -331,7 +332,7 @@ template<class Allocator>
 struct insert_emplace_proxy<Allocator, typename boost::container::allocator_traits<Allocator>::value_type>
    : public insert_move_proxy<Allocator>
 {
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy(typename boost::container::allocator_traits<Allocator>::value_type &&v)
    : insert_move_proxy<Allocator>(v)
@@ -348,7 +349,7 @@ struct insert_emplace_proxy<Allocator
    : public insert_copy_proxy<Allocator>
 {
 
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
@@ -359,7 +360,7 @@ template<class Allocator>
 struct insert_emplace_proxy<Allocator, typename boost::container::allocator_traits<Allocator>::value_type &>
    : public insert_copy_proxy<Allocator>
 {
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
@@ -372,7 +373,7 @@ struct insert_emplace_proxy<Allocator
    >
    : public insert_copy_proxy<Allocator>
 {
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
@@ -396,7 +397,7 @@ struct insert_nonmovable_emplace_proxy##N\
    typedef boost::container::allocator_traits<Allocator> alloc_traits;\
    typedef typename alloc_traits::value_type value_type;\
    \
-   static const bool single_value = true;\
+   BOOST_STATIC_CONSTEXPR bool single_value = true;\
    \
    inline explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
       BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N {}\
@@ -425,7 +426,7 @@ struct insert_emplace_proxy_arg##N\
    typedef typename base_t::value_type value_type;\
    typedef boost::container::allocator_traits<Allocator> alloc_traits;\
    \
-   static const bool single_value = true;\
+   BOOST_STATIC_CONSTEXPR bool single_value = true;\
    \
    inline explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
       : base_t(BOOST_MOVE_FWD##N){}\
@@ -435,8 +436,8 @@ struct insert_emplace_proxy_arg##N\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
-      alloc_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
-      value_type *vp = move_detail::force_ptr<value_type *>(&v);\
+      alloc_traits::construct(a, (value_type*)&v BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
+      value_type *vp = move_detail::launder_cast<value_type *>(&v);\
       BOOST_CONTAINER_TRY{\
          *p = ::boost::move(*vp);\
       }\
@@ -459,7 +460,7 @@ template<class Allocator>
 struct insert_emplace_proxy_arg1<Allocator, ::boost::rv<typename boost::container::allocator_traits<Allocator>::value_type> >
    : public insert_move_proxy<Allocator>
 {
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_move_proxy<Allocator>(v)
@@ -470,7 +471,7 @@ template<class Allocator>
 struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator_traits<Allocator>::value_type>
    : public insert_copy_proxy<Allocator>
 {
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
@@ -484,7 +485,7 @@ template<class Allocator>
 struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator_traits<Allocator>::value_type>
    : public insert_move_proxy<Allocator>
 {
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy_arg1(typename boost::container::allocator_traits<Allocator>::value_type &&v)
    : insert_move_proxy<Allocator>(v)
@@ -500,7 +501,7 @@ struct insert_emplace_proxy_arg1<Allocator
    >
    : public insert_copy_proxy<Allocator>
 {
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
@@ -511,7 +512,7 @@ template<class Allocator>
 struct insert_emplace_proxy_arg1<Allocator, typename boost::container::allocator_traits<Allocator>::value_type &>
    : public insert_copy_proxy<Allocator>
 {
-   static const bool single_value = true;
+   BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)
@@ -524,7 +525,7 @@ struct insert_emplace_proxy_arg1<Allocator
    >
    : public insert_copy_proxy<Allocator>
 {
-   static const bool single_value = true;
+  BOOST_STATIC_CONSTEXPR bool single_value = true;
 
    inline explicit insert_emplace_proxy_arg1(const typename boost::container::allocator_traits<Allocator>::value_type &v)
    : insert_copy_proxy<Allocator>(v)

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

@@ -42,13 +42,13 @@ enum allocation_type_v
 
 typedef unsigned int allocation_type;
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-static const allocation_type allocate_new       = (allocation_type)allocate_new_v;
-static const allocation_type expand_fwd         = (allocation_type)expand_fwd_v;
-static const allocation_type expand_bwd         = (allocation_type)expand_bwd_v;
-static const allocation_type shrink_in_place    = (allocation_type)shrink_in_place_v;
-static const allocation_type try_shrink_in_place= (allocation_type)try_shrink_in_place_v;
-static const allocation_type nothrow_allocation = (allocation_type)nothrow_allocation_v;
-static const allocation_type zero_memory        = (allocation_type)zero_memory_v;
+BOOST_CONTAINER_CONSTANT_VAR allocation_type allocate_new       = (allocation_type)allocate_new_v;
+BOOST_CONTAINER_CONSTANT_VAR allocation_type expand_fwd         = (allocation_type)expand_fwd_v;
+BOOST_CONTAINER_CONSTANT_VAR allocation_type expand_bwd         = (allocation_type)expand_bwd_v;
+BOOST_CONTAINER_CONSTANT_VAR allocation_type shrink_in_place    = (allocation_type)shrink_in_place_v;
+BOOST_CONTAINER_CONSTANT_VAR allocation_type try_shrink_in_place= (allocation_type)try_shrink_in_place_v;
+BOOST_CONTAINER_CONSTANT_VAR allocation_type nothrow_allocation = (allocation_type)nothrow_allocation_v;
+BOOST_CONTAINER_CONSTANT_VAR allocation_type zero_memory        = (allocation_type)zero_memory_v;
 
 }  //namespace container {
 }  //namespace boost {

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

@@ -74,11 +74,11 @@ class block_list_base
 {
    list_node m_list;
 
-   static const std::size_t MaxAlignMinus1 = memory_resource::max_align-1u;
+   BOOST_STATIC_CONSTEXPR std::size_t MaxAlignMinus1 = memory_resource::max_align-1u;
 
    public:
 
-   static const std::size_t header_size = std::size_t(sizeof(DerivedFromBlockListHeader) + MaxAlignMinus1) & std::size_t(~MaxAlignMinus1);
+   BOOST_STATIC_CONSTEXPR std::size_t header_size = std::size_t(sizeof(DerivedFromBlockListHeader) + MaxAlignMinus1) & std::size_t(~MaxAlignMinus1);
 
    explicit block_list_base()
    {  list_algo::init_header(&m_list);  }

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

@@ -68,11 +68,11 @@ class block_slist_base
 {
    slist_node m_slist;
 
-   static const std::size_t MaxAlignMinus1 = memory_resource::max_align-1u;
+   BOOST_STATIC_CONSTEXPR std::size_t MaxAlignMinus1 = memory_resource::max_align-1u;
 
    public:
 
-   static const std::size_t header_size = std::size_t(sizeof(DerivedFromBlockSlistHeader) + MaxAlignMinus1) & std::size_t(~MaxAlignMinus1);
+   BOOST_STATIC_CONSTEXPR std::size_t header_size = std::size_t(sizeof(DerivedFromBlockSlistHeader) + MaxAlignMinus1) & std::size_t(~MaxAlignMinus1);
 
    explicit block_slist_base()
    {  slist_algo::init_header(&m_slist);  }

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

@@ -24,6 +24,7 @@
 #include <boost/container/allocator_traits.hpp>
 #include <boost/container/detail/iterators.hpp>
 #include <boost/container/detail/value_init.hpp>
+#include <boost/container/detail/is_pair.hpp>
 
 namespace boost {
 namespace container {
@@ -62,9 +63,42 @@ BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, empla
 
 //Assignment
 
+template<class T, class U>
+BOOST_CONTAINER_FORCEINLINE
+   typename dtl::disable_if_c
+      <  dtl::is_pair<typename dtl::remove_reference<T>::type>::value
+      && dtl::is_pair<typename dtl::remove_reference<U>::type>::value
+      , void>::type
+assign_in_place_ref(T &t, BOOST_FWD_REF(U) u)
+{  t = ::boost::forward<U>(u);  }
+
+template<class T, class U>
+BOOST_CONTAINER_FORCEINLINE
+   typename dtl::enable_if_c
+      <  dtl::is_pair<typename dtl::remove_reference<T>::type>::value
+      && dtl::is_pair<typename dtl::remove_reference<U>::type>::value
+      , void>::type
+assign_in_place_ref(T &t, const U &u)
+{
+   assign_in_place_ref(t.first, u.first);
+   assign_in_place_ref(t.second, u.second);
+}
+
+template<class T, class U>
+BOOST_CONTAINER_FORCEINLINE
+   typename dtl::enable_if_c
+      <  dtl::is_pair<typename dtl::remove_reference<T>::type>::value
+      && dtl::is_pair<typename dtl::remove_reference<U>::type>::value
+      , void>::type
+assign_in_place_ref(T &t, BOOST_RV_REF(U) u)
+{
+   assign_in_place_ref(t.first,  ::boost::move(u.first));
+   assign_in_place_ref(t.second, ::boost::move(u.second));
+}
+
 template<class DstIt, class InpIt>
 BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, InpIt source)
-{  *dest = *source;  }
+{  assign_in_place_ref(*dest, *source);  }
 
 template<class DstIt, class U>
 BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, value_init_construct_iterator<U>)

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

@@ -50,7 +50,7 @@
 #     pragma GCC diagnostic ignored "-Wstringop-overflow"
 #  endif
 //GCC 12 seems a bit confused about array access error with small_vector
-#  if defined(BOOST_GCC) && ((BOOST_GCC >= 120000) && (BOOST_GCC < 130000))
+#  if defined(BOOST_GCC) && (BOOST_GCC >= 110000)
 #     pragma GCC diagnostic ignored "-Wstringop-overread"
 #     pragma GCC diagnostic ignored "-Wstringop-overflow"
 #  endif
@@ -64,7 +64,7 @@ namespace dtl {
 template<class I>
 struct are_elements_contiguous
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 /////////////////////////
@@ -74,7 +74,7 @@ struct are_elements_contiguous
 template<class T>
 struct are_elements_contiguous<T*>
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 /////////////////////////
@@ -115,7 +115,7 @@ namespace dtl {
 template <class Pointer, bool IsConst>
 struct are_elements_contiguous<boost::container::vec_iterator<Pointer, IsConst> >
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 
@@ -126,7 +126,7 @@ struct are_elements_contiguous<boost::container::vec_iterator<Pointer, IsConst>
 template <class PointedType, class DifferenceType, class OffsetType, std::size_t OffsetAlignment>
 struct are_elements_contiguous< ::boost::interprocess::offset_ptr<PointedType, DifferenceType, OffsetType, OffsetAlignment> >
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 template <typename I, typename O>
@@ -185,20 +185,20 @@ private:
    template <class U> static two test(int, ...);
    template <class U> static char test(int, const wrapper<U::single_value>*);
 public:
-   static const bool value = sizeof(test<T>(0, 0)) == 1;
+   BOOST_STATIC_CONSTEXPR bool value = sizeof(test<T>(0, 0)) == 1;
    void dummy() {}
 };
 
 template<class InsertionProxy, bool = has_single_value<InsertionProxy>::value>
 struct is_single_value_proxy_impl
 {
-   static const bool value = InsertionProxy::single_value;
+   BOOST_STATIC_CONSTEXPR bool value = InsertionProxy::single_value;
 };
 
 template<class InsertionProxy>
 struct is_single_value_proxy_impl<InsertionProxy, false>
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template<class InsertionProxy>
@@ -293,7 +293,7 @@ template <typename O>
 struct is_memzero_initializable
 {
    typedef typename ::boost::container::iterator_traits<O>::value_type value_type;
-   static const bool value = are_elements_contiguous<O>::value &&
+   BOOST_STATIC_CONSTEXPR bool value = are_elements_contiguous<O>::value &&
       (  dtl::is_integral<value_type>::value || dtl::is_enum<value_type>::value
       #if defined(BOOST_CONTAINER_MEMZEROED_POINTER_IS_NULL)
       || dtl::is_pointer<value_type>::value
@@ -1111,7 +1111,7 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<F, G, void>::type
    boost::container::destroy_alloc_n(a, large_range_f, std::size_t(n_j - n_i));
 }
 
-static const std::size_t DeepSwapAllocNMaxStorage = std::size_t(1) << std::size_t(11); //2K bytes
+BOOST_CONTAINER_CONSTANT_VAR std::size_t DeepSwapAllocNMaxStorage = std::size_t(1) << std::size_t(11); //2K bytes
 
 template
    <std::size_t MaxTmpBytes
@@ -1496,8 +1496,8 @@ void expand_backward_forward_and_insert_alloc_move_backward
 {
    typedef std::size_t size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
-   static const bool trivial_dctr_after_move = has_trivial_destructor_after_move<value_type>::value;
-   static const bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;
+   BOOST_STATIC_CONSTEXPR bool trivial_dctr_after_move = has_trivial_destructor_after_move<value_type>::value;
+   BOOST_STATIC_CONSTEXPR bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;
 
    typedef typename dtl::if_c
       <trivial_dctr
@@ -1796,8 +1796,8 @@ inline void expand_backward_forward_and_insert_alloc_move_forward
 {
    typedef std::size_t size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
-   static const bool trivial_dctr_after_move = has_trivial_destructor_after_move<value_type>::value;
-   static const bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;
+   BOOST_STATIC_CONSTEXPR bool trivial_dctr_after_move = has_trivial_destructor_after_move<value_type>::value;
+   BOOST_STATIC_CONSTEXPR bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;
 
    typedef typename dtl::if_c
       <trivial_dctr

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

@@ -62,7 +62,7 @@ namespace dtl {
       template<class X>
       static no_type test(...);
 
-      static const bool value = sizeof(test<T>(0)) == sizeof(yes_type);
+      BOOST_STATIC_CONSTEXPR bool value = sizeof(test<T>(0)) == sizeof(yes_type);
    };
 
    template <class T, class InnerAlloc, class ...Args>