passenger 6.2.1 → 6.2.2

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

@@ -137,28 +137,29 @@ class node_allocator
 
    //!Returns the number of elements that could be allocated.
    //!Never throws
-   size_type max_size() const
-   {  return size_type(-1)/sizeof(T);   }
+   BOOST_CONTAINER_NODISCARD
+   size_type max_size() const BOOST_NOEXCEPT_OR_NOTHROW
+   {  return size_type(-1)/(2u*sizeof(T));   }
 
    //!Allocate memory for an array of count elements.
    //!Throws bad_alloc if there is no enough memory
-   pointer allocate(size_type count, const void * = 0)
+   BOOST_CONTAINER_NODISCARD
+   pointer allocate(size_type count)
    {
       if(BOOST_UNLIKELY(count > this->max_size()))
          boost::container::throw_bad_alloc();
 
-      if(Version == 1 && count == 1){
+      BOOST_IF_CONSTEXPR(Version == 1)
+      if(count == 1){
          typedef dtl::shared_node_pool
-            <sizeof(T), NodesPerBlock> shared_pool_t;
+            <sizeof(T), NodesPerBlock, dtl::alignment_of<T>::value> shared_pool_t;
          typedef dtl::singleton_default<shared_pool_t> singleton_t;
          return pointer(static_cast<T*>(singleton_t::instance().allocate_node()));
       }
-      else{
-         void *ret = dlmalloc_malloc(count*sizeof(T));
-         if(BOOST_UNLIKELY(!ret))
-            boost::container::throw_bad_alloc();
-         return static_cast<pointer>(ret);
-      }
+      void *ret = dlmalloc_memalign(count*sizeof(T), dtl::alignment_of<T>::value);
+      if(BOOST_UNLIKELY(!ret))
+         boost::container::throw_bad_alloc();
+      return static_cast<pointer>(ret);
    }
 
    //!Deallocate allocated memory.
@@ -166,26 +167,27 @@ class node_allocator
    void deallocate(const pointer &ptr, size_type count) BOOST_NOEXCEPT_OR_NOTHROW
    {
       (void)count;
-      if(Version == 1 && count == 1){
+      BOOST_IF_CONSTEXPR(Version == 1)
+      if(count == 1){
          typedef dtl::shared_node_pool
-            <sizeof(T), NodesPerBlock> shared_pool_t;
+            <sizeof(T), NodesPerBlock, dtl::alignment_of<T>::value> shared_pool_t;
          typedef dtl::singleton_default<shared_pool_t> singleton_t;
          singleton_t::instance().deallocate_node(ptr);
+         return;
       }
-      else{
-         dlmalloc_free(ptr);
-      }
+      dlmalloc_free(ptr);
    }
 
    //!Deallocates all free blocks of the pool
    static void deallocate_free_blocks() BOOST_NOEXCEPT_OR_NOTHROW
    {
       typedef dtl::shared_node_pool
-         <sizeof(T), NodesPerBlock> shared_pool_t;
+         <sizeof(T), NodesPerBlock, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       singleton_t::instance().deallocate_free_blocks();
    }
 
+   BOOST_CONTAINER_NODISCARD
    pointer allocation_command
       (allocation_type command, size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse)
    {
@@ -198,6 +200,7 @@ class node_allocator
 
    //!Returns maximum the number of objects the previously allocated memory
    //!pointed by p can hold.
+   BOOST_CONTAINER_NODISCARD
    size_type size(pointer p) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
@@ -207,11 +210,12 @@ class node_allocator
    //!Allocates just one object. Memory allocated with this function
    //!must be deallocated only with deallocate_one().
    //!Throws bad_alloc if there is no enough memory
+   BOOST_CONTAINER_NODISCARD
    pointer allocate_one()
    {
       BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       typedef dtl::shared_node_pool
-         <sizeof(T), NodesPerBlock> shared_pool_t;
+         <sizeof(T), NodesPerBlock, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       return (pointer)singleton_t::instance().allocate_node();
    }
@@ -222,13 +226,13 @@ class node_allocator
    {
       BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       typedef dtl::shared_node_pool
-         <sizeof(T), NodesPerBlock> shared_pool_t;
+         <sizeof(T), NodesPerBlock, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       typename shared_pool_t::multiallocation_chain ch;
       singleton_t::instance().allocate_nodes(num_elements, ch);
       chain.incorporate_after(chain.before_begin()
-                             , (T*)boost::movelib::iterator_to_raw_pointer(ch.begin())
-                             , (T*)boost::movelib::iterator_to_raw_pointer(ch.last())
+                             , (T*)static_cast<void*>(boost::movelib::iterator_to_raw_pointer(ch.begin()))
+                             , (T*)static_cast<void*>(boost::movelib::iterator_to_raw_pointer(ch.last()))
                              , ch.size());
    }
 
@@ -239,7 +243,7 @@ class node_allocator
    {
       BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       typedef dtl::shared_node_pool
-         <sizeof(T), NodesPerBlock> shared_pool_t;
+         <sizeof(T), NodesPerBlock, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       singleton_t::instance().deallocate_node(p);
    }
@@ -248,7 +252,7 @@ class node_allocator
    {
       BOOST_CONTAINER_STATIC_ASSERT(( Version > 1 ));
       typedef dtl::shared_node_pool
-         <sizeof(T), NodesPerBlock> shared_pool_t;
+         <sizeof(T), NodesPerBlock, dtl::alignment_of<T>::value> shared_pool_t;
       typedef dtl::singleton_default<shared_pool_t> singleton_t;
       typename shared_pool_t::multiallocation_chain ch
          ( boost::movelib::iterator_to_raw_pointer(chain.begin())
@@ -268,8 +272,8 @@ class node_allocator
          boost::container::throw_bad_alloc();
       }
       chain.incorporate_after( chain.before_begin()
-                             , (T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
-                             , (T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
+                             , (T*)static_cast<void*>(BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch))
+                             , (T*)static_cast<void*>(BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch))
                              , BOOST_CONTAINER_MEMCHAIN_SIZE(&ch));
    }
 
@@ -284,8 +288,8 @@ class node_allocator
          boost::container::throw_bad_alloc();
       }
       chain.incorporate_after( chain.before_begin()
-                             , (T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
-                             , (T*)BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch)
+                             , (T*)static_cast<void*>(BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch))
+                             , (T*)static_cast<void*>(BOOST_CONTAINER_MEMCHAIN_LASTMEM(&ch))
                              , BOOST_CONTAINER_MEMCHAIN_SIZE(&ch));
    }
 
@@ -307,32 +311,34 @@ class node_allocator
 
    //!An allocator always compares to true, as memory allocated with one
    //!instance can be deallocated by another instance
+   BOOST_CONTAINER_NODISCARD   
    friend bool operator==(const node_allocator &, const node_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return true;   }
 
    //!An allocator always compares to false, as memory allocated with one
    //!instance can be deallocated by another instance
+   BOOST_CONTAINER_NODISCARD
    friend bool operator!=(const node_allocator &, const node_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return false;   }
 
    private:
    pointer priv_allocation_command
       (allocation_type command,   std::size_t limit_size
-      ,size_type &prefer_in_recvd_out_size
-      ,pointer &reuse)
+      ,size_type &prefer_in_recvd_out_size, pointer &reuse_ptr)
    {
       std::size_t const preferred_size = prefer_in_recvd_out_size;
       dlmalloc_command_ret_t ret = {0 , 0};
-      if((limit_size > this->max_size()) || (preferred_size > this->max_size())){
+      if(BOOST_UNLIKELY(limit_size > this->max_size() || preferred_size > this->max_size())){
          return pointer();
       }
       std::size_t l_size = limit_size*sizeof(T);
       std::size_t p_size = preferred_size*sizeof(T);
       std::size_t r_size;
       {
-         void* reuse_ptr_void = reuse;
-         ret = dlmalloc_allocation_command(command, sizeof(T), l_size, p_size, &r_size, reuse_ptr_void);
-         reuse = static_cast<T*>(reuse_ptr_void);
+         void* reuse_ptr_void = reuse_ptr;
+         ret = dlmalloc_allocation_command( command, sizeof(T), dtl::alignment_of<T>::value
+                                          , l_size, p_size, &r_size, reuse_ptr_void);
+         reuse_ptr = ret.second ? static_cast<T*>(reuse_ptr_void) : 0;
       }
       prefer_in_recvd_out_size = r_size/sizeof(T);
       return (pointer)ret.first;

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

@@ -58,7 +58,7 @@ struct tree_opt
 
 typedef tree_opt<red_black_tree, true> tree_assoc_defaults;
 
-#endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#endif   // !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 //!This option setter specifies the underlying tree type
 //!(red-black, AVL, Scapegoat or Splay) for ordered associative containers
@@ -176,7 +176,7 @@ using hash_assoc_options_t = typename boost::container::hash_assoc_options<Optio
 
 #endif
 
-#endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#endif   // !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 ////////////////////////////////////////////////////////////////
 //
@@ -212,7 +212,7 @@ struct default_if_zero<0u, DefaultN>
    BOOST_STATIC_CONSTEXPR std::size_t value = DefaultN;
 };
 
-#endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#endif   // !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
@@ -244,6 +244,27 @@ class default_next_capacity;
 
 typedef vector_opt<void, void> vector_null_opt;
 
+template<class GrowthType, class StoredSizeType, std::size_t InlineChars>
+struct string_opt
+{
+   typedef GrowthType      growth_factor_type;
+   typedef StoredSizeType  stored_size_type;
+   static const std::size_t inline_chars = InlineChars;
+
+   template<class AllocTraits>
+   struct get_stored_size_type
+      : get_stored_size_type_with_alloctraits<AllocTraits, StoredSizeType>
+   {};
+};
+
+typedef string_opt<void, void, 0u> string_null_opt;
+
+struct growth_factor_50;
+
+struct growth_factor_60;
+
+struct growth_factor_100;
+
 #else
 
 //!This growth factor argument specifies that the container should increase its
@@ -258,7 +279,7 @@ struct growth_factor_60{};
 //!capacity a 100% (doubling its capacity) when existing capacity is exhausted.
 struct growth_factor_100{};
 
-#endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#endif   // !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 //!This option setter specifies the growth factor strategy of the
 //!underlying vector.
@@ -307,7 +328,8 @@ BOOST_INTRUSIVE_OPTION_TYPE(growth_factor, GrowthFactor, GrowthFactor, growth_fa
 //!a 32 bit alignment is required for vector and the size will be rounded to 8 bytes. In a 64-bit
 //!machine a 16 bit size type does not usually save memory when comparing to a 32-bit size type.
 //!Measure the size of the resulting container and do not assume a smaller \c stored_size
-//!will always lead to a smaller sizeof(container).
+//!will always lead to a smaller sizeof(container). You might end up not obtaining any `sizeof`
+//!reduction while severily limiting the maximum size of the container.
 //!
 //!If a user tries to insert more elements than representable by \c stored_size, the container
 //!will throw a length_error.
@@ -377,7 +399,7 @@ struct small_vector_opt
 
 typedef small_vector_opt<void, 0u, void> small_vector_null_opt;
 
-#endif    //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#endif    //   !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 //! Helper metafunction to combine options into a single type to be used
 //! by \c boost::container::small_vector.
@@ -448,7 +470,7 @@ struct static_vector_opt
 
 typedef static_vector_opt<true, 0u, void> static_vector_null_opt;
 
-#endif    //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+#endif    //   !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
 //! Helper metafunction to combine options into a single type to be used
 //! by \c boost::container::static_vector.
@@ -496,7 +518,7 @@ using static_vector_options_t = typename boost::container::static_vector_options
 //
 ////////////////////////////////////////////////////////////////
 
-//!Thse options specify the relocation strategy of devector.
+//!These options specify the relocation strategy of devector.
 //!
 //!Predefined relocation limits that can be passed as arguments to this option are:
 //!\c boost::container::relocate_on_66
@@ -510,11 +532,10 @@ using static_vector_options_t = typename boost::container::static_vector_options
 //!Note: Repeated insertions at only one end (only back insertions or only front insertions) usually will
 //!lead to a single relocation when `relocate_on_66` is used and two relocations when `relocate_on_90`
 //!is used.
+BOOST_INTRUSIVE_OPTION_CONSTANT(relocate_on, std::size_t, Fraction, free_fraction)
 
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-BOOST_INTRUSIVE_OPTION_CONSTANT(relocate_on, std::size_t, Fraction, free_fraction)
-
 struct relocate_on_66 : public relocate_on<3U>{};
 
 struct relocate_on_75 : public relocate_on<4U> {};
@@ -539,32 +560,32 @@ typedef devector_opt<void, void, 0u> devector_null_opt;
 //!This relocation condition option specifies that the container will never relocate
 //!elements when there is no space at the side the insertion should
 //!take place
-struct relocate_never;
+struct relocate_never{};
 
 //!This relocation condition option specifies that the container will relocate
 //!all elements when there is no space at the side the insertion should
 //!take place and memory usage is below 66% (2/3)
-struct relocate_on_66;
+struct relocate_on_66{};
 
 //!This relocation condition option specifies that the container will relocate
 //!all elements when there is no space at the side the insertion should
 //!take place and memory usage is below 75% (3/4)
-struct relocate_on_75;
+struct relocate_on_75{};
 
 //!This relocation condition option specifies that the container will relocate
 //!all elements when there is no space at the side the insertion should
 //!take place and memory usage is below 80% (4/5)
-struct relocate_on_80;
+struct relocate_on_80{};
 
 //!This relocation condition option specifies that the container will relocate
 //!all elements when there is no space at the side the insertion should
 //!take place and memory usage is below 85% (6/7)
-struct relocate_on_85;
+struct relocate_on_85{};
 
 //!This relocation condition option specifies that the container will relocate
 //!all elements when there is no space at the side the insertion should
 //!take place and memory usage is below 90% (9/10)
-struct relocate_on_90;
+struct relocate_on_90{};
 
 #endif
 
@@ -638,8 +659,9 @@ typedef deque_opt<0u, 0u, void, false> deque_null_opt;
 
 //! Helper metafunction to combine options into a single type to be used
 //! by \c boost::container::deque.
-//! Supported options are: \c boost::container::block_bytes, \c boost::container::block_size,
-//! \c boost::container::stored_size and \c boost::container::reservable
+//! Supported options are: \c boost::container::block_bytes / \c boost::container::segment_bytes,
+//! \c boost::container::block_size / \c boost::container::segment_size,
+//! \c boost::container::stored_size
 #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
 template<class ...Options>
 #else
@@ -674,30 +696,141 @@ using deque_options_t = typename boost::container::deque_options<Options...>::ty
 
 #endif
 
+////////////////////////////////////////////////////////////////
+//
+//
+//          OPTIONS FOR SEGTOR CONTAINERS
+//
+//
+////////////////////////////////////////////////////////////////
+
+#if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
+template<std::size_t BlockBytes, std::size_t BlockSize, class StoredSizeType, bool Reservable>
+struct segtor_opt : public deque_opt<BlockBytes, BlockSize, StoredSizeType, Reservable>
+{};
+
+typedef segtor_opt<0u, 0u, void, false> segtor_null_opt;
+
+#endif
+
+//! Helper metafunction to combine options into a single type to be used
+//! by \c boost::container::segtor.
+//! Supported options are: \c boost::container::block_bytes / \c boost::container::segment_bytes,
+//! \c boost::container::block_size / \c boost::container::segment_size,
+//! \c boost::container::stored_size
+#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
+template<class ...Options>
+struct segtor_options
+   : deque_options<Options...>
+#else
+template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>
+struct segtor_options
+   : deque_options<O1, O2, O3, O4>
+#endif
+{};
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+//! Helper alias metafunction to combine options into a single type to be used
+//! by \c boost::container::segtor.
+template<class ...Options>
+using segtor_options_t = typename boost::container::segtor_options<Options...>::type;
+
+#endif
+
+////////////////////////////////////////////////////////////////
+//
+//
+//          OPTIONS FOR STRING CONTAINER
+//
+//
+////////////////////////////////////////////////////////////////
+
+//! This option specifies the desired number of characters to be hold inline
+//! in the container.
+//!
+//! A value zero represents the default value
+//! (typically 10 chars in 32-bit systems and 22 chars in 64-bit systems).
+//!
+//!\tparam InlineChars An unsigned integer value. Values greater than 127 are not supported
+//!                    duet to the internal data structure design.
+BOOST_INTRUSIVE_OPTION_CONSTANT(inline_chars, std::size_t, InlineChars, inline_chars)
+
+//! Helper metafunction to combine options into a single type to be used
+//! by \c boost::container::string.
+//! Supported options are: \c boost::container::growth_factor and \c boost::container::stored_size
+#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) || defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
+template<class ...Options>
+#else
+template<class O1 = void, class O2 = void, class O3 = void, class O4 = void>
+#endif
+struct string_options
+{
+   /// @cond
+   typedef typename ::boost::intrusive::pack_options
+      < string_null_opt,
+      #if !defined(BOOST_CONTAINER_VARIADIC_TEMPLATES)
+      O1, O2, O3, O4
+      #else
+      Options...
+      #endif
+      >::type packed_options;
+   typedef string_opt< typename packed_options::growth_factor_type
+                     , typename packed_options::stored_size_type
+                     , packed_options::inline_chars
+                     > implementation_defined;
+   /// @endcond
+   typedef implementation_defined type;
+};
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+//! Helper alias metafunction to combine options into a single type to be used
+//! by \c boost::container::string.
+template<class ...Options>
+using string_options_t = typename boost::container::string_options<Options...>::type;
+
+#endif
+
 //!This option specifies the maximum size of a block in bytes: this delimites the number of contiguous elements
-//!that will be allocated by some containers as min(1u, BlockBytes/sizeof(value_type))
+//!that will be allocated by some segmented containers as min(1u, BlockBytes/sizeof(value_type))
 //!A value zero represents the default value.
 //!
 //!\tparam BlockBytes An unsigned integer value.
 BOOST_INTRUSIVE_OPTION_CONSTANT(block_bytes, std::size_t, BlockBytes, block_bytes)
 
-//!This option specifies the size of a block, delimites the number of contiguous elements
-//!that will be allocated by some containersas BlockSize.
-//!For some containers (like deque), a power of two value can improve performance.
+//!An alias for `block_bytes`
+//!
+//!\tparam SegmentBytes An unsigned integer value.
+BOOST_INTRUSIVE_OPTION_CONSTANT(segment_bytes, std::size_t, SegmentBytes, block_bytes)
+
+//!This option specifies the size of a block, delimites the number of contiguous elements (BlockSize)
+//!that will be allocated by segmented containers.
+//!For some containers (like deque/segtor), a power of two value can improve performance.
 //!A value zero represents the default value.
 //!
 //!\tparam BlockBytes An unsigned integer value.
 BOOST_INTRUSIVE_OPTION_CONSTANT(block_size, std::size_t, BlockSize, block_size)
 
+//!An alias for `block_size`
+//!
+//!\tparam SegmentSize An unsigned integer value.
+BOOST_INTRUSIVE_OPTION_CONSTANT(segment_size, std::size_t, SegmentSize, block_size)
+
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
 //!This option specifies if the container has reserve/capacity-like features
 //!
-//!For some containers (like deque) this option might change the internal representation or
+//!For some containers (like deque/segtor) this option might change the internal representation or
 //!behavior so that memory for elements can be allocated in advance in
 //!order to improve performance.
 //!
 //!\tparam Reservable An boolean value.
 BOOST_INTRUSIVE_OPTION_CONSTANT(reservable, bool, Reservable, reservable)
 
+#endif   //   !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+
 }  //namespace container {
 }  //namespace boost {
 

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/global_resource.hpp

@@ -30,13 +30,13 @@ namespace pmr {
 //!   memory_resource that can serve as a resource for allocating memory using
 //!   global `operator new` and global `operator delete`. The same value is returned every time this function
 //!   is called. For return value p and memory resource r, p->is_equal(r) returns &r == p.
-BOOST_CONTAINER_DECL memory_resource* new_delete_resource() BOOST_NOEXCEPT;
+BOOST_CONTAINER_NODISCARD BOOST_CONTAINER_DECL memory_resource* new_delete_resource() BOOST_NOEXCEPT;
 
 //! <b>Returns</b>: A pointer to a static-duration object of a type derived from
 //!   memory_resource for which allocate() always throws bad_alloc and for which
 //!   deallocate() has no effect. The same value is returned every time this function
 //!   is called. For return value p and memory resource r, p->is_equal(r) returns &r == p.
-BOOST_CONTAINER_DECL memory_resource* null_memory_resource() BOOST_NOEXCEPT;
+BOOST_CONTAINER_NODISCARD BOOST_CONTAINER_DECL memory_resource* null_memory_resource() BOOST_NOEXCEPT;
 
 //! <b>Effects</b>: If r is non-null, sets the value of the default memory resource
 //!   pointer to r, otherwise sets the default memory resource pointer to new_delete_resource().
@@ -52,7 +52,7 @@ BOOST_CONTAINER_DECL memory_resource* set_default_resource(memory_resource* r) B
 
 //! <b>Returns</b>: The current value of the default
 //!   memory resource pointer.
-BOOST_CONTAINER_DECL memory_resource* get_default_resource() BOOST_NOEXCEPT;
+BOOST_CONTAINER_NODISCARD BOOST_CONTAINER_DECL memory_resource* get_default_resource() BOOST_NOEXCEPT;
 
 }  //namespace pmr {
 }  //namespace container {

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/hub.hpp

@@ -0,0 +1,43 @@
+/* Hub container.
+ * 
+ * Copyright 2025-2026 Joaquin M Lopez Munoz.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+#ifndef BOOST_CONTAINER_PMR_HUB_HPP
+#define BOOST_CONTAINER_PMR_HUB_HPP
+
+#if defined (_MSC_VER)
+#  pragma once
+#endif
+
+#include <boost/container/hub.hpp>
+#include <boost/container/pmr/polymorphic_allocator.hpp>
+
+namespace boost {
+namespace container {
+namespace pmr {
+
+#if !defined(BOOST_NO_CXX11_TEMPLATE_ALIASES)
+
+template <class T>
+using hub = boost::container::hub<T, polymorphic_allocator<T> >;
+
+#endif
+
+//! A portable metafunction to obtain a hub
+//! that uses a polymorphic allocator.
+template<class T>
+struct hub_of
+{
+   typedef boost::container::hub
+      < T, polymorphic_allocator<T> > type;
+};
+
+}  //namespace pmr {
+}  //namespace container {
+}  //namespace boost {
+
+#endif   //BOOST_CONTAINER_PMR_HUB_HPP

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/memory_resource.hpp

@@ -28,7 +28,7 @@ namespace pmr {
 
 //! The memory_resource class is an abstract interface to an
 //! unbounded set of classes encapsulating memory resources.
-class memory_resource
+class BOOST_CONTAINER_NOVTABLE memory_resource
 {
    public:
    // For exposition only
@@ -41,11 +41,11 @@ class memory_resource
 
    //! <b>Effects</b>: Equivalent to
    //! `return do_allocate(bytes, alignment);`
-   void* allocate(std::size_t bytes, std::size_t alignment = max_align)
+   BOOST_CONTAINER_NODISCARD void* allocate(std::size_t bytes, std::size_t alignment = max_align)
    {  
       //Obtain a pointer to enough storage and initialize the lifetime 
       //of an array object of the given size in the address
-      return ::operator new(bytes, this->do_allocate(bytes, alignment), boost_container_new_t());
+      return ::operator new(bytes, this->do_allocate(bytes, alignment), boost_container_init_life_t());
    }
 
    //! <b>Effects</b>: Equivalent to
@@ -62,11 +62,13 @@ class memory_resource
 
    //! <b>Returns</b>:
    //!   `&a == &b || a.is_equal(b)`.
+   BOOST_CONTAINER_NODISCARD   
    friend bool operator==(const memory_resource& a, const memory_resource& b) BOOST_NOEXCEPT
    {  return &a == &b || a.is_equal(b);   }
 
    //! <b>Returns</b>:
    //!   !(a == b).
+   BOOST_CONTAINER_NODISCARD
    friend bool operator!=(const memory_resource& a, const memory_resource& b) BOOST_NOEXCEPT
    {  return !(a == b); }
    

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/monotonic_buffer_resource.hpp

@@ -112,6 +112,7 @@ class BOOST_CONTAINER_DECL monotonic_buffer_resource
    ~monotonic_buffer_resource() BOOST_OVERRIDE;
 
    //! <b>Effects</b>: `upstream_resource()->deallocate()` as necessary to release all allocated memory.
+   //!   Resets *this to its initial state at construction.
    //!   [Note: memory is released back to `upstream_resource()` even if some blocks that were allocated
    //!   from this have not been deallocated from this. - end note]
    void release() BOOST_NOEXCEPT;

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/polymorphic_allocator.hpp

@@ -78,7 +78,7 @@ class polymorphic_allocator
 
    //! <b>Returns</b>: Equivalent to
    //!   `static_cast<T*>(m_resource->allocate(n * sizeof(T), alignof(T)))`.
-   T* allocate(size_t n)
+   BOOST_CONTAINER_NODISCARD T* allocate(size_t n)
    {  return static_cast<T*>(m_resource->allocate(n*sizeof(T), ::boost::move_detail::alignment_of<T>::value));  }
 
    //! <b>Requires</b>: p was allocated from a memory resource, x, equal to *m_resource,

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/resource_adaptor.hpp

@@ -31,6 +31,8 @@
 namespace boost {
 namespace container {
 
+#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
+
 namespace pmr_dtl {
 
 template<class T>
@@ -53,6 +55,8 @@ struct max_allocator_alignment< std::allocator<T> >
 
 }  //namespace pmr_dtl
 
+#endif   //BOOST_CONTAINER_DOXYGEN_INVOKED
+
 namespace pmr {
 
 //! An instance of resource_adaptor<Allocator> is an adaptor that wraps a memory_resource interface