passenger 5.3.3 → 5.3.4

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

@@ -83,19 +83,19 @@ class adaptive_pool
    typedef T *                                  pointer;
    typedef const T *                            const_pointer;
    typedef typename ::boost::container::
-      container_detail::unvoid_ref<T>::type     reference;
+      dtl::unvoid_ref<T>::type     reference;
    typedef typename ::boost::container::
-      container_detail::unvoid_ref<const T>::type     const_reference;
+      dtl::unvoid_ref<const T>::type     const_reference;
    typedef std::size_t                          size_type;
    typedef std::ptrdiff_t                       difference_type;
 
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       version_type<self_t, Version>             version;
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       basic_multiallocation_chain<void*>              multiallocation_chain_void;
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       transform_multiallocation_chain
          <multiallocation_chain_void, T>              multiallocation_chain;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -156,9 +156,9 @@ class adaptive_pool
          boost::container::throw_bad_alloc();
 
       if(Version == 1 && count == 1){
-         typedef typename container_detail::shared_adaptive_node_pool
+         typedef typename dtl::shared_adaptive_node_pool
             <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
-         typedef container_detail::singleton_default<shared_pool_t> singleton_t;
+         typedef dtl::singleton_default<shared_pool_t> singleton_t;
          return pointer(static_cast<T*>(singleton_t::instance().allocate_node()));
       }
       else{
@@ -172,9 +172,9 @@ class adaptive_pool
    {
       (void)count;
       if(Version == 1 && count == 1){
-         typedef container_detail::shared_adaptive_node_pool
+         typedef dtl::shared_adaptive_node_pool
             <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
-         typedef container_detail::singleton_default<shared_pool_t> singleton_t;
+         typedef dtl::singleton_default<shared_pool_t> singleton_t;
          singleton_t::instance().deallocate_node(ptr);
       }
       else{
@@ -203,9 +203,9 @@ class adaptive_pool
    //!Throws bad_alloc if there is no enough memory
    pointer allocate_one()
    {
-      typedef container_detail::shared_adaptive_node_pool
+      typedef dtl::shared_adaptive_node_pool
          <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
-      typedef container_detail::singleton_default<shared_pool_t> singleton_t;
+      typedef dtl::singleton_default<shared_pool_t> singleton_t;
       return (pointer)singleton_t::instance().allocate_node();
    }
 
@@ -213,9 +213,9 @@ class adaptive_pool
    //!Elements must be individually deallocated with deallocate_one()
    void allocate_individual(std::size_t num_elements, multiallocation_chain &chain)
    {
-      typedef container_detail::shared_adaptive_node_pool
+      typedef dtl::shared_adaptive_node_pool
          <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
-      typedef container_detail::singleton_default<shared_pool_t> singleton_t;
+      typedef dtl::singleton_default<shared_pool_t> singleton_t;
       singleton_t::instance().allocate_nodes(num_elements, static_cast<typename shared_pool_t::multiallocation_chain&>(chain));
       //typename shared_pool_t::multiallocation_chain ch;
       //singleton_t::instance().allocate_nodes(num_elements, ch);
@@ -228,17 +228,17 @@ class adaptive_pool
    //!with other functions different from allocate_one(). Never throws
    void deallocate_one(pointer p) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      typedef container_detail::shared_adaptive_node_pool
+      typedef dtl::shared_adaptive_node_pool
          <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
-      typedef container_detail::singleton_default<shared_pool_t> singleton_t;
+      typedef dtl::singleton_default<shared_pool_t> singleton_t;
       singleton_t::instance().deallocate_node(p);
    }
 
    void deallocate_individual(multiallocation_chain &chain) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      typedef container_detail::shared_adaptive_node_pool
+      typedef dtl::shared_adaptive_node_pool
          <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
-      typedef container_detail::singleton_default<shared_pool_t> singleton_t;
+      typedef dtl::singleton_default<shared_pool_t> singleton_t;
       //typename shared_pool_t::multiallocation_chain ch(&*chain.begin(), &*chain.last(), chain.size());
       //singleton_t::instance().deallocate_nodes(ch);
       singleton_t::instance().deallocate_nodes(chain);
@@ -297,9 +297,9 @@ class adaptive_pool
    //!Deallocates all free blocks of the pool
    static void deallocate_free_blocks() BOOST_NOEXCEPT_OR_NOTHROW
    {
-      typedef container_detail::shared_adaptive_node_pool
+      typedef dtl::shared_adaptive_node_pool
          <sizeof(T), NodesPerBlock, MaxFreeBlocks, OverheadPercent> shared_pool_t;
-      typedef container_detail::singleton_default<shared_pool_t> singleton_t;
+      typedef dtl::singleton_default<shared_pool_t> singleton_t;
       singleton_t::instance().deallocate_free_blocks();
    }
 

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

@@ -49,11 +49,11 @@ class allocator<void, Version, AllocationDisableMask>
    typedef const int &                          const_reference;
    typedef std::size_t                          size_type;
    typedef std::ptrdiff_t                       difference_type;
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       version_type<self_t, Version>             version;
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
          basic_multiallocation_chain<void*>        multiallocation_chain;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -133,14 +133,14 @@ class allocator
    typedef std::size_t                          size_type;
    typedef std::ptrdiff_t                       difference_type;
 
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       version_type<self_t, Version>                version;
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
          basic_multiallocation_chain<void*>        void_multiallocation_chain;
 
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       transform_multiallocation_chain
          <void_multiallocation_chain, T>           multiallocation_chain;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED

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

@@ -50,21 +50,21 @@
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME allocate
-#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace dtl {
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 2
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 2
 #include <boost/intrusive/detail/has_member_function_callable_with.hpp>
 
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME destroy
-#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace dtl {
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 1
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 1
 #include <boost/intrusive/detail/has_member_function_callable_with.hpp>
 
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME construct
-#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace container_detail {
+#define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_BEG namespace boost { namespace container { namespace dtl {
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_NS_END   }}}
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MIN 1
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 9
@@ -87,7 +87,7 @@ BOOST_INTRUSIVE_HAS_STATIC_MEMBER_FUNC_SIGNATURE(has_select_on_container_copy_co
 
 }  //namespace allocator_traits_detail {
 
-namespace container_detail {
+namespace dtl {
 
 //workaround needed for C++03 compilers with no construct()
 //supporting rvalue references
@@ -121,7 +121,7 @@ BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(is_always_equal)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(is_partially_propagable)
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -196,59 +196,59 @@ struct allocator_traits
       {  typedef see_documentation type;  };
    #else
       //pointer
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
          pointer, value_type*)
             pointer;
       //const_pointer
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Allocator,
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::dtl::, Allocator,
          const_pointer, typename boost::intrusive::pointer_traits<pointer>::template
             rebind_pointer<const value_type>)
                const_pointer;
       //reference
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
-         reference, typename container_detail::unvoid_ref<value_type>::type)
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
+         reference, typename dtl::unvoid_ref<value_type>::type)
             reference;
       //const_reference
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
-         const_reference, typename container_detail::unvoid_ref<const value_type>::type)
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
+         const_reference, typename dtl::unvoid_ref<const value_type>::type)
                const_reference;
       //void_pointer
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Allocator,
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::dtl::, Allocator,
          void_pointer, typename boost::intrusive::pointer_traits<pointer>::template
             rebind_pointer<void>)
                void_pointer;
       //const_void_pointer
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::container_detail::, Allocator,
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_EVAL_DEFAULT(boost::container::dtl::, Allocator,
          const_void_pointer, typename boost::intrusive::pointer_traits<pointer>::template
             rebind_pointer<const void>)
                const_void_pointer;
       //difference_type
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
          difference_type, std::ptrdiff_t)
             difference_type;
       //size_type
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
          size_type, std::size_t)
             size_type;
       //propagate_on_container_copy_assignment
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
-         propagate_on_container_copy_assignment, container_detail::false_type)
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
+         propagate_on_container_copy_assignment, dtl::false_type)
             propagate_on_container_copy_assignment;
       //propagate_on_container_move_assignment
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
-         propagate_on_container_move_assignment, container_detail::false_type)
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
+         propagate_on_container_move_assignment, dtl::false_type)
             propagate_on_container_move_assignment;
       //propagate_on_container_swap
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
-         propagate_on_container_swap, container_detail::false_type)
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
+         propagate_on_container_swap, dtl::false_type)
             propagate_on_container_swap;
       //is_always_equal
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
-         is_always_equal, container_detail::is_empty<Allocator>)
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
+         is_always_equal, dtl::is_empty<Allocator>)
             is_always_equal;
       //is_partially_propagable
-      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::container_detail::, Allocator,
-         is_partially_propagable, container_detail::false_type)
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT(boost::container::dtl::, Allocator,
+         is_partially_propagable, dtl::false_type)
             is_partially_propagable;
 
       //rebind_alloc & rebind_traits
@@ -302,10 +302,10 @@ struct allocator_traits
    //! otherwise, invokes <code>a.allocate(n)</code>
    BOOST_CONTAINER_FORCEINLINE static pointer allocate(Allocator &a, size_type n, const_void_pointer p)
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_allocate
             <Allocator, const size_type, const const_void_pointer>::value;
-      container_detail::bool_<value> flag;
+      dtl::bool_<value> flag;
       return allocator_traits::priv_allocate(flag, a, n, p);
    }
 
@@ -315,10 +315,10 @@ struct allocator_traits
    BOOST_CONTAINER_FORCEINLINE static void destroy(Allocator &a, T*p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       typedef T* destroy_pointer;
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_destroy
             <Allocator, const destroy_pointer>::value;
-      container_detail::bool_<value> flag;
+      dtl::bool_<value> flag;
       allocator_traits::priv_destroy(flag, a, p);
    }
 
@@ -327,36 +327,36 @@ struct allocator_traits
    BOOST_CONTAINER_FORCEINLINE static size_type max_size(const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {
       const bool value = allocator_traits_detail::has_max_size<Allocator, size_type (Allocator::*)() const>::value;
-      container_detail::bool_<value> flag;
+      dtl::bool_<value> flag;
       return allocator_traits::priv_max_size(flag, a);
    }
 
    //! <b>Returns</b>: <code>a.select_on_container_copy_construction()</code> if that expression is well-formed;
    //! otherwise, a.
    BOOST_CONTAINER_FORCEINLINE static BOOST_CONTAINER_DOC1ST(Allocator,
-      typename container_detail::if_c
+      typename dtl::if_c
          < allocator_traits_detail::has_select_on_container_copy_construction<Allocator BOOST_MOVE_I Allocator (Allocator::*)() const>::value
          BOOST_MOVE_I Allocator BOOST_MOVE_I const Allocator & >::type)
    select_on_container_copy_construction(const Allocator &a)
    {
       const bool value = allocator_traits_detail::has_select_on_container_copy_construction
          <Allocator, Allocator (Allocator::*)() const>::value;
-      container_detail::bool_<value> flag;
+      dtl::bool_<value> flag;
       return allocator_traits::priv_select_on_container_copy_construction(flag, a);
    }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
       //! <b>Effects</b>: calls <code>a.construct(p, std::forward<Args>(args)...)</code> if that call is well-formed;
-      //! otherwise, invokes <code>::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)</code>
+      //! otherwise, invokes <code>`placement new` (static_cast<void*>(p)) T(std::forward<Args>(args)...)</code>
       template <class T, class ...Args>
       BOOST_CONTAINER_FORCEINLINE static void construct(Allocator & a, T* p, BOOST_FWD_REF(Args)... args)
       {
          static const bool value = ::boost::move_detail::and_
-            < container_detail::is_not_std_allocator<Allocator>
-            , boost::container::container_detail::has_member_function_callable_with_construct
+            < dtl::is_not_std_allocator<Allocator>
+            , boost::container::dtl::has_member_function_callable_with_construct
                   < Allocator, T*, Args... >
             >::value;
-         container_detail::bool_<value> flag;
+         dtl::bool_<value> flag;
          allocator_traits::priv_construct(flag, a, p, ::boost::forward<Args>(args)...);
       }
    #endif
@@ -365,7 +365,7 @@ struct allocator_traits
    //! <code>false</code>.
    BOOST_CONTAINER_FORCEINLINE static bool storage_is_unpropagable(const Allocator &a, pointer p) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      container_detail::bool_<is_partially_propagable::value> flag;
+      dtl::bool_<is_partially_propagable::value> flag;
       return allocator_traits::priv_storage_is_unpropagable(flag, a, p);
    }
 
@@ -373,45 +373,45 @@ struct allocator_traits
    //! <code>a == b</code>.
    BOOST_CONTAINER_FORCEINLINE static bool equal(const Allocator &a, const Allocator &b) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      container_detail::bool_<is_always_equal::value> flag;
+      dtl::bool_<is_always_equal::value> flag;
       return allocator_traits::priv_equal(flag, a, b);
    }
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    private:
-   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(container_detail::true_type, Allocator &a, size_type n, const_void_pointer p)
+   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(dtl::true_type, Allocator &a, size_type n, const_void_pointer p)
    {  return a.allocate(n, p);  }
 
-   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(container_detail::false_type, Allocator &a, size_type n, const_void_pointer)
+   BOOST_CONTAINER_FORCEINLINE static pointer priv_allocate(dtl::false_type, Allocator &a, size_type n, const_void_pointer)
    {  return a.allocate(n);  }
 
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(container_detail::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(dtl::true_type, Allocator &a, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  a.destroy(p);  }
 
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(container_detail::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static void priv_destroy(dtl::false_type, Allocator &, T* p) BOOST_NOEXCEPT_OR_NOTHROW
    {  p->~T(); (void)p;  }
 
-   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(container_detail::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(dtl::true_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a.max_size();  }
 
-   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(container_detail::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static size_type priv_max_size(dtl::false_type, const Allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return size_type(-1)/sizeof(value_type);  }
 
-   BOOST_CONTAINER_FORCEINLINE static Allocator priv_select_on_container_copy_construction(container_detail::true_type, const Allocator &a)
+   BOOST_CONTAINER_FORCEINLINE static Allocator priv_select_on_container_copy_construction(dtl::true_type, const Allocator &a)
    {  return a.select_on_container_copy_construction();  }
 
-   BOOST_CONTAINER_FORCEINLINE static const Allocator &priv_select_on_container_copy_construction(container_detail::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
+   BOOST_CONTAINER_FORCEINLINE static const Allocator &priv_select_on_container_copy_construction(dtl::false_type, const Allocator &a) BOOST_NOEXCEPT_OR_NOTHROW
    {  return a;  }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       template<class T, class ...Args>
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args)
+      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::true_type, Allocator &a, T *p, BOOST_FWD_REF(Args) ...args)
       {  a.construct( p, ::boost::forward<Args>(args)...);  }
 
       template<class T, class ...Args>
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
+      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::false_type, Allocator &, T *p, BOOST_FWD_REF(Args) ...args)
       {  ::new((void*)p, boost_container_new_t()) T(::boost::forward<Args>(args)...); }
    #else // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
       public:
@@ -421,11 +421,11 @@ struct allocator_traits
       BOOST_CONTAINER_FORCEINLINE static void construct(Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {\
          static const bool value = ::boost::move_detail::and_ \
-            < container_detail::is_not_std_allocator<Allocator> \
-            , boost::container::container_detail::has_member_function_callable_with_construct \
+            < dtl::is_not_std_allocator<Allocator> \
+            , boost::container::dtl::has_member_function_callable_with_construct \
                   < Allocator, T* BOOST_MOVE_I##N BOOST_MOVE_FWD_T##N > \
             >::value; \
-         container_detail::bool_<value> flag;\
+         dtl::bool_<value> flag;\
          (priv_construct)(flag, a, p BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       }\
       //
@@ -438,11 +438,11 @@ struct allocator_traits
       /////////////////////////////////
       #define BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL(N) \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::true_type, Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::true_type, Allocator &a, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {  a.construct( p BOOST_MOVE_I##N BOOST_MOVE_FWD##N );  }\
       \
       template<class T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-      BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::false_type, Allocator &, T *p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
       {  ::new((void*)p, boost_container_new_t()) T(BOOST_MOVE_FWD##N); }\
       //
       BOOST_MOVE_ITERATE_0TO8(BOOST_CONTAINER_ALLOCATOR_TRAITS_PRIV_CONSTRUCT_IMPL)
@@ -451,19 +451,19 @@ struct allocator_traits
    #endif   // #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
    template<class T>
-   BOOST_CONTAINER_FORCEINLINE static void priv_construct(container_detail::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
+   BOOST_CONTAINER_FORCEINLINE static void priv_construct(dtl::false_type, Allocator &, T *p, const ::boost::container::default_init_t&)
    {  ::new((void*)p, boost_container_new_t()) T; }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(container_detail::true_type, const Allocator &a, pointer p)
+   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(dtl::true_type, const Allocator &a, pointer p)
    {  return a.storage_is_unpropagable(p);  }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(container_detail::false_type, const Allocator &, pointer)
+   BOOST_CONTAINER_FORCEINLINE static bool priv_storage_is_unpropagable(dtl::false_type, const Allocator &, pointer)
    {  return false;  }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(container_detail::true_type,  const Allocator &, const Allocator &)
+   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(dtl::true_type,  const Allocator &, const Allocator &)
    {  return true;  }
 
-   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(container_detail::false_type, const Allocator &a, const Allocator &b)
+   BOOST_CONTAINER_FORCEINLINE static bool priv_equal(dtl::false_type, const Allocator &a, const Allocator &b)
    {  return a == b;  }
 
    #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)

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

@@ -67,7 +67,7 @@ namespace detail{
    //Create namespace to avoid compilation errors
 }}}
 
-namespace boost{ namespace container{ namespace container_detail{
+namespace boost{ namespace container{ namespace dtl{
    namespace bi = boost::intrusive;
    namespace bid = boost::intrusive::detail;
 }}}
@@ -88,23 +88,14 @@ namespace boost{ namespace container{ namespace pmr{
 namespace boost {
 namespace container {
 
-//! Enumeration used to configure ordered associative containers
-//! with a concrete tree implementation.
-enum tree_type_enum
-{
-   red_black_tree,
-   avl_tree,
-   scapegoat_tree,
-   splay_tree
-};
-
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 template<class T>
 class new_allocator;
 
 template <class T
-         ,class Allocator = new_allocator<T> >
+         ,class Allocator = new_allocator<T>
+         ,class Options = void>
 class vector;
 
 template <class T
@@ -130,35 +121,30 @@ template <class T
          ,class Allocator = new_allocator<T> >
 class slist;
 
-template<tree_type_enum TreeType, bool OptimizeSize>
-struct tree_opt;
-
-typedef tree_opt<red_black_tree, true> tree_assoc_defaults;
-
 template <class Key
          ,class Compare  = std::less<Key>
          ,class Allocator = new_allocator<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void>
 class set;
 
 template <class Key
          ,class Compare  = std::less<Key>
          ,class Allocator = new_allocator<Key>
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 class multiset;
 
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
          ,class Allocator = new_allocator<std::pair<const Key, T> >
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 class map;
 
 template <class Key
          ,class T
          ,class Compare  = std::less<Key>
          ,class Allocator = new_allocator<std::pair<const Key, T> >
-         ,class Options = tree_assoc_defaults >
+         ,class Options = void >
 class multimap;
 
 template <class Key
@@ -246,13 +232,6 @@ class synchronized_pool_resource;
 
 }  //namespace pmr {
 
-#else
-
-//! Default options for tree-based associative containers
-//!   - tree_type<red_black_tree>
-//!   - optimize_size<true>
-typedef implementation_defined tree_assoc_defaults;
-
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 //! Type used to tag that the input range is