Use namespace dtl instead of container_detail to avoid excessively long symbol names.

bench/Jamfile.v2

@@ -21,7 +21,7 @@ rule test_all
 
    for local fileb in [ glob *.cpp ]
    {
-      all_rules += [ run $(fileb) /boost/timer//boost_timer /boost/container//boost_container
+      all_rules += [ run $(fileb) /boost/container//boost_container  /boost/timer//boost_timer
       :  # additional args
       :  # test-files
       :  # requirements

bench/bench_adaptive_node_pool.cpp

@@ -221,28 +221,28 @@ void list_test_template(std::size_t num_iterations, std::size_t num_elements, bo
    }
 
    //Release node_allocator cache
-   typedef boost::container::container_detail::shared_node_pool
+   typedef boost::container::dtl::shared_node_pool
       < (2*sizeof(void*)+sizeof(int))
       , AdPoolAlignOnlyV2::nodes_per_block> shared_node_pool_t;
-   boost::container::container_detail::singleton_default
+   boost::container::dtl::singleton_default
       <shared_node_pool_t>::instance().purge_blocks();
 
    //Release adaptive_pool cache
-   typedef boost::container::container_detail::shared_adaptive_node_pool
+   typedef boost::container::dtl::shared_adaptive_node_pool
       < (2*sizeof(void*)+sizeof(int))
       , AdPool2PercentV2::nodes_per_block
       , AdPool2PercentV2::max_free_blocks
       , AdPool2PercentV2::overhead_percent> shared_adaptive_pool_plus_t;
-   boost::container::container_detail::singleton_default
+   boost::container::dtl::singleton_default
       <shared_adaptive_pool_plus_t>::instance().deallocate_free_blocks();
 
    //Release adaptive_pool cache
-   typedef boost::container::container_detail::shared_adaptive_node_pool
+   typedef boost::container::dtl::shared_adaptive_node_pool
       < (2*sizeof(void*)+sizeof(int))
       , AdPool2PercentV2::nodes_per_block
       , AdPool2PercentV2::max_free_blocks
       , 0u> shared_adaptive_pool_plus_align_only_t;
-   boost::container::container_detail::singleton_default
+   boost::container::dtl::singleton_default
       <shared_adaptive_pool_plus_align_only_t>::instance().deallocate_free_blocks();
    //Release dlmalloc memory
    bc::dlmalloc_trim(0);

bench/bench_alloc_shrink_to_fit.cpp

@@ -84,8 +84,8 @@ void vector_test_template(unsigned int num_iterations, unsigned int num_elements
    timer.resume();
 
    #ifndef NDEBUG
-   typedef bc::container_detail::integral_constant
-      <unsigned, bc::container_detail::version<Allocator>::value> alloc_version;
+   typedef bc::dtl::integral_constant
+      <unsigned, bc::dtl::version<Allocator>::value> alloc_version;
    #endif
 
    for(unsigned int r = 0; r != num_iterations; ++r){

bench/detail/varray.hpp

@@ -50,7 +50,7 @@
  * @defgroup varray_non_member varray non-member functions
  */
 
-namespace boost { namespace container { namespace container_detail {
+namespace boost { namespace container { namespace dtl {
 
 // Forward declaration
 template <typename Value, std::size_t Capacity, typename Strategy>
@@ -220,14 +220,14 @@ struct varray_traits
 template <typename Value, std::size_t Capacity, typename Strategy = strategy::def<Value> >
 class varray
 {
-    typedef container_detail::varray_traits<
+    typedef dtl::varray_traits<
         Value, Capacity, Strategy
     > vt;
 
     typedef typename vt::error_handler errh;
     typedef typename aligned_storage<
         sizeof(Value[Capacity]),
-        boost::container::container_detail::alignment_of<Value[Capacity]>::value
+        boost::container::dtl::alignment_of<Value[Capacity]>::value
     >::type aligned_storage_type;
 
     template <typename V, std::size_t C, typename S>
@@ -2235,7 +2235,7 @@ inline void swap(varray<V, C1, S1> & x, varray<V, C2, S2> & y)
     x.swap(y);
 }
 
-}}} // namespace boost::container::container_detail
+}}} // namespace boost::container::dtl
 
 #include <boost/container/detail/config_end.hpp>
 

bench/detail/varray_concept.hpp

@@ -12,7 +12,7 @@
 
 #include <boost/concept_check.hpp>
 
-namespace boost { namespace container { namespace container_detail { namespace concept {
+namespace boost { namespace container { namespace dtl { namespace concept {
 
 /**
  * VArrayStrategyConcept
@@ -55,6 +55,6 @@ public :
 #endif
 };
 
-}}}} // namespace boost::container::container_detail::concept
+}}}} // namespace boost::container::dtl::concept
 
 #endif //BOOST_CONTAINER_VARRAY_CONCEPT_HPP

bench/detail/varray_util.hpp

@@ -41,10 +41,10 @@
 
 namespace boost { namespace container { namespace varray_detail {
 
-namespace bcd = ::boost::container::container_detail;
+namespace bcd = ::boost::container::dtl;
 
 template <typename I>
-struct are_elements_contiguous : boost::container::container_detail::is_pointer<I>
+struct are_elements_contiguous : boost::container::dtl::is_pointer<I>
 {};
 
 #if defined(BOOST_CONTAINER_VARRAY_ENABLE_VECTORS_OPTIMIZATION) && !defined(BOOST_NO_EXCEPTIONS)
@@ -176,7 +176,7 @@ inline O copy_dispatch(I first, I last, O dst, bcd::true_type const& /*use_memmo
 {
    typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
    const std::size_t d = boost::container::iterator_distance(first, last);
-   ::memmove(boost::container::container_detail::addressof(*dst), boost::container::container_detail::addressof(*first), sizeof(value_type) * d);
+   ::memmove(boost::container::dtl::addressof(*dst), boost::container::dtl::addressof(*first), sizeof(value_type) * d);
    return dst + d;
 }
 
@@ -206,7 +206,7 @@ O uninitialized_copy_dispatch(I first, I last, O dst,
 {
    typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
    const std::size_t d = boost::container::iterator_distance(first, last);
-   ::memcpy(boost::container::container_detail::addressof(*dst), boost::container::container_detail::addressof(*first), sizeof(value_type) * d);
+   ::memcpy(boost::container::dtl::addressof(*dst), boost::container::dtl::addressof(*first), sizeof(value_type) * d);
    return dst + d;
 }
 
@@ -238,7 +238,7 @@ O uninitialized_move_dispatch(I first, I last, O dst,
 {
    typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
    const std::size_t d = boost::container::iterator_distance(first, last);
-   ::memcpy(boost::container::container_detail::addressof(*dst), boost::container::container_detail::addressof(*first), sizeof(value_type) * d);
+   ::memcpy(boost::container::dtl::addressof(*dst), boost::container::dtl::addressof(*first), sizeof(value_type) * d);
    return dst + d;
 }
 
@@ -255,7 +255,7 @@ O uninitialized_move_dispatch(I first, I last, O dst,
     {
         typedef typename boost::container::iterator_traits<O>::value_type value_type;
         for (; first != last; ++first, ++o )
-            new (boost::container::container_detail::addressof(*o)) value_type(boost::move(*first));
+            new (boost::container::dtl::addressof(*o)) value_type(boost::move(*first));
     }
     BOOST_CATCH(...)
     {
@@ -289,7 +289,7 @@ O move_dispatch(I first, I last, O dst,
 {
    typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
    const std::size_t d = boost::container::iterator_distance(first, last);
-   ::memmove(boost::container::container_detail::addressof(*dst), boost::container::container_detail::addressof(*first), sizeof(value_type)*d );
+   ::memmove(boost::container::dtl::addressof(*dst), boost::container::dtl::addressof(*first), sizeof(value_type)*d );
    return dst + d;
 }
 
@@ -322,7 +322,7 @@ BDO move_backward_dispatch(BDI first, BDI last, BDO dst,
     typedef typename ::boost::container::iterator_traits<BDI>::value_type value_type;
     const std::size_t d = boost::container::iterator_distance(first, last);
     BDO foo(dst - d);
-    ::memmove(boost::container::container_detail::addressof(*foo), boost::container::container_detail::addressof(*first), sizeof(value_type) * d);
+    ::memmove(boost::container::dtl::addressof(*foo), boost::container::dtl::addressof(*first), sizeof(value_type) * d);
     return foo;
 }
 
@@ -419,7 +419,7 @@ void uninitialized_fill_dispatch(I first, I last,
 {
     typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
     for ( ; first != last ; ++first )
-        new (boost::container::container_detail::addressof(*first)) value_type();
+        new (boost::container::dtl::addressof(*first)) value_type();
 }
 
 template <typename I, typename DisableTrivialInit>
@@ -434,7 +434,7 @@ void uninitialized_fill_dispatch(I first, I last,
     BOOST_TRY
     {
         for ( ; it != last ; ++it )
-            new (boost::container::container_detail::addressof(*it)) value_type();                           // may throw
+            new (boost::container::dtl::addressof(*it)) value_type();                           // may throw
     }
     BOOST_CATCH(...)
     {
@@ -466,7 +466,7 @@ inline
 void construct_dispatch(bcd::false_type const& /*dont_init*/, I pos)
 {
     typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
-    new (static_cast<void*>(::boost::container::container_detail::addressof(*pos))) value_type();                      // may throw
+    new (static_cast<void*>(::boost::container::dtl::addressof(*pos))) value_type();                      // may throw
 }
 
 template <typename DisableTrivialInit, typename I>
@@ -487,7 +487,7 @@ template <typename I, typename V>
 inline
 void construct_dispatch(I pos, V const& v, bcd::true_type const& /*use_memcpy*/)
 {
-    ::memcpy(boost::container::container_detail::addressof(*pos), boost::container::container_detail::addressof(v), sizeof(V));
+    ::memcpy(boost::container::dtl::addressof(*pos), boost::container::dtl::addressof(v), sizeof(V));
 }
 
 template <typename I, typename P>
@@ -496,7 +496,7 @@ void construct_dispatch(I pos, P const& p,
                         bcd::false_type const& /*use_memcpy*/)
 {
     typedef typename ::boost::container::iterator_traits<I>::value_type V;
-    new (static_cast<void*>(boost::container::container_detail::addressof(*pos))) V(p);                      // may throw
+    new (static_cast<void*>(boost::container::dtl::addressof(*pos))) V(p);                      // may throw
 }
 
 template <typename DisableTrivialInit, typename I, typename P>
@@ -517,7 +517,7 @@ inline
 void construct(DisableTrivialInit const&, I pos, BOOST_RV_REF(P) p)
 {
     typedef typename ::boost::container::iterator_traits<I>::value_type V;
-    new (static_cast<void*>(boost::container::container_detail::addressof(*pos))) V(::boost::move(p));                      // may throw
+    new (static_cast<void*>(boost::container::dtl::addressof(*pos))) V(::boost::move(p));                      // may throw
 }
 
 // Needed by emplace_back() and emplace()
@@ -532,7 +532,7 @@ void construct(DisableTrivialInit const&,
                BOOST_FWD_REF(Args) ...args)
 {
     typedef typename ::boost::container::iterator_traits<I>::value_type V;
-    new (static_cast<void*>(boost::container::container_detail::addressof(*pos))) V(::boost::forward<Args>(args)...);    // may throw
+    new (static_cast<void*>(boost::container::dtl::addressof(*pos))) V(::boost::forward<Args>(args)...);    // may throw
 }
 
 #else // !BOOST_NO_CXX11_VARIADIC_TEMPLATES
@@ -546,7 +546,7 @@ template <typename DisableTrivialInit, typename I, typename P BOOST_MOVE_I##N BO
 inline void construct(DisableTrivialInit const&, I pos, BOOST_FWD_REF(P) p BOOST_MOVE_I##N BOOST_MOVE_UREF##N )\
 {\
     typedef typename ::boost::container::iterator_traits<I>::value_type V;\
-    new (static_cast<void*>(boost::container::container_detail::addressof(*pos)))\
+    new (static_cast<void*>(boost::container::dtl::addressof(*pos)))\
     V(::boost::forward<P>(p) BOOST_MOVE_I##N BOOST_MOVE_FWD##N); /*may throw*/\
 }
 BOOST_MOVE_ITERATE_1TO9(BOOST_CONTAINER_VARRAY_UTIL_CONSTRUCT_CODE)
@@ -562,7 +562,7 @@ inline
 void assign_dispatch(I pos, V const& v,
                      bcd::true_type const& /*use_memcpy*/)
 {
-    ::memcpy(boost::container::container_detail::addressof(*pos), boost::container::container_detail::addressof(v), sizeof(V));
+    ::memcpy(boost::container::dtl::addressof(*pos), boost::container::dtl::addressof(v), sizeof(V));
 }
 
 template <typename I, typename V>

bench/varray.hpp

@@ -54,9 +54,9 @@ namespace boost { namespace container {
  */
 template <typename Value, std::size_t Capacity>
 class varray
-    : public container_detail::varray<Value, Capacity>
+    : public dtl::varray<Value, Capacity>
 {
-    typedef container_detail::varray<Value, Capacity> base_t;
+    typedef dtl::varray<Value, Capacity> base_t;
 
     BOOST_COPYABLE_AND_MOVABLE(varray)
 
@@ -238,7 +238,7 @@ public:
     //!   Linear O(N).
     template <std::size_t C>
     varray(BOOST_RV_REF_2_TEMPL_ARGS(varray, value_type, C) other)
-        : base_t(boost::move(static_cast<container_detail::varray<value_type, C>&>(other)))
+        : base_t(boost::move(static_cast<dtl::varray<value_type, C>&>(other)))
     {}
 
     //! @brief Move assignment. Moves Values stored in the other varray to this one.
@@ -272,7 +272,7 @@ public:
     template <std::size_t C>
     varray & operator=(BOOST_RV_REF_2_TEMPL_ARGS(varray, value_type, C) other)
     {
-        base_t::operator=(boost::move(static_cast<container_detail::varray<value_type, C>&>(other)));
+        base_t::operator=(boost::move(static_cast<dtl::varray<value_type, C>&>(other)));
         return *this;
     }
 

example/Jamfile.v2

@@ -21,7 +21,7 @@ rule test_all
 
    for local fileb in [ glob doc_*.cpp ]
    {
-      all_rules += [ run $(fileb)  /boost/container//boost_container /boost/timer//boost_timer
+      all_rules += [ run $(fileb)  /boost/container//boost_container
       :  # additional args
       :  # test-files
       :  # requirements

include/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();
    }
 

include/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

include/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,21 +327,21 @@ 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);
    }
 
@@ -352,11 +352,11 @@ struct allocator_traits
       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)

include/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;
 }}}

include/boost/container/deque.hpp

@@ -68,7 +68,7 @@ template <class T>
 struct deque_value_traits
 {
    typedef T value_type;
-   static const bool trivial_dctr = container_detail::is_trivially_destructible<value_type>::value;
+   static const bool trivial_dctr = dtl::is_trivially_destructible<value_type>::value;
    static const bool trivial_dctr_after_move = ::boost::has_trivial_destructor_after_move<value_type>::value;
 };
 
@@ -82,7 +82,7 @@ struct deque_buf_size
    static const std::size_t value    = sizeof_t < min_size ? (min_size/sizeof_t) : std::size_t(1);
 };
 
-namespace container_detail {
+namespace dtl {
 
 // Class invariants:
 //  For any nonsingular iterator i:
@@ -273,7 +273,7 @@ class deque_iterator
       {  return x += n;  }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 // Deque base class.  It has two purposes.  First, its constructor
 //  and destructor allocate (but don't initialize) storage.  This makes
@@ -323,8 +323,8 @@ class deque_base
    void priv_deallocate_map(ptr_alloc_ptr p, size_type n) BOOST_NOEXCEPT_OR_NOTHROW
       { this->ptr_alloc().deallocate(p, n); }
 
-   typedef container_detail::deque_iterator<val_alloc_ptr, false> iterator;
-   typedef container_detail::deque_iterator<val_alloc_ptr, true > const_iterator;
+   typedef dtl::deque_iterator<val_alloc_ptr, false> iterator;
+   typedef dtl::deque_iterator<val_alloc_ptr, true > const_iterator;
 
    deque_base(size_type num_elements, const allocator_type& a)
       :  members_(a)
@@ -369,7 +369,7 @@ class deque_base
 //      if(num_elements){
          size_type num_nodes = num_elements / s_buffer_size() + 1;
 
-         this->members_.m_map_size = container_detail::max_value((size_type) InitialMapSize, num_nodes + 2);
+         this->members_.m_map_size = dtl::max_value((size_type) InitialMapSize, num_nodes + 2);
          this->members_.m_map = this->priv_allocate_map(this->members_.m_map_size);
 
          ptr_alloc_ptr nstart = this->members_.m_map + (this->members_.m_map_size - num_nodes) / 2;
@@ -535,7 +535,7 @@ class deque : protected deque_base<Allocator>
    //! <b>Throws</b>: If allocator_type's default constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   deque() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+   deque() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : Base()
    {}
 
@@ -558,7 +558,7 @@ class deque : protected deque_base<Allocator>
    explicit deque(size_type n)
       : Base(n, allocator_type())
    {
-      container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy;
+      dtl::insert_value_initialized_n_proxy<Allocator, iterator> proxy;
       proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
       //deque_base will deallocate in case of exception...
    }
@@ -575,7 +575,7 @@ class deque : protected deque_base<Allocator>
    deque(size_type n, default_init_t)
       : Base(n, allocator_type())
    {
-      container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy;
+      dtl::insert_default_initialized_n_proxy<Allocator, iterator> proxy;
       proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
       //deque_base will deallocate in case of exception...
    }
@@ -590,7 +590,7 @@ class deque : protected deque_base<Allocator>
    explicit deque(size_type n, const allocator_type &a)
       : Base(n, a)
    {
-      container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy;
+      dtl::insert_value_initialized_n_proxy<Allocator, iterator> proxy;
       proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
       //deque_base will deallocate in case of exception...
    }
@@ -607,7 +607,7 @@ class deque : protected deque_base<Allocator>
    deque(size_type n, default_init_t, const allocator_type &a)
       : Base(n, a)
    {
-      container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy;
+      dtl::insert_default_initialized_n_proxy<Allocator, iterator> proxy;
       proxy.uninitialized_copy_n_and_update(this->alloc(), this->begin(), n);
       //deque_base will deallocate in case of exception...
    }
@@ -644,7 +644,7 @@ class deque : protected deque_base<Allocator>
    template <class InIt>
    deque(InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_convertible
+      , typename dtl::disable_if_convertible
          <InIt, size_type>::type * = 0
       #endif
       )
@@ -663,7 +663,7 @@ class deque : protected deque_base<Allocator>
    template <class InIt>
    deque(InIt first, InIt last, const allocator_type& a
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_convertible
+      , typename dtl::disable_if_convertible
          <InIt, size_type>::type * = 0
       #endif
       )
@@ -776,14 +776,14 @@ class deque : protected deque_base<Allocator>
       if (&x != this){
          allocator_type &this_alloc     = this->alloc();
          const allocator_type &x_alloc  = x.alloc();
-         container_detail::bool_<allocator_traits_type::
+         dtl::bool_<allocator_traits_type::
             propagate_on_container_copy_assignment::value> flag;
          if(flag && this_alloc != x_alloc){
             this->clear();
             this->shrink_to_fit();
          }
-         container_detail::assign_alloc(this->alloc(), x.alloc(), flag);
-         container_detail::assign_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
+         dtl::assign_alloc(this->alloc(), x.alloc(), flag);
+         dtl::assign_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
          this->assign(x.cbegin(), x.cend());
       }
       return *this;
@@ -806,7 +806,7 @@ class deque : protected deque_base<Allocator>
       allocator_type &x_alloc    = x.alloc();
       const bool propagate_alloc = allocator_traits_type::
             propagate_on_container_move_assignment::value;
-      container_detail::bool_<propagate_alloc> flag;
+      dtl::bool_<propagate_alloc> flag;
       const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
       //Resources can be transferred if both allocators are
       //going to be equal after this function (either propagated or already equal)
@@ -814,8 +814,8 @@ class deque : protected deque_base<Allocator>
          //Destroy objects but retain memory in case x reuses it in the future
          this->clear();
          //Move allocator if needed
-         container_detail::move_alloc(this_alloc, x_alloc, flag);
-         container_detail::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
+         dtl::move_alloc(this_alloc, x_alloc, flag);
+         dtl::move_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
          //Nothrow swap
          this->swap_members(x);
       }
@@ -863,10 +863,10 @@ class deque : protected deque_base<Allocator>
    template <class InIt>
    void assign(InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<InIt, size_type>
-         , container_detail::is_not_input_iterator<InIt>
+         , dtl::is_convertible<InIt, size_type>
+         , dtl::is_not_input_iterator<InIt>
          >::type * = 0
       #endif
       )
@@ -886,10 +886,10 @@ class deque : protected deque_base<Allocator>
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
    void assign(FwdIt first, FwdIt last
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<FwdIt, size_type>
-         , container_detail::is_input_iterator<FwdIt>
+         , dtl::is_convertible<FwdIt, size_type>
+         , dtl::is_input_iterator<FwdIt>
          >::type * = 0
       )
    {
@@ -1096,7 +1096,7 @@ class deque : protected deque_base<Allocator>
          this->priv_erase_last_n(len - new_size);
       else{
          const size_type n = new_size - this->size();
-         container_detail::insert_value_initialized_n_proxy<Allocator, iterator> proxy;
+         dtl::insert_value_initialized_n_proxy<Allocator, iterator> proxy;
          priv_insert_back_aux_impl(n, proxy);
       }
    }
@@ -1116,7 +1116,7 @@ class deque : protected deque_base<Allocator>
          this->priv_erase_last_n(len - new_size);
       else{
          const size_type n = new_size - this->size();
-         container_detail::insert_default_initialized_n_proxy<Allocator, iterator> proxy;
+         dtl::insert_default_initialized_n_proxy<Allocator, iterator> proxy;
          priv_insert_back_aux_impl(n, proxy);
       }
    }
@@ -1366,7 +1366,7 @@ class deque : protected deque_base<Allocator>
          return r;
       }
       else{
-         typedef container_detail::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type;
+         typedef dtl::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type;
          return *this->priv_insert_front_aux_impl(1, type(boost::forward<Args>(args)...));
       }
    }
@@ -1392,7 +1392,7 @@ class deque : protected deque_base<Allocator>
          return r;
       }
       else{
-         typedef container_detail::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type;
+         typedef dtl::insert_nonmovable_emplace_proxy<Allocator, iterator, Args...> type;
          return *this->priv_insert_back_aux_impl(1, type(boost::forward<Args>(args)...));
       }
    }
@@ -1419,7 +1419,7 @@ class deque : protected deque_base<Allocator>
          return (this->end()-1);
       }
       else{
-         typedef container_detail::insert_emplace_proxy<Allocator, iterator, Args...> type;
+         typedef dtl::insert_emplace_proxy<Allocator, iterator, Args...> type;
          return this->priv_insert_aux_impl(p, 1, type(boost::forward<Args>(args)...));
       }
    }
@@ -1438,7 +1438,7 @@ class deque : protected deque_base<Allocator>
          return r;\
       }\
       else{\
-         typedef container_detail::insert_nonmovable_emplace_proxy##N\
+         typedef dtl::insert_nonmovable_emplace_proxy##N\
                <Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
          return *priv_insert_front_aux_impl(1, type(BOOST_MOVE_FWD##N));\
       }\
@@ -1455,7 +1455,7 @@ class deque : protected deque_base<Allocator>
          return r;\
       }\
       else{\
-         typedef container_detail::insert_nonmovable_emplace_proxy##N\
+         typedef dtl::insert_nonmovable_emplace_proxy##N\
                <Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
          return *priv_insert_back_aux_impl(1, type(BOOST_MOVE_FWD##N));\
       }\
@@ -1474,7 +1474,7 @@ class deque : protected deque_base<Allocator>
          return (--this->end());\
       }\
       else{\
-         typedef container_detail::insert_emplace_proxy_arg##N\
+         typedef dtl::insert_emplace_proxy_arg##N\
                <Allocator, iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
          return this->priv_insert_aux_impl(p, 1, type(BOOST_MOVE_FWD##N));\
       }\
@@ -1583,10 +1583,10 @@ class deque : protected deque_base<Allocator>
    template <class InIt>
    iterator insert(const_iterator pos, InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<InIt, size_type>
-         , container_detail::is_not_input_iterator<InIt>
+         , dtl::is_convertible<InIt, size_type>
+         , dtl::is_not_input_iterator<InIt>
          >::type * = 0
       #endif
       )
@@ -1624,16 +1624,16 @@ class deque : protected deque_base<Allocator>
    template <class FwdIt>
    iterator insert(const_iterator p, FwdIt first, FwdIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<FwdIt, size_type>
-         , container_detail::is_input_iterator<FwdIt>
+         , dtl::is_convertible<FwdIt, size_type>
+         , dtl::is_input_iterator<FwdIt>
          >::type * = 0
       #endif
       )
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      container_detail::insert_range_proxy<Allocator, FwdIt, iterator> proxy(first);
+      dtl::insert_range_proxy<Allocator, FwdIt, iterator> proxy(first);
       return priv_insert_aux_impl(p, boost::container::iterator_distance(first, last), proxy);
    }
    #endif
@@ -1748,9 +1748,9 @@ class deque : protected deque_base<Allocator>
                                || allocator_traits_type::is_always_equal::value)
    {
       this->swap_members(x);
-      container_detail::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
-      container_detail::swap_alloc(this->alloc(), x.alloc(), flag);
-      container_detail::swap_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
+      dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
+      dtl::swap_alloc(this->alloc(), x.alloc(), flag);
+      dtl::swap_alloc(this->ptr_alloc(), x.ptr_alloc(), flag);
    }
 
    //! <b>Effects</b>: Erases all the elements of the deque.
@@ -1874,7 +1874,7 @@ class deque : protected deque_base<Allocator>
       else {
          return priv_insert_aux_impl
             ( p, (size_type)1
-            , container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
+            , dtl::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
       }
    }
 
@@ -1889,7 +1889,7 @@ class deque : protected deque_base<Allocator>
       else{
          priv_insert_aux_impl
             ( this->cbegin(), (size_type)1
-            , container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
+            , dtl::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
       }
    }
 
@@ -1904,7 +1904,7 @@ class deque : protected deque_base<Allocator>
       else{
          priv_insert_aux_impl
             ( this->cend(), (size_type)1
-            , container_detail::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
+            , dtl::get_insert_value_proxy<iterator, Allocator>(::boost::forward<U>(x)));
       }
    }
 
@@ -2220,7 +2220,7 @@ class deque : protected deque_base<Allocator>
       }
       else {
          size_type new_map_size =
-            this->members_.m_map_size + container_detail::max_value(this->members_.m_map_size, nodes_to_add) + 2;
+            this->members_.m_map_size + dtl::max_value(this->members_.m_map_size, nodes_to_add) + 2;
 
          index_pointer new_map = this->priv_allocate_map(new_map_size);
          new_nstart = new_map + (new_map_size - new_num_nodes) / 2

include/boost/container/detail/adaptive_node_pool.hpp

@@ -37,12 +37,12 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<bool AlignOnly>
 struct select_private_adaptive_node_pool_impl
 {
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
          private_adaptive_node_pool_impl
             < fake_segment_manager
             , unsigned(AlignOnly)*::boost::container::adaptive_pool_flag::align_only
@@ -157,7 +157,7 @@ class shared_adaptive_node_pool
    default_mutex mutex_;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/adaptive_node_pool_impl.hpp

@@ -55,7 +55,7 @@ static const unsigned int address_ordered = 1u << 2u;
 
 }  //namespace adaptive_pool_flag{
 
-namespace container_detail {
+namespace dtl {
 
 template<class size_type>
 struct hdr_offset_holder_t
@@ -876,7 +876,7 @@ class private_adaptive_node_pool_impl
    size_type                           m_totally_free_blocks;  //Free blocks
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/addressof.hpp

@@ -22,7 +22,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template <typename T>
 BOOST_CONTAINER_FORCEINLINE T* addressof(T& obj)
@@ -34,7 +34,7 @@ BOOST_CONTAINER_FORCEINLINE T* addressof(T& obj)
    )));
 }
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/advanced_insert_int.hpp

@@ -41,7 +41,7 @@
 #include <boost/assert.hpp>
 #include <boost/core/no_exceptions_support.hpp>
 
-namespace boost { namespace container { namespace container_detail {
+namespace boost { namespace container { namespace dtl {
 
 template<class Allocator, class FwdIt, class Iterator>
 struct move_insert_range_proxy
@@ -208,7 +208,7 @@ insert_copy_proxy<Allocator, It> get_insert_value_proxy(const typename boost::co
    return insert_copy_proxy<Allocator, It>(v);
 }
 
-}}}   //namespace boost { namespace container { namespace container_detail {
+}}}   //namespace boost { namespace container { namespace dtl {
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
@@ -217,7 +217,7 @@ insert_copy_proxy<Allocator, It> get_insert_value_proxy(const typename boost::co
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class Allocator, class Iterator, class ...Args>
 struct insert_nonmovable_emplace_proxy
@@ -301,7 +301,7 @@ struct insert_emplace_proxy<Allocator, Iterator, typename boost::container::allo
 //Any problem is solvable with an extra layer of indirection? ;-)
 template<class Allocator, class Iterator>
 struct insert_emplace_proxy<Allocator, Iterator
-   , typename boost::container::container_detail::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type
+   , typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type
    >
    : public insert_copy_proxy<Allocator, Iterator>
 {
@@ -321,7 +321,7 @@ struct insert_emplace_proxy<Allocator, Iterator, typename boost::container::allo
 
 template<class Allocator, class Iterator>
 struct insert_emplace_proxy<Allocator, Iterator
-   , typename boost::container::container_detail::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type &
+   , typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type &
    >
    : public insert_copy_proxy<Allocator, Iterator>
 {
@@ -330,7 +330,7 @@ struct insert_emplace_proxy<Allocator, Iterator
    {}
 };
 
-}}}   //namespace boost { namespace container { namespace container_detail {
+}}}   //namespace boost { namespace container { namespace dtl {
 
 #else // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
@@ -338,7 +338,7 @@ struct insert_emplace_proxy<Allocator, Iterator
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 #define BOOST_CONTAINER_ADVANCED_INSERT_INT_CODE(N) \
 template< class Allocator, class Iterator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
@@ -437,7 +437,7 @@ struct insert_emplace_proxy_arg1<Allocator, Iterator, typename boost::container:
 //Any problem is solvable with an extra layer of indirection? ;-)
 template<class Allocator, class Iterator>
 struct insert_emplace_proxy_arg1<Allocator, Iterator
-   , typename boost::container::container_detail::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type
+   , typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type
    >
    : public insert_copy_proxy<Allocator, Iterator>
 {
@@ -457,7 +457,7 @@ struct insert_emplace_proxy_arg1<Allocator, Iterator, typename boost::container:
 
 template<class Allocator, class Iterator>
 struct insert_emplace_proxy_arg1<Allocator, Iterator
-   , typename boost::container::container_detail::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type &
+   , typename boost::container::dtl::add_const<typename boost::container::allocator_traits<Allocator>::value_type>::type &
    >
    : public insert_copy_proxy<Allocator, Iterator>
 {
@@ -468,7 +468,7 @@ struct insert_emplace_proxy_arg1<Allocator, Iterator
 
 #endif
 
-}}}   //namespace boost { namespace container { namespace container_detail {
+}}}   //namespace boost { namespace container { namespace dtl {
 
 #endif   // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 

include/boost/container/detail/alloc_helpers.hpp

@@ -24,36 +24,36 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class AllocatorType>
-inline void swap_alloc(AllocatorType &, AllocatorType &, container_detail::false_type)
+inline void swap_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-inline void swap_alloc(AllocatorType &l, AllocatorType &r, container_detail::true_type)
+inline void swap_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  boost::adl_move_swap(l, r);   }
 
 template<class AllocatorType>
-inline void assign_alloc(AllocatorType &, const AllocatorType &, container_detail::false_type)
+inline void assign_alloc(AllocatorType &, const AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-inline void assign_alloc(AllocatorType &l, const AllocatorType &r, container_detail::true_type)
+inline void assign_alloc(AllocatorType &l, const AllocatorType &r, dtl::true_type)
 {  l = r;   }
 
 template<class AllocatorType>
-inline void move_alloc(AllocatorType &, AllocatorType &, container_detail::false_type)
+inline void move_alloc(AllocatorType &, AllocatorType &, dtl::false_type)
    BOOST_NOEXCEPT_OR_NOTHROW
 {}
 
 template<class AllocatorType>
-inline void move_alloc(AllocatorType &l, AllocatorType &r, container_detail::true_type)
+inline void move_alloc(AllocatorType &l, AllocatorType &r, dtl::true_type)
 {  l = ::boost::move(r);   }
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/allocator_version_traits.hpp

@@ -33,12 +33,12 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
-template<class Allocator, unsigned Version = boost::container::container_detail::version<Allocator>::value>
+template<class Allocator, unsigned Version = boost::container::dtl::version<Allocator>::value>
 struct allocator_version_traits
 {
-   typedef ::boost::container::container_detail::integral_constant
+   typedef ::boost::container::dtl::integral_constant
       <unsigned, Version> alloc_version;
 
    typedef typename Allocator::multiallocation_chain multiallocation_chain;
@@ -67,7 +67,7 @@ struct allocator_version_traits
 template<class Allocator>
 struct allocator_version_traits<Allocator, 1>
 {
-   typedef ::boost::container::container_detail::integral_constant
+   typedef ::boost::container::dtl::integral_constant
       <unsigned, 1> alloc_version;
 
    typedef typename boost::container::allocator_traits<Allocator>::pointer    pointer;
@@ -76,9 +76,9 @@ struct allocator_version_traits<Allocator, 1>
 
    typedef typename boost::intrusive::pointer_traits<pointer>::
          template rebind_pointer<void>::type                void_ptr;
-   typedef container_detail::basic_multiallocation_chain
+   typedef dtl::basic_multiallocation_chain
       <void_ptr>                                            multialloc_cached_counted;
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       transform_multiallocation_chain
          < multialloc_cached_counted, value_type>           multiallocation_chain;
 
@@ -153,7 +153,7 @@ struct allocator_version_traits<Allocator, 1>
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/construct_in_place.hpp

@@ -67,7 +67,7 @@ BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, InpIt source)
 template<class DstIt, class U, class D>
 BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, value_init_construct_iterator<U, D>)
 {
-   container_detail::value_init<U> val;
+   dtl::value_init<U> val;
    *dest = boost::move(val.get());
 }
 

include/boost/container/detail/container_or_allocator_rebind.hpp

@@ -24,7 +24,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class AllocatorOrContainer, class ToType, bool = is_container<AllocatorOrContainer>::value>
 struct container_or_allocator_rebind_impl
@@ -42,7 +42,7 @@ struct container_or_allocator_rebind
    : container_or_allocator_rebind_impl<AllocatorOrContainer, ToType>
 {};
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/container_rebind.hpp

@@ -23,7 +23,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
    template <class Cont, class U>
    struct container_rebind;
@@ -251,7 +251,7 @@ namespace container_detail {
 
 #endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/copy_move_algo.hpp

@@ -38,7 +38,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class I>
 struct are_elements_contiguous
@@ -75,7 +75,7 @@ class vector_iterator;
 template<class Pointer>
 class vector_const_iterator;
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 
 namespace interprocess {
@@ -87,20 +87,20 @@ class offset_ptr;
 
 namespace container {
 
-namespace container_detail {
+namespace dtl {
 
 /////////////////////////
 //vector_[const_]iterator
 /////////////////////////
 
 template<class Pointer>
-struct are_elements_contiguous<boost::container::container_detail::vector_iterator<Pointer> >
+struct are_elements_contiguous<boost::container::dtl::vector_iterator<Pointer> >
 {
    static const bool value = true;
 };
 
 template<class Pointer>
-struct are_elements_contiguous<boost::container::container_detail::vector_const_iterator<Pointer> >
+struct are_elements_contiguous<boost::container::dtl::vector_const_iterator<Pointer> >
 {
    static const bool value = true;
 };
@@ -130,7 +130,7 @@ template <typename I, typename O>
 struct is_memtransfer_copy_assignable
    : boost::move_detail::and_
       < are_contiguous_and_same<I, O>
-      , container_detail::is_trivially_copy_assignable< typename ::boost::container::iterator_traits<I>::value_type >
+      , dtl::is_trivially_copy_assignable< typename ::boost::container::iterator_traits<I>::value_type >
       >
 {};
 
@@ -138,28 +138,28 @@ template <typename I, typename O>
 struct is_memtransfer_copy_constructible
    : boost::move_detail::and_
       < are_contiguous_and_same<I, O>
-      , container_detail::is_trivially_copy_constructible< typename ::boost::container::iterator_traits<I>::value_type >
+      , dtl::is_trivially_copy_constructible< typename ::boost::container::iterator_traits<I>::value_type >
       >
 {};
 
 template <typename I, typename O, typename R>
 struct enable_if_memtransfer_copy_constructible
-   : enable_if<container_detail::is_memtransfer_copy_constructible<I, O>, R>
+   : enable_if<dtl::is_memtransfer_copy_constructible<I, O>, R>
 {};
 
 template <typename I, typename O, typename R>
 struct disable_if_memtransfer_copy_constructible
-   : disable_if<container_detail::is_memtransfer_copy_constructible<I, O>, R>
+   : disable_if<dtl::is_memtransfer_copy_constructible<I, O>, R>
 {};
 
 template <typename I, typename O, typename R>
 struct enable_if_memtransfer_copy_assignable
-   : enable_if<container_detail::is_memtransfer_copy_assignable<I, O>, R>
+   : enable_if<dtl::is_memtransfer_copy_assignable<I, O>, R>
 {};
 
 template <typename I, typename O, typename R>
 struct disable_if_memtransfer_copy_assignable
-   : disable_if<container_detail::is_memtransfer_copy_assignable<I, O>, R>
+   : disable_if<dtl::is_memtransfer_copy_assignable<I, O>, R>
 {};
 
 template
@@ -224,44 +224,44 @@ struct is_memzero_initializable
 {
    typedef typename ::boost::container::iterator_traits<O>::value_type value_type;
    static const bool value = are_elements_contiguous<O>::value &&
-      (  container_detail::is_integral<value_type>::value || container_detail::is_enum<value_type>::value
+      (  dtl::is_integral<value_type>::value || dtl::is_enum<value_type>::value
       #if defined(BOOST_CONTAINER_MEMZEROED_POINTER_IS_NULL)
-      || container_detail::is_pointer<value_type>::value
+      || dtl::is_pointer<value_type>::value
       #endif
       #if defined(BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_ZERO)
-      || container_detail::is_floating_point<value_type>::value
+      || dtl::is_floating_point<value_type>::value
       #endif
       #if defined(BOOST_CONTAINER_MEMZEROED_FLOATING_POINT_IS_ZERO) && defined(BOOST_CONTAINER_MEMZEROED_POINTER_IS_NULL)
-      || container_detail::is_pod<value_type>::value
+      || dtl::is_pod<value_type>::value
       #endif
       );
 };
 
 template <typename O, typename R>
 struct enable_if_memzero_initializable
-   : enable_if_c<container_detail::is_memzero_initializable<O>::value, R>
+   : enable_if_c<dtl::is_memzero_initializable<O>::value, R>
 {};
 
 template <typename O, typename R>
 struct disable_if_memzero_initializable
-   : enable_if_c<!container_detail::is_memzero_initializable<O>::value, R>
+   : enable_if_c<!dtl::is_memzero_initializable<O>::value, R>
 {};
 
 template <typename I, typename R>
 struct enable_if_trivially_destructible
-   : enable_if_c < container_detail::is_trivially_destructible
+   : enable_if_c < dtl::is_trivially_destructible
                   <typename boost::container::iterator_traits<I>::value_type>::value
                , R>
 {};
 
 template <typename I, typename R>
 struct disable_if_trivially_destructible
-   : enable_if_c <!container_detail::is_trivially_destructible
+   : enable_if_c <!dtl::is_trivially_destructible
                   <typename boost::container::iterator_traits<I>::value_type>::value
                , R>
 {};
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -281,7 +281,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_move_alloc(Allocator &a, I f, I l, F r)
 {
    F back = r;
@@ -305,9 +305,9 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_move_alloc(Allocator &, I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove(f, l, r); }
+{  return dtl::memmove(f, l, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -326,7 +326,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_move_alloc_n(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
@@ -350,9 +350,9 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_move_alloc_n(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n(f, n, r); }
+{  return dtl::memmove_n(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -371,7 +371,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, I>::type
+inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
    uninitialized_move_alloc_n_source(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
@@ -395,9 +395,9 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
    uninitialized_move_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n_source(f, n, r); }
+{  return dtl::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -416,7 +416,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_copy_alloc(Allocator &a, I f, I l, F r)
 {
    F back = r;
@@ -440,9 +440,9 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_copy_alloc(Allocator &, I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove(f, l, r); }
+{  return dtl::memmove(f, l, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -461,7 +461,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_copy_alloc_n(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
@@ -485,9 +485,9 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
    uninitialized_copy_alloc_n(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n(f, n, r); }
+{  return dtl::memmove_n(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -506,7 +506,7 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_constructible<I, F, I>::type
+inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
    uninitialized_copy_alloc_n_source(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
@@ -530,9 +530,9 @@ template
    <typename Allocator,
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
    uninitialized_copy_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n_source(f, n, r); }
+{  return dtl::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -550,7 +550,7 @@ inline typename container_detail::enable_if_memtransfer_copy_constructible<I, F,
 template
    <typename Allocator,
     typename F> // F models ForwardIterator
-inline typename container_detail::disable_if_memzero_initializable<F, F>::type
+inline typename dtl::disable_if_memzero_initializable<F, F>::type
    uninitialized_value_init_alloc_n(Allocator &a, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    F back = r;
@@ -573,7 +573,7 @@ inline typename container_detail::disable_if_memzero_initializable<F, F>::type
 template
    <typename Allocator,
     typename F> // F models ForwardIterator
-inline typename container_detail::enable_if_memzero_initializable<F, F>::type
+inline typename dtl::enable_if_memzero_initializable<F, F>::type
    uninitialized_value_init_alloc_n(Allocator &, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
 {
    typedef typename boost::container::iterator_traits<F>::value_type value_type;
@@ -698,7 +698,7 @@ inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, typename boost::co
 template
 <typename I,   // I models InputIterator
 typename F>    // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
    copy(I f, I l, F r)
 {
    while (f != l) {
@@ -711,9 +711,9 @@ inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F
 template
 <typename I,   // I models InputIterator
 typename F>    // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
    copy(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove(f, l, r); }
+{  return dtl::memmove(f, l, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -725,7 +725,7 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
    copy_n(I f, U n, F r)
 {
    while (n--) {
@@ -739,9 +739,9 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
    copy_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n(f, n, r); }
+{  return dtl::memmove_n(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -753,7 +753,7 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
    copy_n_source(I f, U n, F r)
 {
    while (n--) {
@@ -767,9 +767,9 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
    copy_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n_source(f, n, r); }
+{  return dtl::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -781,7 +781,7 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
    copy_n_source_dest(I f, U n, F &r)
 {
    while (n--) {
@@ -795,9 +795,9 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
    copy_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n_source_dest(f, n, r);  }
+{  return dtl::memmove_n_source_dest(f, n, r);  }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -808,7 +808,7 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>
 template
 <typename I,   // I models InputIterator
 typename F>   // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
    move(I f, I l, F r)
 {
    while (f != l) {
@@ -821,9 +821,9 @@ inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F
 template
 <typename I,   // I models InputIterator
 typename F>   // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
    move(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove(f, l, r); }
+{  return dtl::memmove(f, l, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -835,7 +835,7 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
    move_n(I f, U n, F r)
 {
    while (n--) {
@@ -849,9 +849,9 @@ template
 <typename I,   // I models InputIterator
 typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
    move_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n(f, n, r); }
+{  return dtl::memmove_n(f, n, r); }
 
 
 //////////////////////////////////////////////////////////////////////////////
@@ -863,7 +863,7 @@ inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>
 template
 <typename I,   // I models BidirectionalIterator
 typename F>    // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, F>::type
    move_backward(I f, I l, F r)
 {
    while (f != l) {
@@ -876,7 +876,7 @@ inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, F
 template
 <typename I,   // I models InputIterator
 typename F>   // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, F>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, F>::type
    move_backward(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
@@ -896,7 +896,7 @@ template
 <typename I    // I models InputIterator
 ,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
    move_n_source_dest(I f, U n, F &r)
 {
    while (n--) {
@@ -910,9 +910,9 @@ template
 <typename I    // I models InputIterator
 ,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
    move_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n_source_dest(f, n, r); }
+{  return dtl::memmove_n_source_dest(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -924,7 +924,7 @@ template
 <typename I    // I models InputIterator
 ,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
-inline typename container_detail::disable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
    move_n_source(I f, U n, F r)
 {
    while (n--) {
@@ -938,9 +938,9 @@ template
 <typename I    // I models InputIterator
 ,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
-inline typename container_detail::enable_if_memtransfer_copy_assignable<I, F, I>::type
+inline typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
    move_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
-{  return container_detail::memmove_n_source(f, n, r); }
+{  return dtl::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
 //
@@ -952,7 +952,7 @@ template
    <typename Allocator
    ,typename I   // I models InputIterator
    ,typename U>  // U models unsigned integral constant
-inline typename container_detail::disable_if_trivially_destructible<I, void>::type
+inline typename dtl::disable_if_trivially_destructible<I, void>::type
    destroy_alloc_n(Allocator &a, I f, U n)
 {
    while(n){
@@ -966,7 +966,7 @@ template
    <typename Allocator
    ,typename I   // I models InputIterator
    ,typename U>  // U models unsigned integral constant
-inline typename container_detail::enable_if_trivially_destructible<I, void>::type
+inline typename dtl::enable_if_trivially_destructible<I, void>::type
    destroy_alloc_n(Allocator &, I, U)
 {}
 
@@ -982,7 +982,7 @@ template
    ,typename F // F models ForwardIterator
    ,typename G // G models ForwardIterator
    >
-inline typename container_detail::disable_if_memtransfer_copy_assignable<F, G, void>::type
+inline typename dtl::disable_if_memtransfer_copy_assignable<F, G, void>::type
    deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits<Allocator>::size_type n_i
                     , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
 {
@@ -1002,15 +1002,15 @@ template
    ,typename F // F models ForwardIterator
    ,typename G // G models ForwardIterator
    >
-inline typename container_detail::enable_if_c
-   < container_detail::is_memtransfer_copy_assignable<F, G>::value && (MaxTmpBytes <= DeepSwapAllocNMaxStorage) && false
+inline typename dtl::enable_if_c
+   < dtl::is_memtransfer_copy_assignable<F, G>::value && (MaxTmpBytes <= DeepSwapAllocNMaxStorage) && false
    , void>::type
    deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits<Allocator>::size_type n_i
                     , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
-   typedef typename container_detail::aligned_storage
-      <MaxTmpBytes, container_detail::alignment_of<value_type>::value>::type storage_type;
+   typedef typename dtl::aligned_storage
+      <MaxTmpBytes, dtl::alignment_of<value_type>::value>::type storage_type;
    storage_type storage;
 
    const std::size_t n_i_bytes = sizeof(value_type)*n_i;
@@ -1032,15 +1032,15 @@ template
    ,typename F // F models ForwardIterator
    ,typename G // G models ForwardIterator
    >
-inline typename container_detail::enable_if_c
-   < container_detail::is_memtransfer_copy_assignable<F, G>::value && true//(MaxTmpBytes > DeepSwapAllocNMaxStorage)
+inline typename dtl::enable_if_c
+   < dtl::is_memtransfer_copy_assignable<F, G>::value && true//(MaxTmpBytes > DeepSwapAllocNMaxStorage)
    , void>::type
    deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits<Allocator>::size_type n_i
                     , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
-   typedef typename container_detail::aligned_storage
-      <DeepSwapAllocNMaxStorage, container_detail::alignment_of<value_type>::value>::type storage_type;
+   typedef typename dtl::aligned_storage
+      <DeepSwapAllocNMaxStorage, dtl::alignment_of<value_type>::value>::type storage_type;
    storage_type storage;
    const std::size_t sizeof_storage = sizeof(storage);
 

include/boost/container/detail/destroyers.hpp

@@ -30,7 +30,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 //!A deleter for scoped_ptr that deallocates the memory
 //!allocated for an object using a STL allocator.
@@ -39,8 +39,8 @@ struct scoped_deallocator
 {
    typedef allocator_traits<Allocator> allocator_traits_type;
    typedef typename allocator_traits_type::pointer pointer;
-   typedef container_detail::integral_constant<unsigned,
-      boost::container::container_detail::
+   typedef dtl::integral_constant<unsigned,
+      boost::container::dtl::
          version<Allocator>::value>                   alloc_version;
 
    private:
@@ -142,8 +142,8 @@ struct scoped_destroy_deallocator
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer    pointer;
    typedef typename AllocTraits::size_type  size_type;
-   typedef container_detail::integral_constant<unsigned,
-      boost::container::container_detail::
+   typedef dtl::integral_constant<unsigned,
+      boost::container::dtl::
          version<Allocator>::value>                          alloc_version;
 
    scoped_destroy_deallocator(pointer p, Allocator& a)
@@ -296,8 +296,8 @@ class allocator_destroyer
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::value_type value_type;
    typedef typename AllocTraits::pointer    pointer;
-   typedef container_detail::integral_constant<unsigned,
-      boost::container::container_detail::
+   typedef dtl::integral_constant<unsigned,
+      boost::container::dtl::
          version<Allocator>::value>                           alloc_version;
 
    private:
@@ -369,7 +369,7 @@ class allocator_multialloc_chain_node_deallocator
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/dispatch_uses_allocator.hpp

@@ -35,7 +35,7 @@
 
 namespace boost { namespace container {
 
-namespace container_detail {
+namespace dtl {
 
 
 // Check if we can detect is_convertible using advanced SFINAE expressions
@@ -110,10 +110,10 @@ template < typename ConstructAlloc
          , typename T
          , class ...Args
          >
-inline typename container_detail::enable_if_and
+inline typename dtl::enable_if_and
    < void
-   , container_detail::is_not_pair<T>
-   , container_detail::not_< uses_allocator<T, ArgAlloc> >
+   , dtl::is_not_pair<T>
+   , dtl::not_< uses_allocator<T, ArgAlloc> >
    >::type dispatch_uses_allocator
    ( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, T* p, BOOST_FWD_REF(Args)...args)
 {
@@ -127,9 +127,9 @@ template < typename ConstructAlloc
          , typename T
          , class ...Args
          >
-inline typename container_detail::enable_if_and
+inline typename dtl::enable_if_and
    < void
-   , container_detail::is_not_pair<T>
+   , dtl::is_not_pair<T>
    , uses_allocator<T, ArgAlloc>
    , is_constructible_with_allocator_prefix<T, ArgAlloc, Args...>
    >::type dispatch_uses_allocator
@@ -146,11 +146,11 @@ template < typename ConstructAlloc
          , typename T
          , class ...Args
          >
-inline typename container_detail::enable_if_and
+inline typename dtl::enable_if_and
    < void
-   , container_detail::is_not_pair<T>
+   , dtl::is_not_pair<T>
    , uses_allocator<T, ArgAlloc>
-   , container_detail::not_<is_constructible_with_allocator_prefix<T, ArgAlloc, Args...> >
+   , dtl::not_<is_constructible_with_allocator_prefix<T, ArgAlloc, Args...> >
    >::type dispatch_uses_allocator
    ( ConstructAlloc& construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, T* p, BOOST_FWD_REF(Args)...args)
 {
@@ -162,10 +162,10 @@ inline typename container_detail::enable_if_and
 
 #define BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR_CODE(N) \
    template <typename ConstructAlloc, typename ArgAlloc, typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   inline typename container_detail::enable_if_and\
+   inline typename dtl::enable_if_and\
       < void\
-      , container_detail::is_not_pair<T>\
-      , container_detail::not_<uses_allocator<T, ArgAlloc> >\
+      , dtl::is_not_pair<T>\
+      , dtl::not_<uses_allocator<T, ArgAlloc> >\
       >::type\
       dispatch_uses_allocator\
       (ConstructAlloc &construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, T* p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
@@ -179,9 +179,9 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR
 
 #define BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR_CODE(N) \
    template < typename ConstructAlloc, typename ArgAlloc, typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   inline typename container_detail::enable_if_and\
+   inline typename dtl::enable_if_and\
       < void\
-      , container_detail::is_not_pair<T>\
+      , dtl::is_not_pair<T>\
       , uses_allocator<T, ArgAlloc>\
       , is_constructible_with_allocator_prefix<T, ArgAlloc BOOST_MOVE_I##N BOOST_MOVE_TARG##N>\
       >::type\
@@ -197,11 +197,11 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR
 
 #define BOOST_CONTAINER_SCOPED_ALLOCATOR_DISPATCH_USES_ALLOCATOR_CODE(N) \
    template < typename ConstructAlloc, typename ArgAlloc, typename T BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   inline typename container_detail::enable_if_and\
+   inline typename dtl::enable_if_and\
       < void\
-      , container_detail::is_not_pair<T>\
+      , dtl::is_not_pair<T>\
       , uses_allocator<T, ArgAlloc>\
-      , container_detail::not_<is_constructible_with_allocator_prefix<T, ArgAlloc BOOST_MOVE_I##N BOOST_MOVE_TARG##N> >\
+      , dtl::not_<is_constructible_with_allocator_prefix<T, ArgAlloc BOOST_MOVE_I##N BOOST_MOVE_TARG##N> >\
       >::type\
       dispatch_uses_allocator\
       (ConstructAlloc& construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, T* p BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
@@ -219,18 +219,18 @@ template < typename ConstructAlloc
          , typename ArgAlloc
          , typename Pair
          > inline 
-BOOST_CONTAINER_DOC1ST(void, typename container_detail::enable_if<container_detail::is_pair<Pair> >::type)
+BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> >::type)
    dispatch_uses_allocator
    ( ConstructAlloc & construct_alloc
    , BOOST_FWD_REF(ArgAlloc) arg_alloc
    , Pair* p)
 {
-   (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->first));
+   (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->first));
    BOOST_TRY{
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->second));
+      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->second));
    }
    BOOST_CATCH(...) {
-      allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(p->first));
+      allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
       BOOST_RETHROW
    }
    BOOST_CATCH_END
@@ -240,18 +240,18 @@ BOOST_CONTAINER_DOC1ST(void, typename container_detail::enable_if<container_deta
 template < typename ConstructAlloc
          , typename ArgAlloc
          , class Pair, class U, class V>
-BOOST_CONTAINER_DOC1ST(void, typename container_detail::enable_if<container_detail::is_pair<Pair> >::type)
+BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if<dtl::is_pair<Pair> >::type)
    dispatch_uses_allocator
    ( ConstructAlloc & construct_alloc
    , BOOST_FWD_REF(ArgAlloc) arg_alloc
    , Pair* p, BOOST_FWD_REF(U) x, BOOST_FWD_REF(V) y)
 {
-   (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->first), ::boost::forward<U>(x));
+   (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<U>(x));
    BOOST_TRY{
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->second), ::boost::forward<V>(y));
+      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<V>(y));
    }
    BOOST_CATCH(...){
-      allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(p->first));
+      allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
       BOOST_RETHROW
    }
    BOOST_CATCH_END
@@ -260,7 +260,7 @@ BOOST_CONTAINER_DOC1ST(void, typename container_detail::enable_if<container_deta
 template < typename ConstructAlloc
          , typename ArgAlloc
          , class Pair, class Pair2>
-BOOST_CONTAINER_DOC1ST(void, typename container_detail::enable_if< container_detail::is_pair<Pair> >::type)
+BOOST_CONTAINER_DOC1ST(void, typename dtl::enable_if< dtl::is_pair<Pair> >::type)
    dispatch_uses_allocator
    (ConstructAlloc & construct_alloc
    , BOOST_FWD_REF(ArgAlloc) arg_alloc
@@ -270,10 +270,10 @@ BOOST_CONTAINER_DOC1ST(void, typename container_detail::enable_if< container_det
 template < typename ConstructAlloc
          , typename ArgAlloc
          , class Pair, class Pair2>
-typename container_detail::enable_if_and
+typename dtl::enable_if_and
    < void
-   , container_detail::is_pair<Pair>
-   , container_detail::not_<boost::move_detail::is_reference<Pair2> > >::type //This is needed for MSVC10 and ambiguous overloads
+   , dtl::is_pair<Pair>
+   , dtl::not_<boost::move_detail::is_reference<Pair2> > >::type //This is needed for MSVC10 and ambiguous overloads
    dispatch_uses_allocator
    (ConstructAlloc & construct_alloc
       , BOOST_FWD_REF(ArgAlloc) arg_alloc
@@ -286,20 +286,20 @@ typename container_detail::enable_if_and
 template< typename ConstructAlloc, typename ArgAlloc, class Pair \
         , template<class, class, class, class, class, class, class, class, class, class> class BoostTuple \
          BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
-typename container_detail::enable_if< container_detail::is_pair<Pair> >::type\
+typename dtl::enable_if< dtl::is_pair<Pair> >::type\
    dispatch_uses_allocator( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t\
       , BoostTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::boost::tuples::null_type)> p\
       , BoostTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::boost::tuples::null_type)> q)\
 {\
    (void)p; (void)q;\
    (dispatch_uses_allocator)\
-      (construct_alloc, arg_alloc, container_detail::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_TMPL_GET##N);\
+      (construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_TMPL_GET##N);\
    BOOST_TRY{\
       (dispatch_uses_allocator)\
-         (construct_alloc, arg_alloc, container_detail::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_TMPL_GETQ##M);\
+         (construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_TMPL_GETQ##M);\
    }\
    BOOST_CATCH(...) {\
-      allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(pair->first));\
+      allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));\
       BOOST_RETHROW\
    }\
    BOOST_CATCH_END\
@@ -317,12 +317,12 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
                                     , Tuple<Args1...>& t1, Tuple<Args2...>& t2, index_tuple<Indexes1...>, index_tuple<Indexes2...>)
    {
       (void)t1; (void)t2;
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(pair->first), ::boost::forward<Args1>(get<Indexes1>(t1))...);
+      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(pair->first), ::boost::forward<Args1>(get<Indexes1>(t1))...);
       BOOST_TRY{
-         (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(pair->second), ::boost::forward<Args2>(get<Indexes2>(t2))...);
+         (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(pair->second), ::boost::forward<Args2>(get<Indexes2>(t2))...);
       }
       BOOST_CATCH(...){
-         allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(pair->first));
+         allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));
          BOOST_RETHROW
       }
       BOOST_CATCH_END
@@ -330,7 +330,7 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
 
    template< typename ConstructAlloc, typename ArgAlloc, class Pair
            , template<class ...> class Tuple, class... Args1, class... Args2>
-   typename container_detail::enable_if< container_detail::is_pair<Pair> >::type
+   typename dtl::enable_if< dtl::is_pair<Pair> >::type
       dispatch_uses_allocator( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t
                              , Tuple<Args1...> t1, Tuple<Args2...> t2)
    {
@@ -346,20 +346,20 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
    template< typename ConstructAlloc, typename ArgAlloc, class Pair\
            , template<class, class, class, class, class, class, class, class, class, class> class StdTuple\
             BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
-   typename container_detail::enable_if< container_detail::is_pair<Pair> >::type\
+   typename dtl::enable_if< dtl::is_pair<Pair> >::type\
       dispatch_uses_allocator(ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t\
                            , StdTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::std::tr1::_Nil)> p\
                            , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::std::tr1::_Nil)> q)\
    {\
       (void)p; (void)q;\
       (dispatch_uses_allocator)\
-         (construct_alloc, arg_alloc, container_detail::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
+         (construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
       BOOST_TRY{\
          (dispatch_uses_allocator)\
-            (construct_alloc, arg_alloc, container_detail::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
+            (construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
       }\
       BOOST_CATCH(...) {\
-         allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(pair->first));\
+         allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));\
          BOOST_RETHROW\
       }\
       BOOST_CATCH_END\
@@ -380,7 +380,7 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
    template< typename ConstructAlloc, typename ArgAlloc, class Pair\
             , template<BOOST_MOVE_REPEAT(_VARIADIC_MAX, class), class, class, class> class StdTuple \
             BOOST_MOVE_I_IF(BOOST_MOVE_OR(N,M)) BOOST_MOVE_CLASS##N BOOST_MOVE_I_IF(BOOST_MOVE_AND(N,M)) BOOST_MOVE_CLASSQ##M > \
-   typename container_detail::enable_if< container_detail::is_pair<Pair> >::type\
+   typename dtl::enable_if< dtl::is_pair<Pair> >::type\
       dispatch_uses_allocator\
          ( ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* pair, piecewise_construct_t\
          , StdTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(BOOST_MOVE_ADD(_VARIADIC_MAX, 3),N),::std::_Nil) > p\
@@ -388,13 +388,13 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
    {\
       (void)p; (void)q;\
       (dispatch_uses_allocator)\
-         (construct_alloc, arg_alloc, container_detail::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
+         (construct_alloc, arg_alloc, dtl::addressof(pair->first) BOOST_MOVE_I_IF(N) BOOST_MOVE_GET_IDX##N);\
       BOOST_TRY{\
          (dispatch_uses_allocator)\
-            (construct_alloc, arg_alloc, container_detail::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
+            (construct_alloc, arg_alloc, dtl::addressof(pair->second) BOOST_MOVE_I_IF(M) BOOST_MOVE_GET_IDXQ##M);\
       }\
       BOOST_CATCH(...) {\
-         allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(pair->first));\
+         allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(pair->first));\
          BOOST_RETHROW\
       }\
       BOOST_CATCH_END\
@@ -411,16 +411,16 @@ BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_DISPATCH_USES_ALLOCATOR_PIECEWISE_CONSTRUCT_BO
 template < typename ConstructAlloc
          , typename ArgAlloc
          , class Pair, class KeyType, class ... Args>
-typename container_detail::enable_if< container_detail::is_pair<Pair>, void >::type
+typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
    dispatch_uses_allocator
    (ConstructAlloc & construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* p, try_emplace_t, BOOST_FWD_REF(KeyType) k, BOOST_FWD_REF(Args) ...args)
 {
-   (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->first), ::boost::forward<KeyType>(k));
+   (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));
    BOOST_TRY{
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->second), ::boost::forward<Args>(args)...);
+      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->second), ::boost::forward<Args>(args)...);
    }
    BOOST_CATCH(...) {
-      allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(p->first));
+      allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));
       BOOST_RETHROW
    }
    BOOST_CATCH_END
@@ -430,18 +430,18 @@ typename container_detail::enable_if< container_detail::is_pair<Pair>, void >::t
 
 #define BOOST_CONTAINER_DISPATCH_USES_ALLOCATOR_PAIR_TRY_EMPLACE_CODE(N) \
    template <typename ConstructAlloc, typename ArgAlloc, class Pair, class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
-   inline typename container_detail::enable_if\
-      < container_detail::is_pair<Pair>, void >::type\
+   inline typename dtl::enable_if\
+      < dtl::is_pair<Pair>, void >::type\
       dispatch_uses_allocator\
       (ConstructAlloc &construct_alloc, BOOST_FWD_REF(ArgAlloc) arg_alloc, Pair* p, try_emplace_t, \
        BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
-      (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->first), ::boost::forward<KeyType>(k));\
+      (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->first), ::boost::forward<KeyType>(k));\
       BOOST_TRY{\
-         (dispatch_uses_allocator)(construct_alloc, arg_alloc, container_detail::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+         (dispatch_uses_allocator)(construct_alloc, arg_alloc, dtl::addressof(p->second) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       }\
       BOOST_CATCH(...) {\
-         allocator_traits<ConstructAlloc>::destroy(construct_alloc, container_detail::addressof(p->first));\
+         allocator_traits<ConstructAlloc>::destroy(construct_alloc, dtl::addressof(p->first));\
          BOOST_RETHROW\
       }\
       BOOST_CATCH_END\
@@ -452,7 +452,7 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_DISPATCH_USES_ALLOCATOR_PAIR_TRY_EMPLACE
 
 #endif   //!defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
-}  //namespace container_detail
+}  //namespace dtl
 
 }} // namespace boost { namespace container {
 

include/boost/container/detail/flat_tree.hpp

@@ -56,7 +56,7 @@
 
 //merge_unique
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME merge_unique
-#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 3
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 3
@@ -64,7 +64,7 @@
 
 //merge_equal
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME merge
-#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 3
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 3
@@ -72,7 +72,7 @@
 
 //index_of
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME index_of
-#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
@@ -80,7 +80,7 @@
 
 //nth
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME nth
-#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
@@ -88,7 +88,7 @@
 
 //reserve
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME reserve
-#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
@@ -96,7 +96,7 @@
 
 //capacity
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_FUNCNAME capacity
-#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 0
 #define BOOST_INTRUSIVE_HAS_MEMBER_FUNCTION_CALLABLE_WITH_MAX 0
@@ -106,20 +106,20 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(stored_allocator_type)
 
 template<class SequenceContainer, class Iterator, class Compare>
 BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal
-   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::true_)
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::true_)
 {
    dest.merge(first, last, comp);
 }
 
 template<class SequenceContainer, class Iterator, class Compare>
 BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal_non_merge_member
-   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::true_)
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::true_)
 {
    typedef typename SequenceContainer::iterator    iterator;
    typedef typename SequenceContainer::value_type  value_type;
@@ -135,7 +135,7 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal_non_merge_member
 
 template<class SequenceContainer, class Iterator, class Compare>
 BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal_non_merge_member
-   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::false_)
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
 {
    typedef typename SequenceContainer::iterator    iterator;
 
@@ -146,24 +146,24 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal_non_merge_member
 
 template<class SequenceContainer, class Iterator, class Compare>
 BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_equal
-   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::false_)
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
 {
    (flat_tree_merge_equal_non_merge_member)( dest, first, last, comp
-                                           , container_detail::bool_<is_contiguous_container<SequenceContainer>::value>());
+                                           , dtl::bool_<is_contiguous_container<SequenceContainer>::value>());
 }
 
 template<class SequenceContainer, class Iterator, class Compare>
 BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique
-   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::true_)
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::true_)
 {
    dest.merge_unique(first, last, comp);
 }
 
 template<class SequenceContainer, class Iterator, class Compare>
 BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique
-   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, container_detail::false_)
+   (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
 {
-   (flat_tree_merge_equal)(dest, first, last, comp, container_detail::false_());
+   (flat_tree_merge_equal)(dest, first, last, comp, dtl::false_());
    dest.erase(boost::movelib::unique
       (dest.begin(), dest.end(), boost::movelib::negate<Compare>(comp)), dest.cend());
 }
@@ -171,7 +171,7 @@ BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique
 template<class SequenceContainer, class Iterator>
 BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
    flat_tree_index_of
-      (SequenceContainer& cont, Iterator p, container_detail::true_)
+      (SequenceContainer& cont, Iterator p, dtl::true_)
 {
    return cont.index_of(p);
 }
@@ -179,7 +179,7 @@ BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
 template<class SequenceContainer, class Iterator>
 BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
    flat_tree_index_of
-      (SequenceContainer& cont, Iterator p, container_detail::false_)
+      (SequenceContainer& cont, Iterator p, dtl::false_)
 {
    typedef typename SequenceContainer::size_type size_type;
    return static_cast<size_type>(p - cont.begin());
@@ -188,7 +188,7 @@ BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
 template<class Iterator, class SequenceContainer>
 BOOST_CONTAINER_FORCEINLINE Iterator
    flat_tree_nth
-      (SequenceContainer& cont, typename SequenceContainer::size_type n, container_detail::true_)
+      (SequenceContainer& cont, typename SequenceContainer::size_type n, dtl::true_)
 {
    return cont.nth(n);
 }
@@ -196,7 +196,7 @@ BOOST_CONTAINER_FORCEINLINE Iterator
 template<class Iterator, class SequenceContainer>
 BOOST_CONTAINER_FORCEINLINE Iterator
    flat_tree_nth
-      (SequenceContainer& cont, typename SequenceContainer::size_type n, container_detail::false_)
+      (SequenceContainer& cont, typename SequenceContainer::size_type n, dtl::false_)
 {
    return cont.begin()+ n;
 }
@@ -204,7 +204,7 @@ BOOST_CONTAINER_FORCEINLINE Iterator
 template<class SequenceContainer>
 BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::stored_allocator_type &
    flat_tree_get_stored_allocator
-      (SequenceContainer& cont, container_detail::true_)
+      (SequenceContainer& cont, dtl::true_)
 {
    return cont.get_stored_allocator();
 }
@@ -212,7 +212,7 @@ BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::stored_allocator_type &
 template<class SequenceContainer>
 BOOST_CONTAINER_FORCEINLINE const typename SequenceContainer::stored_allocator_type &
    flat_tree_get_stored_allocator
-      (const SequenceContainer& cont, container_detail::true_)
+      (const SequenceContainer& cont, dtl::true_)
 {
    return cont.get_stored_allocator();
 }
@@ -220,13 +220,13 @@ BOOST_CONTAINER_FORCEINLINE const typename SequenceContainer::stored_allocator_t
 template<class SequenceContainer>
 BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::allocator_type
    flat_tree_get_stored_allocator
-      (SequenceContainer& cont, container_detail::false_)
+      (SequenceContainer& cont, dtl::false_)
 {
    return cont.get_allocator();
 }
 
 template<class SequenceContainer, class Compare>
-void flat_tree_adopt_sequence_equal(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, container_detail::true_)
+void flat_tree_adopt_sequence_equal(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, dtl::true_)
 {
    tseq.clear();
    boost::movelib::adaptive_sort
@@ -239,14 +239,14 @@ void flat_tree_adopt_sequence_equal(SequenceContainer &tseq, BOOST_RV_REF(Sequen
 }
 
 template<class SequenceContainer, class Compare>
-void flat_tree_adopt_sequence_equal(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, container_detail::false_)
+void flat_tree_adopt_sequence_equal(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, dtl::false_)
 {
    boost::movelib::adaptive_sort(seq.begin(), seq.end(), comp);
    tseq = boost::move(seq);
 }
 
 template<class SequenceContainer, class Compare>
-void flat_tree_adopt_sequence_unique(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, container_detail::true_)
+void flat_tree_adopt_sequence_unique(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, dtl::true_)
 {
    boost::movelib::adaptive_sort
       ( boost::movelib::iterator_to_raw_pointer(seq.begin())
@@ -261,7 +261,7 @@ void flat_tree_adopt_sequence_unique(SequenceContainer &tseq, BOOST_RV_REF(Seque
 }
 
 template<class SequenceContainer, class Compare>
-void flat_tree_adopt_sequence_unique(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, container_detail::false_)
+void flat_tree_adopt_sequence_unique(SequenceContainer &tseq, BOOST_RV_REF(SequenceContainer) seq, Compare comp, dtl::false_)
 {
    boost::movelib::adaptive_sort(seq.begin(), seq.end(), comp);
    seq.erase(boost::movelib::unique
@@ -271,27 +271,27 @@ void flat_tree_adopt_sequence_unique(SequenceContainer &tseq, BOOST_RV_REF(Seque
 
 template<class SequenceContainer>
 BOOST_CONTAINER_FORCEINLINE void
-   flat_tree_reserve(SequenceContainer &tseq, typename SequenceContainer::size_type cap, container_detail::true_)
+   flat_tree_reserve(SequenceContainer &tseq, typename SequenceContainer::size_type cap, dtl::true_)
 {
    tseq.reserve(cap);
 }
 
 template<class SequenceContainer>
 BOOST_CONTAINER_FORCEINLINE void
-   flat_tree_reserve(SequenceContainer &, typename SequenceContainer::size_type, container_detail::false_)
+   flat_tree_reserve(SequenceContainer &, typename SequenceContainer::size_type, dtl::false_)
 {
 }
 
 template<class SequenceContainer>
 BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
-   flat_tree_capacity(const SequenceContainer &tseq, container_detail::true_)
+   flat_tree_capacity(const SequenceContainer &tseq, dtl::true_)
 {
    return tseq.capacity();
 }
 
 template<class SequenceContainer>
 BOOST_CONTAINER_FORCEINLINE typename SequenceContainer::size_type
-   flat_tree_capacity(const SequenceContainer &tseq, container_detail::false_)
+   flat_tree_capacity(const SequenceContainer &tseq, dtl::false_)
 {
    return tseq.size();
 }
@@ -328,9 +328,9 @@ class flat_tree_value_compare
 template<class Pointer>
 struct get_flat_tree_iterators
 {
-   typedef typename boost::container::container_detail::
+   typedef typename boost::container::dtl::
       vec_iterator<Pointer, false>                             iterator;
-   typedef typename boost::container::container_detail::
+   typedef typename boost::container::dtl::
       vec_iterator<Pointer, true >                             const_iterator;
    typedef boost::container::reverse_iterator<iterator>        reverse_iterator;
    typedef boost::container::reverse_iterator<const_iterator>  const_reverse_iterator;
@@ -338,7 +338,7 @@ struct get_flat_tree_iterators
 */
 
 template < class Value, class AllocatorOrContainer
-         , bool = boost::container::container_detail::is_container<AllocatorOrContainer>::value >
+         , bool = boost::container::dtl::is_container<AllocatorOrContainer>::value >
 struct select_container_type
 {
    typedef AllocatorOrContainer type;
@@ -452,20 +452,20 @@ class flat_tree
 
    //!Standard extension
    typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
-      (boost::container::container_detail::, container_type
+      (boost::container::dtl::, container_type
       ,stored_allocator_type, allocator_type)               stored_allocator_type;
 
    static const bool has_stored_allocator_type =
-      BOOST_INTRUSIVE_HAS_TYPE(boost::container::container_detail::, container_type, stored_allocator_type);
+      BOOST_INTRUSIVE_HAS_TYPE(boost::container::dtl::, container_type, stored_allocator_type);
 
    private:
    typedef allocator_traits<stored_allocator_type> stored_allocator_traits;
 
    public:
-   typedef typename container_detail::if_c
+   typedef typename dtl::if_c
       <has_stored_allocator_type, const stored_allocator_type &, allocator_type>::type get_stored_allocator_const_return_t;
 
-   typedef typename container_detail::if_c
+   typedef typename dtl::if_c
       <has_stored_allocator_type, stored_allocator_type &, allocator_type>::type get_stored_allocator_noconst_return_t;
 
    BOOST_CONTAINER_FORCEINLINE flat_tree()
@@ -489,7 +489,7 @@ class flat_tree
    { }
 
    BOOST_CONTAINER_FORCEINLINE flat_tree(BOOST_RV_REF(flat_tree) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       :  m_data(boost::move(x.m_data))
    { }
 
@@ -599,7 +599,7 @@ class flat_tree
    BOOST_CONTAINER_FORCEINLINE flat_tree&  operator=(BOOST_RV_REF(flat_tree) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {  m_data = boost::move(x.m_data); return *this;  }
 
    BOOST_CONTAINER_FORCEINLINE const value_compare &priv_value_comp() const
@@ -632,12 +632,12 @@ class flat_tree
 
    BOOST_CONTAINER_FORCEINLINE get_stored_allocator_const_return_t get_stored_allocator() const
    {
-      return flat_tree_get_stored_allocator(this->m_data.m_seq, container_detail::bool_<has_stored_allocator_type>());
+      return flat_tree_get_stored_allocator(this->m_data.m_seq, dtl::bool_<has_stored_allocator_type>());
    }
 
    BOOST_CONTAINER_FORCEINLINE get_stored_allocator_noconst_return_t get_stored_allocator()
    {
-      return flat_tree_get_stored_allocator(this->m_data.m_seq, container_detail::bool_<has_stored_allocator_type>());
+      return flat_tree_get_stored_allocator(this->m_data.m_seq, dtl::bool_<has_stored_allocator_type>());
    }
 
    BOOST_CONTAINER_FORCEINLINE iterator begin()
@@ -687,7 +687,7 @@ class flat_tree
 
    BOOST_CONTAINER_FORCEINLINE void swap(flat_tree& other)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value )
    {  this->m_data.swap(other.m_data);  }
 
    public:
@@ -775,8 +775,8 @@ class flat_tree
    template <class InIt>
    void insert_equal(InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < container_detail::is_input_iterator<InIt>::value
+      , typename dtl::enable_if_c
+         < dtl::is_input_iterator<InIt>::value
          >::type * = 0
       #endif
       )
@@ -785,8 +785,8 @@ class flat_tree
    template <class InIt>
    void insert_equal(InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < !container_detail::is_input_iterator<InIt>::value
+      , typename dtl::enable_if_c
+         < !dtl::is_input_iterator<InIt>::value
          >::type * = 0
       #endif
       )
@@ -801,8 +801,8 @@ class flat_tree
    template <class InIt>
    void insert_equal(ordered_range_t, InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < container_detail::is_input_iterator<InIt>::value
+      , typename dtl::enable_if_c
+         < dtl::is_input_iterator<InIt>::value
          >::type * = 0
       #endif
       )
@@ -811,9 +811,9 @@ class flat_tree
    template <class FwdIt>
    void insert_equal(ordered_range_t, FwdIt first, FwdIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < !container_detail::is_input_iterator<FwdIt>::value &&
-         container_detail::is_forward_iterator<FwdIt>::value
+      , typename dtl::enable_if_c
+         < !dtl::is_input_iterator<FwdIt>::value &&
+         dtl::is_forward_iterator<FwdIt>::value
          >::type * = 0
       #endif
       )
@@ -826,26 +826,26 @@ class flat_tree
    template <class BidirIt>
    void insert_equal(ordered_range_t, BidirIt first, BidirIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_input_iterator<BidirIt>
-         , container_detail::is_forward_iterator<BidirIt>
+         , dtl::is_input_iterator<BidirIt>
+         , dtl::is_forward_iterator<BidirIt>
          >::type * = 0
       #endif
       )
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_merge_unique<container_type, iterator, iterator, value_compare>::value;
-      (flat_tree_merge_equal)(this->m_data.m_seq, first, last, this->priv_value_comp(), container_detail::bool_<value>());
+      (flat_tree_merge_equal)(this->m_data.m_seq, first, last, this->priv_value_comp(), dtl::bool_<value>());
    }
 
    template <class InIt>
    void insert_unique(ordered_unique_range_t, InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_or
+      , typename dtl::enable_if_or
          < void
-         , container_detail::is_input_iterator<InIt>
-         , container_detail::is_forward_iterator<InIt>
+         , dtl::is_input_iterator<InIt>
+         , dtl::is_forward_iterator<InIt>
          >::type * = 0
       #endif
       )
@@ -860,16 +860,16 @@ class flat_tree
    template <class BidirIt>
    void insert_unique(ordered_unique_range_t, BidirIt first, BidirIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < !(container_detail::is_input_iterator<BidirIt>::value ||
-             container_detail::is_forward_iterator<BidirIt>::value)
+      , typename dtl::enable_if_c
+         < !(dtl::is_input_iterator<BidirIt>::value ||
+             dtl::is_forward_iterator<BidirIt>::value)
          >::type * = 0
       #endif
       )
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_merge_unique<container_type, iterator, iterator, value_compare>::value;
-      (flat_tree_merge_unique)(this->m_data.m_seq, first, last, this->priv_value_comp(), container_detail::bool_<value>());
+      (flat_tree_merge_unique)(this->m_data.m_seq, first, last, this->priv_value_comp(), dtl::bool_<value>());
    }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -1069,30 +1069,30 @@ class flat_tree
 
    BOOST_CONTAINER_FORCEINLINE iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_nth<container_type, size_type>::value;
-      return flat_tree_nth<iterator>(this->m_data.m_seq, n, container_detail::bool_<value>());
+      return flat_tree_nth<iterator>(this->m_data.m_seq, n, dtl::bool_<value>());
    }
 
    BOOST_CONTAINER_FORCEINLINE const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_nth<container_type, size_type>::value;
-      return flat_tree_nth<const_iterator>(this->m_data.m_seq, n, container_detail::bool_<value>());
+      return flat_tree_nth<const_iterator>(this->m_data.m_seq, n, dtl::bool_<value>());
    }
 
    BOOST_CONTAINER_FORCEINLINE size_type index_of(iterator p) BOOST_NOEXCEPT_OR_NOTHROW
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_index_of<container_type, iterator>::value;
-      return flat_tree_index_of(this->m_data.m_seq, p, container_detail::bool_<value>());
+      return flat_tree_index_of(this->m_data.m_seq, p, dtl::bool_<value>());
    }
 
    BOOST_CONTAINER_FORCEINLINE size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_index_of<container_type, const_iterator>::value;
-      return flat_tree_index_of(this->m_data.m_seq, p, container_detail::bool_<value>());
+      return flat_tree_index_of(this->m_data.m_seq, p, dtl::bool_<value>());
    }
 
    // set operations:
@@ -1141,26 +1141,26 @@ class flat_tree
 
    BOOST_CONTAINER_FORCEINLINE void merge_unique(flat_tree& source)
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_merge_unique<container_type, iterator, iterator, value_compare>::value;
       (flat_tree_merge_unique)
          ( this->m_data.m_seq
          , boost::make_move_iterator(source.m_data.m_seq.begin())
          , boost::make_move_iterator(source.m_data.m_seq.end())
          , this->priv_value_comp()
-         , container_detail::bool_<value>());
+         , dtl::bool_<value>());
    }
 
    BOOST_CONTAINER_FORCEINLINE void merge_equal(flat_tree& source)
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_merge<container_type, iterator, iterator, value_compare>::value;
       (flat_tree_merge_equal)
          ( this->m_data.m_seq
          , boost::make_move_iterator(source.m_data.m_seq.begin())
          , boost::make_move_iterator(source.m_data.m_seq.end())
          , this->priv_value_comp()
-         , container_detail::bool_<value>());
+         , dtl::bool_<value>());
    }
 
    BOOST_CONTAINER_FORCEINLINE iterator lower_bound(const key_type& k)
@@ -1189,16 +1189,16 @@ class flat_tree
 
    BOOST_CONTAINER_FORCEINLINE size_type capacity() const
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_capacity<container_type>::value;
-      return (flat_tree_capacity)(this->m_data.m_seq, container_detail::bool_<value>());
+      return (flat_tree_capacity)(this->m_data.m_seq, dtl::bool_<value>());
    }
 
    BOOST_CONTAINER_FORCEINLINE void reserve(size_type cnt)
    {
-      const bool value = boost::container::container_detail::
+      const bool value = boost::container::dtl::
          has_member_function_callable_with_reserve<container_type, size_type>::value;
-      (flat_tree_reserve)(this->m_data.m_seq, cnt, container_detail::bool_<value>());
+      (flat_tree_reserve)(this->m_data.m_seq, cnt, dtl::bool_<value>());
    }
 
    BOOST_CONTAINER_FORCEINLINE container_type extract_sequence()
@@ -1214,13 +1214,13 @@ class flat_tree
    BOOST_CONTAINER_FORCEINLINE void adopt_sequence_equal(BOOST_RV_REF(container_type) seq)
    {
       (flat_tree_adopt_sequence_equal)( m_data.m_seq, boost::move(seq), this->priv_value_comp()
-         , container_detail::bool_<is_contiguous_container<container_type>::value>());
+         , dtl::bool_<is_contiguous_container<container_type>::value>());
    }
 
    BOOST_CONTAINER_FORCEINLINE void adopt_sequence_unique(BOOST_RV_REF(container_type) seq)
    {
       (flat_tree_adopt_sequence_unique)(m_data.m_seq, boost::move(seq), this->priv_value_comp()
-         , container_detail::bool_<is_contiguous_container<container_type>::value>());
+         , dtl::bool_<is_contiguous_container<container_type>::value>());
    }
 
    void adopt_sequence_equal(ordered_range_t, BOOST_RV_REF(container_type) seq)
@@ -1497,7 +1497,7 @@ class flat_tree
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 }  //namespace container {
 
@@ -1505,9 +1505,9 @@ class flat_tree
 //!specialization for optimizations
 template <class T, class KeyOfValue,
 class Compare, class AllocatorOrContainer>
-struct has_trivial_destructor_after_move<boost::container::container_detail::flat_tree<T, KeyOfValue, Compare, AllocatorOrContainer> >
+struct has_trivial_destructor_after_move<boost::container::dtl::flat_tree<T, KeyOfValue, Compare, AllocatorOrContainer> >
 {
-   typedef typename boost::container::container_detail::select_container_type<T, AllocatorOrContainer>::type container_type;
+   typedef typename boost::container::dtl::select_container_type<T, AllocatorOrContainer>::type container_type;
    typedef typename container_type::allocator_type allocator_t;
    typedef typename ::boost::container::allocator_traits<allocator_t>::pointer pointer;
    static const bool value = ::boost::has_trivial_destructor_after_move<allocator_t>::value &&

include/boost/container/detail/is_container.hpp

@@ -36,7 +36,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template <class Container>
 struct is_container
@@ -48,7 +48,7 @@ struct is_container
          has_member_function_callable_with_empty<const Container>::value;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/is_contiguous_container.hpp

@@ -28,7 +28,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template <class Container>
 struct is_contiguous_container
@@ -40,7 +40,7 @@ struct is_contiguous_container
          has_member_function_callable_with_data<const Container>::value;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/is_sorted.hpp

@@ -20,7 +20,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template <class ForwardIterator, class Pred>
 bool is_sorted (ForwardIterator first, ForwardIterator last, Pred pred)
@@ -50,7 +50,7 @@ bool is_sorted_and_unique (ForwardIterator first, ForwardIterator last, Pred pre
    return true;
 }
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/iterator_to_raw_pointer.hpp

@@ -22,11 +22,11 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 using ::boost::movelib::iterator_to_raw_pointer;
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/iterators.hpp

@@ -612,7 +612,7 @@ class emplace_iterator
 template<class ...Args>
 struct emplace_functor
 {
-   typedef typename container_detail::build_number_seq<sizeof...(Args)>::type index_tuple_t;
+   typedef typename dtl::build_number_seq<sizeof...(Args)>::type index_tuple_t;
 
    emplace_functor(BOOST_FWD_REF(Args)... args)
       : args_(args...)
@@ -628,21 +628,21 @@ struct emplace_functor
 
    private:
    template<class Allocator, class T, std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void inplace_impl(Allocator &a, T* ptr, const container_detail::index_tuple<IdxPack...>&)
+   BOOST_CONTAINER_FORCEINLINE void inplace_impl(Allocator &a, T* ptr, const dtl::index_tuple<IdxPack...>&)
    {
       allocator_traits<Allocator>::construct
-         (a, ptr, ::boost::forward<Args>(container_detail::get<IdxPack>(args_))...);
+         (a, ptr, ::boost::forward<Args>(dtl::get<IdxPack>(args_))...);
    }
 
    template<class DestIt, std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void inplace_impl(DestIt dest, const container_detail::index_tuple<IdxPack...>&)
+   BOOST_CONTAINER_FORCEINLINE void inplace_impl(DestIt dest, const dtl::index_tuple<IdxPack...>&)
    {
       typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;
-      value_type && tmp= value_type(::boost::forward<Args>(container_detail::get<IdxPack>(args_))...);
+      value_type && tmp= value_type(::boost::forward<Args>(dtl::get<IdxPack>(args_))...);
       *dest = ::boost::move(tmp);
    }
 
-   container_detail::tuple<Args&...> args_;
+   dtl::tuple<Args&...> args_;
 };
 
 template<class ...Args>
@@ -672,7 +672,7 @@ struct emplace_functor##N\
    void operator()(DestIt dest)\
    {\
       typedef typename boost::container::iterator_traits<DestIt>::value_type value_type;\
-      BOOST_MOVE_IF(N, value_type tmp(BOOST_MOVE_MFWD##N), container_detail::value_init<value_type> tmp) ;\
+      BOOST_MOVE_IF(N, value_type tmp(BOOST_MOVE_MFWD##N), dtl::value_init<value_type> tmp) ;\
       *dest = ::boost::move(const_cast<value_type &>(BOOST_MOVE_IF(N, tmp, tmp.get())));\
    }\
    \
@@ -692,7 +692,7 @@ BOOST_MOVE_ITERATE_0TO9(BOOST_MOVE_ITERATOR_EMPLACE_FUNCTOR_CODE)
 
 #endif
 
-namespace container_detail {
+namespace dtl {
 
 template<class T>
 struct has_iterator_category
@@ -863,7 +863,7 @@ class iterator_from_iiterator
    IIterator m_iit;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 using ::boost::intrusive::reverse_iterator;
 

include/boost/container/detail/math_functions.hpp

@@ -32,7 +32,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 // Greatest common divisor and least common multiple
 
@@ -114,7 +114,7 @@ inline std::size_t floor_log2 (std::size_t x)
    return log2;
 }
 
-} // namespace container_detail
+} // namespace dtl
 } // namespace container
 } // namespace boost
 

include/boost/container/detail/min_max.hpp

@@ -20,7 +20,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class T>
 const T &max_value(const T &a, const T &b)
@@ -30,7 +30,7 @@ template<class T>
 const T &min_value(const T &a, const T &b)
 {  return a < b ? a : b;   }
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/mpl.hpp

@@ -30,7 +30,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 using boost::move_detail::integral_constant;
 using boost::move_detail::true_type;
@@ -76,7 +76,7 @@ struct select1st
    {  return const_cast<type&>(x.first);   }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/multiallocation_chain.hpp

@@ -35,7 +35,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class VoidPointer>
 class basic_multiallocation_chain
@@ -53,7 +53,7 @@ class basic_multiallocation_chain
    typedef bi::slist< node
                     , bi::linear<true>
                     , bi::cache_last<true>
-                    , bi::size_type<typename boost::container::container_detail::make_unsigned<difference_type>::type>
+                    , bi::size_type<typename boost::container::dtl::make_unsigned<difference_type>::type>
                     > slist_impl_t;
    slist_impl_t slist_impl_;
 
@@ -182,7 +182,7 @@ class basic_multiallocation_chain
 template<class T>
 struct cast_functor
 {
-   typedef typename container_detail::add_reference<T>::type result_type;
+   typedef typename dtl::add_reference<T>::type result_type;
    template<class U>
    result_type operator()(U &ptr) const
    {  return *static_cast<T*>(static_cast<void*>(&ptr));  }
@@ -211,7 +211,7 @@ class transform_multiallocation_chain
    public:
    typedef transform_iterator
       < typename MultiallocationChain::iterator
-      , container_detail::cast_functor <T> >             iterator;
+      , dtl::cast_functor <T> >             iterator;
    typedef typename MultiallocationChain::size_type      size_type;
 
    transform_multiallocation_chain()
@@ -289,7 +289,7 @@ class transform_multiallocation_chain
 
 }}}
 
-// namespace container_detail {
+// namespace dtl {
 // namespace container {
 // namespace boost {
 

include/boost/container/detail/mutex.hpp

@@ -171,7 +171,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 #if BOOST_MUTEX_HELPER == BOOST_MUTEX_HELPER_NONE
    class null_mutex
@@ -268,7 +268,7 @@ class scoped_lock
    Mutex &m_;
 };
 
-} // namespace container_detail
+} // namespace dtl
 } // namespace container
 } // namespace boost
 

include/boost/container/detail/next_capacity.hpp

@@ -25,7 +25,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 enum NextCapacityOption { NextCapacityDouble, NextCapacity60Percent };
 
@@ -68,7 +68,7 @@ struct next_capacity_calculator<SizeType, NextCapacity60Percent>
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/node_alloc_holder.hpp

@@ -50,7 +50,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_compare)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(predicate_type)
@@ -61,14 +61,14 @@ struct node_alloc_holder
    //If the intrusive container is an associative container, obtain the predicate, which will
    //be of type node_compare<>. If not an associative container value_compare will be a "nat" type.
    typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
-      ( boost::container::container_detail::
-      , ICont, value_compare, container_detail::nat)              intrusive_value_compare;
+      ( boost::container::dtl::
+      , ICont, value_compare, dtl::nat)              intrusive_value_compare;
    //In that case obtain the value predicate from the node predicate via predicate_type
    //if intrusive_value_compare is node_compare<>, nat otherwise
    typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
-      ( boost::container::container_detail::
+      ( boost::container::dtl::
       , intrusive_value_compare
-      , predicate_type, container_detail::nat)                    value_compare;
+      , predicate_type, dtl::nat)                    value_compare;
 
    typedef allocator_traits<Allocator>                            allocator_traits_type;
    typedef typename allocator_traits_type::value_type             value_type;
@@ -77,14 +77,14 @@ struct node_alloc_holder
    typedef typename allocator_traits_type::template
       portable_rebind_alloc<Node>::type                           NodeAlloc;
    typedef allocator_traits<NodeAlloc>                            node_allocator_traits_type;
-   typedef container_detail::allocator_version_traits<NodeAlloc>  node_allocator_version_traits_type;
+   typedef dtl::allocator_version_traits<NodeAlloc>  node_allocator_version_traits_type;
    typedef Allocator                                              ValAlloc;
    typedef typename node_allocator_traits_type::pointer           NodePtr;
-   typedef container_detail::scoped_deallocator<NodeAlloc>        Deallocator;
+   typedef dtl::scoped_deallocator<NodeAlloc>        Deallocator;
    typedef typename node_allocator_traits_type::size_type         size_type;
    typedef typename node_allocator_traits_type::difference_type   difference_type;
-   typedef container_detail::integral_constant<unsigned,
-      boost::container::container_detail::
+   typedef dtl::integral_constant<unsigned,
+      boost::container::dtl::
          version<NodeAlloc>::value>                               alloc_version;
    typedef typename ICont::iterator                               icont_iterator;
    typedef typename ICont::const_iterator                         icont_citerator;
@@ -134,15 +134,15 @@ struct node_alloc_holder
 
    void copy_assign_alloc(const node_alloc_holder &x)
    {
-      container_detail::bool_<allocator_traits_type::propagate_on_container_copy_assignment::value> flag;
-      container_detail::assign_alloc( static_cast<NodeAlloc &>(this->members_)
+      dtl::bool_<allocator_traits_type::propagate_on_container_copy_assignment::value> flag;
+      dtl::assign_alloc( static_cast<NodeAlloc &>(this->members_)
                                     , static_cast<const NodeAlloc &>(x.members_), flag);
    }
 
    void move_assign_alloc( node_alloc_holder &x)
    {
-      container_detail::bool_<allocator_traits_type::propagate_on_container_move_assignment::value> flag;
-      container_detail::move_alloc( static_cast<NodeAlloc &>(this->members_)
+      dtl::bool_<allocator_traits_type::propagate_on_container_move_assignment::value> flag;
+      dtl::move_alloc( static_cast<NodeAlloc &>(this->members_)
                                   , static_cast<NodeAlloc &>(x.members_), flag);
    }
 
@@ -167,7 +167,7 @@ struct node_alloc_holder
       Deallocator node_deallocator(p, this->node_alloc());
       allocator_traits<NodeAlloc>::construct
          ( this->node_alloc()
-         , container_detail::addressof(p->m_data), boost::forward<Args>(args)...);
+         , dtl::addressof(p->m_data), boost::forward<Args>(args)...);
       node_deallocator.release();
       //This does not throw
       typedef typename Node::hook_type hook_type;
@@ -185,7 +185,7 @@ struct node_alloc_holder
       Deallocator node_deallocator(p, this->node_alloc());\
       allocator_traits<NodeAlloc>::construct\
          ( this->node_alloc()\
-         , container_detail::addressof(p->m_data)\
+         , dtl::addressof(p->m_data)\
           BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       node_deallocator.release();\
       typedef typename Node::hook_type hook_type;\
@@ -203,7 +203,7 @@ struct node_alloc_holder
    {
       NodePtr p = this->allocate_one();
       Deallocator node_deallocator(p, this->node_alloc());
-      ::boost::container::construct_in_place(this->node_alloc(), container_detail::addressof(p->m_data), it);
+      ::boost::container::construct_in_place(this->node_alloc(), dtl::addressof(p->m_data), it);
       node_deallocator.release();
       //This does not throw
       typedef typename Node::hook_type hook_type;
@@ -218,12 +218,12 @@ struct node_alloc_holder
       NodeAlloc &na = this->node_alloc();
       Deallocator node_deallocator(p, this->node_alloc());
       node_allocator_traits_type::construct
-         (na, container_detail::addressof(p->m_data.first), boost::forward<KeyConvertible>(key));
+         (na, dtl::addressof(p->m_data.first), boost::forward<KeyConvertible>(key));
       BOOST_TRY{
-         node_allocator_traits_type::construct(na, container_detail::addressof(p->m_data.second));
+         node_allocator_traits_type::construct(na, dtl::addressof(p->m_data.second));
       }
       BOOST_CATCH(...){
-         node_allocator_traits_type::destroy(na, container_detail::addressof(p->m_data.first));
+         node_allocator_traits_type::destroy(na, dtl::addressof(p->m_data.first));
          BOOST_RETHROW;
       }
       BOOST_CATCH_END
@@ -243,8 +243,8 @@ struct node_alloc_holder
    void swap(node_alloc_holder &x)
    {
       this->icont().swap(x.icont());
-      container_detail::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
-      container_detail::swap_alloc(this->node_alloc(), x.node_alloc(), flag);
+      dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
+      dtl::swap_alloc(this->node_alloc(), x.node_alloc(), flag);
    }
 
    template<class FwdIterator, class Inserter>
@@ -264,13 +264,13 @@ struct node_alloc_holder
          Node *p = 0;
          BOOST_TRY{
             Deallocator node_deallocator(NodePtr(), nalloc);
-            container_detail::scoped_destructor<NodeAlloc> sdestructor(nalloc, 0);
+            dtl::scoped_destructor<NodeAlloc> sdestructor(nalloc, 0);
             while(n--){
                p = boost::movelib::iterator_to_raw_pointer(itbeg);
                node_deallocator.set(p);
                ++itbeg;
                //This can throw
-               boost::container::construct_in_place(nalloc, container_detail::addressof(p->m_data), beg);
+               boost::container::construct_in_place(nalloc, dtl::addressof(p->m_data), beg);
                sdestructor.set(p);
                ++beg;
                //This does not throw
@@ -410,7 +410,7 @@ struct node_alloc_holder
    {  return this->members_.m_icont;   }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/node_pool.hpp

@@ -32,7 +32,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 //!Pooled memory allocator using single segregated storage. Includes
 //!a reference count but the class does not delete itself, this is
@@ -41,10 +41,10 @@ namespace container_detail {
 template< std::size_t NodeSize, std::size_t NodesPerBlock >
 class private_node_pool
    //Inherit from the implementation to avoid template bloat
-   :  public boost::container::container_detail::
+   :  public boost::container::dtl::
          private_node_pool_impl<fake_segment_manager>
 {
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       private_node_pool_impl<fake_segment_manager>   base_t;
    //Non-copyable
    private_node_pool(const private_node_pool &);
@@ -148,7 +148,7 @@ class shared_node_pool
    default_mutex mutex_;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/node_pool_impl.hpp

@@ -38,7 +38,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class SegmentManagerBase>
 class private_node_pool_impl
@@ -366,7 +366,7 @@ class private_node_pool_impl
 };
 
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/pair.hpp

@@ -74,7 +74,7 @@ struct is_boost_tuple< boost::tuples::tuple<T0, T1, T2, T3, T4, T5, T6, T7, T8,
 
 template<class Tuple>
 struct disable_if_boost_tuple
-   : boost::container::container_detail::disable_if< is_boost_tuple<Tuple> >
+   : boost::container::dtl::disable_if< is_boost_tuple<Tuple> >
 {};
 
 template<class T>
@@ -133,7 +133,7 @@ static piecewise_construct_t piecewise_construct = BOOST_CONTAINER_DOC1ST(unspec
 
 ///@cond
 
-namespace container_detail {
+namespace dtl {
 
 struct piecewise_construct_use
 {
@@ -283,7 +283,7 @@ struct pair
    pair( piecewise_construct_t\
        , BoostTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::boost::tuples::null_type)> p\
        , BoostTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,M),::boost::tuples::null_type)> q\
-       , typename container_detail::enable_if_c\
+       , typename dtl::enable_if_c\
          < pair_impl::is_boost_tuple< BoostTuple<BOOST_MOVE_TARG##N  BOOST_MOVE_I##N BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(10,N),::boost::tuples::null_type)> >::value &&\
            !(pair_impl::is_tuple_null<BOOST_MOVE_LAST_TARG##N>::value || pair_impl::is_tuple_null<BOOST_MOVE_LAST_TARGQ##M>::value) \
          >::type* = 0\
@@ -381,10 +381,10 @@ struct pair
    }
 
    template <class D, class S>
-   typename ::boost::container::container_detail::disable_if_or
+   typename ::boost::container::dtl::disable_if_or
       < pair &
-      , ::boost::container::container_detail::is_same<T1, D>
-      , ::boost::container::container_detail::is_same<T2, S>
+      , ::boost::container::dtl::is_same<T1, D>
+      , ::boost::container::dtl::is_same<T2, S>
       >::type
       operator=(const pair<D, S>&p)
    {
@@ -394,10 +394,10 @@ struct pair
    }
 
    template <class D, class S>
-   typename ::boost::container::container_detail::disable_if_or
+   typename ::boost::container::dtl::disable_if_or
       < pair &
-      , ::boost::container::container_detail::is_same<T1, D>
-      , ::boost::container::container_detail::is_same<T2, S>
+      , ::boost::container::dtl::is_same<T1, D>
+      , ::boost::container::dtl::is_same<T2, S>
       >::type
       operator=(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p)
    {
@@ -478,13 +478,13 @@ template <class T1, class T2>
 inline void swap(pair<T1, T2>& x, pair<T1, T2>& y)
 {  x.swap(y);  }
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 
 #ifdef BOOST_NO_CXX11_RVALUE_REFERENCES
 
 template<class T1, class T2>
-struct has_move_emulation_enabled< ::boost::container::container_detail::pair<T1, T2> >
+struct has_move_emulation_enabled< ::boost::container::dtl::pair<T1, T2> >
 {
    static const bool value = true;
 };
@@ -497,7 +497,7 @@ template<class T>
 struct is_class_or_union;
 
 template <class T1, class T2>
-struct is_class_or_union< ::boost::container::container_detail::pair<T1, T2> >
+struct is_class_or_union< ::boost::container::dtl::pair<T1, T2> >
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 {
@@ -516,7 +516,7 @@ template<class T>
 struct is_union;
 
 template <class T1, class T2>
-struct is_union< ::boost::container::container_detail::pair<T1, T2> >
+struct is_union< ::boost::container::dtl::pair<T1, T2> >
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 {
@@ -535,7 +535,7 @@ template<class T>
 struct is_class;
 
 template <class T1, class T2>
-struct is_class< ::boost::container::container_detail::pair<T1, T2> >
+struct is_class< ::boost::container::dtl::pair<T1, T2> >
 //This specialization is needed to avoid instantiation of pair in
 //is_class, and allow recursive maps.
 {

include/boost/container/detail/pool_common.hpp

@@ -26,7 +26,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class VoidPointer>
 struct node_slist
@@ -48,7 +48,7 @@ struct is_stateless_segment_manager
    static const bool value = false;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/pool_common_alloc.hpp

@@ -30,10 +30,10 @@
 
 namespace boost{
 namespace container{
-namespace container_detail{
+namespace dtl{
 
 struct node_slist_helper
-   : public boost::container::container_detail::node_slist<void*>
+   : public boost::container::dtl::node_slist<void*>
 {};
 
 struct fake_segment_manager
@@ -41,7 +41,7 @@ struct fake_segment_manager
    typedef void * void_pointer;
    static const std::size_t PayloadPerAllocation = BOOST_CONTAINER_ALLOCATION_PAYLOAD;
 
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       basic_multiallocation_chain<void*>              multiallocation_chain;
    static void deallocate(void_pointer p)
    { dlmalloc_free(p); }
@@ -77,23 +77,23 @@ struct fake_segment_manager
 
 }  //namespace boost{
 }  //namespace container{
-}  //namespace container_detail{
+}  //namespace dtl{
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class T>
 struct is_stateless_segment_manager;
 
 template<>
 struct is_stateless_segment_manager
-   <boost::container::container_detail::fake_segment_manager>
+   <boost::container::dtl::fake_segment_manager>
 {
    static const bool value = true;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/singleton.hpp

@@ -69,7 +69,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 // T must be: no-throw default constructible and no-throw destructible
 template <typename T>
@@ -112,7 +112,7 @@ template <typename T>
 typename singleton_default<T>::object_creator
 singleton_default<T>::create_object;
 
-} // namespace container_detail
+} // namespace dtl
 } // namespace container
 } // namespace boost
 

include/boost/container/detail/transform_iterator.hpp

@@ -63,7 +63,7 @@ class transform_iterator
    : public UnaryFunction
    , public boost::container::iterator
       < typename Iterator::iterator_category
-      , typename container_detail::remove_reference<typename UnaryFunction::result_type>::type
+      , typename dtl::remove_reference<typename UnaryFunction::result_type>::type
       , typename Iterator::difference_type
       , operator_arrow_proxy<typename UnaryFunction::result_type>
       , typename UnaryFunction::result_type>

include/boost/container/detail/tree.hpp

@@ -61,7 +61,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 using boost::intrusive::tree_value_compare;
 
@@ -71,38 +71,38 @@ struct intrusive_tree_hook;
 template<class VoidPointer, bool OptimizeSize>
 struct intrusive_tree_hook<VoidPointer, boost::container::red_black_tree, OptimizeSize>
 {
-   typedef typename container_detail::bi::make_set_base_hook
-      < container_detail::bi::void_pointer<VoidPointer>
-      , container_detail::bi::link_mode<container_detail::bi::normal_link>
-      , container_detail::bi::optimize_size<OptimizeSize>
+   typedef typename dtl::bi::make_set_base_hook
+      < dtl::bi::void_pointer<VoidPointer>
+      , dtl::bi::link_mode<dtl::bi::normal_link>
+      , dtl::bi::optimize_size<OptimizeSize>
       >::type  type;
 };
 
 template<class VoidPointer, bool OptimizeSize>
 struct intrusive_tree_hook<VoidPointer, boost::container::avl_tree, OptimizeSize>
 {
-   typedef typename container_detail::bi::make_avl_set_base_hook
-      < container_detail::bi::void_pointer<VoidPointer>
-      , container_detail::bi::link_mode<container_detail::bi::normal_link>
-      , container_detail::bi::optimize_size<OptimizeSize>
+   typedef typename dtl::bi::make_avl_set_base_hook
+      < dtl::bi::void_pointer<VoidPointer>
+      , dtl::bi::link_mode<dtl::bi::normal_link>
+      , dtl::bi::optimize_size<OptimizeSize>
       >::type  type;
 };
 
 template<class VoidPointer, bool OptimizeSize>
 struct intrusive_tree_hook<VoidPointer, boost::container::scapegoat_tree, OptimizeSize>
 {
-   typedef typename container_detail::bi::make_bs_set_base_hook
-      < container_detail::bi::void_pointer<VoidPointer>
-      , container_detail::bi::link_mode<container_detail::bi::normal_link>
+   typedef typename dtl::bi::make_bs_set_base_hook
+      < dtl::bi::void_pointer<VoidPointer>
+      , dtl::bi::link_mode<dtl::bi::normal_link>
       >::type  type;
 };
 
 template<class VoidPointer, bool OptimizeSize>
 struct intrusive_tree_hook<VoidPointer, boost::container::splay_tree, OptimizeSize>
 {
-   typedef typename container_detail::bi::make_bs_set_base_hook
-      < container_detail::bi::void_pointer<VoidPointer>
-      , container_detail::bi::link_mode<container_detail::bi::normal_link>
+   typedef typename dtl::bi::make_bs_set_base_hook
+      < dtl::bi::void_pointer<VoidPointer>
+      , dtl::bi::link_mode<dtl::bi::normal_link>
       >::type  type;
 };
 
@@ -222,9 +222,9 @@ class push_back_functor
    {  this->icont_.push_back(n); }
 };
 
-}//namespace container_detail {
+}//namespace dtl {
 
-namespace container_detail {
+namespace dtl {
 
 template< class NodeType, class NodeCompareType
         , class SizeType,  class HookType
@@ -235,12 +235,12 @@ template<class NodeType, class NodeCompareType, class SizeType, class HookType>
 struct intrusive_tree_dispatch
    <NodeType, NodeCompareType, SizeType, HookType, boost::container::red_black_tree>
 {
-   typedef typename container_detail::bi::make_rbtree
+   typedef typename dtl::bi::make_rbtree
       <NodeType
-      ,container_detail::bi::compare<NodeCompareType>
-      ,container_detail::bi::base_hook<HookType>
-      ,container_detail::bi::constant_time_size<true>
-      ,container_detail::bi::size_type<SizeType>
+      ,dtl::bi::compare<NodeCompareType>
+      ,dtl::bi::base_hook<HookType>
+      ,dtl::bi::constant_time_size<true>
+      ,dtl::bi::size_type<SizeType>
       >::type  type;
 };
 
@@ -248,12 +248,12 @@ template<class NodeType, class NodeCompareType, class SizeType, class HookType>
 struct intrusive_tree_dispatch
    <NodeType, NodeCompareType, SizeType, HookType, boost::container::avl_tree>
 {
-   typedef typename container_detail::bi::make_avltree
+   typedef typename dtl::bi::make_avltree
       <NodeType
-      ,container_detail::bi::compare<NodeCompareType>
-      ,container_detail::bi::base_hook<HookType>
-      ,container_detail::bi::constant_time_size<true>
-      ,container_detail::bi::size_type<SizeType>
+      ,dtl::bi::compare<NodeCompareType>
+      ,dtl::bi::base_hook<HookType>
+      ,dtl::bi::constant_time_size<true>
+      ,dtl::bi::size_type<SizeType>
       >::type  type;
 };
 
@@ -261,12 +261,12 @@ template<class NodeType, class NodeCompareType, class SizeType, class HookType>
 struct intrusive_tree_dispatch
    <NodeType, NodeCompareType, SizeType, HookType, boost::container::scapegoat_tree>
 {
-   typedef typename container_detail::bi::make_sgtree
+   typedef typename dtl::bi::make_sgtree
       <NodeType
-      ,container_detail::bi::compare<NodeCompareType>
-      ,container_detail::bi::base_hook<HookType>
-      ,container_detail::bi::floating_point<true>
-      ,container_detail::bi::size_type<SizeType>
+      ,dtl::bi::compare<NodeCompareType>
+      ,dtl::bi::base_hook<HookType>
+      ,dtl::bi::floating_point<true>
+      ,dtl::bi::size_type<SizeType>
       >::type  type;
 };
 
@@ -274,12 +274,12 @@ template<class NodeType, class NodeCompareType, class SizeType, class HookType>
 struct intrusive_tree_dispatch
    <NodeType, NodeCompareType, SizeType, HookType, boost::container::splay_tree>
 {
-   typedef typename container_detail::bi::make_splaytree
+   typedef typename dtl::bi::make_splaytree
       <NodeType
-      ,container_detail::bi::compare<NodeCompareType>
-      ,container_detail::bi::base_hook<HookType>
-      ,container_detail::bi::constant_time_size<true>
-      ,container_detail::bi::size_type<SizeType>
+      ,dtl::bi::compare<NodeCompareType>
+      ,dtl::bi::base_hook<HookType>
+      ,dtl::bi::constant_time_size<true>
+      ,dtl::bi::size_type<SizeType>
       >::type  type;
 };
 
@@ -293,7 +293,7 @@ struct intrusive_tree_type
       allocator_traits<Allocator>::void_pointer            void_pointer;
    typedef typename boost::container::
       allocator_traits<Allocator>::size_type               size_type;
-   typedef typename container_detail::tree_node
+   typedef typename dtl::tree_node
          < value_type, void_pointer
          , tree_type_value, OptimizeSize>                   node_t;
    typedef value_to_node_compare
@@ -340,9 +340,9 @@ struct intrusive_tree_proxy<tree_type_value, true>
    {  c.rebalance(); }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
-namespace container_detail {
+namespace dtl {
 
 //This functor will be used with Intrusive clone functions to obtain
 //already allocated nodes from a intrusive container instead of
@@ -433,9 +433,9 @@ template <class T, class KeyOfValue,
           class Compare, class Allocator,
           class Options = tree_assoc_defaults>
 class tree
-   : public container_detail::node_alloc_holder
+   : public dtl::node_alloc_holder
       < Allocator
-      , typename container_detail::intrusive_tree_type
+      , typename dtl::intrusive_tree_type
          < Allocator, tree_value_compare
             <typename allocator_traits<Allocator>::pointer, Compare, KeyOfValue>
          , Options::tree_type, Options::optimize_size>::type
@@ -444,10 +444,10 @@ class tree
    typedef tree_value_compare
       < typename allocator_traits<Allocator>::pointer
       , Compare, KeyOfValue>                                ValComp;
-   typedef typename container_detail::intrusive_tree_type
+   typedef typename dtl::intrusive_tree_type
          < Allocator, ValComp, Options::tree_type
          , Options::optimize_size>::type                    Icont;
-   typedef container_detail::node_alloc_holder
+   typedef dtl::node_alloc_holder
       <Allocator, Icont>                                    AllocHolder;
    typedef typename AllocHolder::NodePtr                    NodePtr;
    typedef tree < T, KeyOfValue
@@ -459,7 +459,7 @@ class tree
    typedef typename AllocHolder::Node                       Node;
    typedef typename Icont::iterator                         iiterator;
    typedef typename Icont::const_iterator                   iconst_iterator;
-   typedef container_detail::allocator_destroyer<NodeAlloc> Destroyer;
+   typedef dtl::allocator_destroyer<NodeAlloc> Destroyer;
    typedef typename AllocHolder::alloc_version              alloc_version;
    typedef intrusive_tree_proxy<Options::tree_type>         intrusive_tree_proxy_t;
 
@@ -484,9 +484,9 @@ class tree
       allocator_traits<Allocator>::size_type          size_type;
    typedef typename boost::container::
       allocator_traits<Allocator>::difference_type    difference_type;
-   typedef container_detail::iterator_from_iiterator
+   typedef dtl::iterator_from_iiterator
       <iiterator, false>                              iterator;
-   typedef container_detail::iterator_from_iiterator
+   typedef dtl::iterator_from_iiterator
       <iiterator, true >                              const_iterator;
    typedef boost::container::reverse_iterator
       <iterator>                                      reverse_iterator;
@@ -590,10 +590,10 @@ class tree
    template <class InputIterator>
    void tree_construct_non_unique(InputIterator first, InputIterator last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_or
+      , typename dtl::enable_if_or
          < void
-         , container_detail::is_same<alloc_version, version_1>
-         , container_detail::is_input_iterator<InputIterator>
+         , dtl::is_same<alloc_version, version_1>
+         , dtl::is_input_iterator<InputIterator>
          >::type * = 0
       #endif
          )
@@ -610,10 +610,10 @@ class tree
    template <class InputIterator>
    void tree_construct_non_unique(InputIterator first, InputIterator last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_same<alloc_version, version_1>
-         , container_detail::is_input_iterator<InputIterator>
+         , dtl::is_same<alloc_version, version_1>
+         , dtl::is_input_iterator<InputIterator>
          >::type * = 0
       #endif
          )
@@ -627,10 +627,10 @@ class tree
    template <class InputIterator>
    void tree_construct( ordered_range_t, InputIterator first, InputIterator last
          #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_same<alloc_version, version_1>
-         , container_detail::is_input_iterator<InputIterator>
+         , dtl::is_same<alloc_version, version_1>
+         , dtl::is_input_iterator<InputIterator>
          >::type * = 0
          #endif
          )
@@ -638,17 +638,17 @@ class tree
       //Optimized allocation and construction
       this->allocate_many_and_construct
          ( first, boost::container::iterator_distance(first, last)
-         , container_detail::push_back_functor<Node, Icont>(this->icont()));
+         , dtl::push_back_functor<Node, Icont>(this->icont()));
       //AllocHolder clears in case of exception
    }
 
    template <class InputIterator>
    void tree_construct( ordered_range_t, InputIterator first, InputIterator last
          #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_or
+      , typename dtl::enable_if_or
          < void
-         , container_detail::is_same<alloc_version, version_1>
-         , container_detail::is_input_iterator<InputIterator>
+         , dtl::is_same<alloc_version, version_1>
+         , dtl::is_input_iterator<InputIterator>
          >::type * = 0
          #endif
          )
@@ -668,7 +668,7 @@ class tree
    }
 
    BOOST_CONTAINER_FORCEINLINE tree(BOOST_RV_REF(tree) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       :  AllocHolder(BOOST_MOVE_BASE(AllocHolder, x), x.value_comp())
    {}
 
@@ -701,7 +701,7 @@ class tree
       if (&x != this){
          NodeAlloc &this_alloc     = this->get_stored_allocator();
          const NodeAlloc &x_alloc  = x.get_stored_allocator();
-         container_detail::bool_<allocator_traits<NodeAlloc>::
+         dtl::bool_<allocator_traits<NodeAlloc>::
             propagate_on_container_copy_assignment::value> flag;
          if(flag && this_alloc != x_alloc){
             this->clear();
@@ -730,7 +730,7 @@ class tree
    tree& operator=(BOOST_RV_REF(tree) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {
       BOOST_ASSERT(this != &x);
       NodeAlloc &this_alloc = this->node_alloc();
@@ -856,7 +856,7 @@ class tree
 
    BOOST_CONTAINER_FORCEINLINE void swap(ThisType& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value )
    {  AllocHolder::swap(x);   }
 
    public:
@@ -1315,7 +1315,7 @@ class tree
    {  x.swap(y);  }
 };
 
-} //namespace container_detail {
+} //namespace dtl {
 } //namespace container {
 
 template <class T>
@@ -1326,7 +1326,7 @@ struct has_trivial_destructor_after_move;
 template <class T, class KeyOfValue, class Compare, class Allocator, class Options>
 struct has_trivial_destructor_after_move
    < 
-      ::boost::container::container_detail::tree
+      ::boost::container::dtl::tree
          <T, KeyOfValue, Compare, Allocator, Options>
    >
 {

include/boost/container/detail/type_traits.hpp

@@ -28,7 +28,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 using ::boost::move_detail::enable_if;
 using ::boost::move_detail::enable_if_and;
@@ -63,7 +63,7 @@ using ::boost::move_detail::aligned_storage;
 using ::boost::move_detail::nat;
 using ::boost::move_detail::max_align_t;
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/value_init.hpp

@@ -26,7 +26,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<class T>
 struct value_init
@@ -42,7 +42,7 @@ struct value_init
    T m_t;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {
 

include/boost/container/detail/variadic_templates_tools.hpp

@@ -28,7 +28,7 @@
 
 namespace boost {
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template<typename... Values>
 class tuple;
@@ -156,7 +156,7 @@ struct build_number_seq
 template<> struct build_number_seq<0> : index_tuple<>{};
 template<> struct build_number_seq<1> : index_tuple<0>{};
 
-}}}   //namespace boost { namespace container { namespace container_detail {
+}}}   //namespace boost { namespace container { namespace dtl {
 
 #include <boost/container/detail/config_end.hpp>
 

include/boost/container/detail/version_type.hpp

@@ -32,11 +32,11 @@
 
 namespace boost{
 namespace container {
-namespace container_detail {
+namespace dtl {
 
 template <class T, unsigned V>
 struct version_type
-    : public container_detail::integral_constant<unsigned, V>
+    : public dtl::integral_constant<unsigned, V>
 {
     typedef T type;
 
@@ -46,7 +46,7 @@ struct version_type
 namespace impl{
 
 template <class T,
-          bool = container_detail::is_convertible<version_type<T, 0>, typename T::version>::value>
+          bool = dtl::is_convertible<version_type<T, 0>, typename T::version>::value>
 struct extract_version
 {
    static const unsigned value = 1;
@@ -86,7 +86,7 @@ struct version<T, true>
 
 template <class T>
 struct version
-   : public container_detail::integral_constant<unsigned, impl::version<T>::value>
+   : public dtl::integral_constant<unsigned, impl::version<T>::value>
 {};
 
 template<class T, unsigned N>
@@ -96,11 +96,11 @@ struct is_version
       is_same< typename version<T>::type, integral_constant<unsigned, N> >::value;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
-typedef container_detail::integral_constant<unsigned, 0> version_0;
-typedef container_detail::integral_constant<unsigned, 1> version_1;
-typedef container_detail::integral_constant<unsigned, 2> version_2;
+typedef dtl::integral_constant<unsigned, 0> version_0;
+typedef dtl::integral_constant<unsigned, 1> version_1;
+typedef dtl::integral_constant<unsigned, 2> version_2;
 
 }  //namespace container {
 }  //namespace boost{

include/boost/container/flat_set.hpp

@@ -80,13 +80,13 @@ template <class Key, class Compare, class AllocatorOrContainer>
 #endif
 class flat_set
    ///@cond
-   : public container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, AllocatorOrContainer>
+   : public dtl::flat_tree<Key, dtl::identity<Key>, Compare, AllocatorOrContainer>
    ///@endcond
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_set)
-   typedef container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, AllocatorOrContainer> tree_t;
+   typedef dtl::flat_tree<Key, dtl::identity<Key>, Compare, AllocatorOrContainer> tree_t;
 
    public:
    tree_t &tree()
@@ -134,8 +134,8 @@ class flat_set
    //!
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_FORCEINLINE
-   flat_set() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
-                                container_detail::is_nothrow_default_constructible<Compare>::value)
+   flat_set() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
+                                dtl::is_nothrow_default_constructible<Compare>::value)
       : tree_t()
    {}
 
@@ -350,7 +350,7 @@ class flat_set
    //!
    //! <b>Postcondition</b>: x is emptied.
    BOOST_CONTAINER_FORCEINLINE flat_set(BOOST_RV_REF(flat_set) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : tree_t(BOOST_MOVE_BASE(tree_t, x))
    {}
 
@@ -384,7 +384,7 @@ class flat_set
    BOOST_CONTAINER_FORCEINLINE flat_set& operator=(BOOST_RV_REF(flat_set) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {  return static_cast<flat_set&>(this->tree_t::operator=(BOOST_MOVE_BASE(tree_t, x)));  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -794,7 +794,7 @@ class flat_set
    //! <b>Complexity</b>: Constant.
    void swap(flat_set& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value );
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value );
 
    //! <b>Effects</b>: erase(a.begin(),a.end()).
    //!
@@ -1052,13 +1052,13 @@ template <class Key, class Compare, class AllocatorOrContainer>
 #endif
 class flat_multiset
    ///@cond
-   : public container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, AllocatorOrContainer>
+   : public dtl::flat_tree<Key, dtl::identity<Key>, Compare, AllocatorOrContainer>
    ///@endcond
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    BOOST_COPYABLE_AND_MOVABLE(flat_multiset)
-   typedef container_detail::flat_tree<Key, container_detail::identity<Key>, Compare, AllocatorOrContainer> tree_t;
+   typedef dtl::flat_tree<Key, dtl::identity<Key>, Compare, AllocatorOrContainer> tree_t;
 
    public:
    tree_t &tree()
@@ -1095,8 +1095,8 @@ class flat_multiset
    typedef typename sequence_type::const_reverse_iterator                           const_reverse_iterator;
 
    //! @copydoc ::boost::container::flat_set::flat_set()
-   BOOST_CONTAINER_FORCEINLINE flat_multiset() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
-                                                                 container_detail::is_nothrow_default_constructible<Compare>::value)
+   BOOST_CONTAINER_FORCEINLINE flat_multiset() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<AllocatorOrContainer>::value &&
+                                                                 dtl::is_nothrow_default_constructible<Compare>::value)
       : tree_t()
    {}
 
@@ -1249,7 +1249,7 @@ class flat_multiset
 
    //! @copydoc ::boost::container::flat_set::flat_set(flat_set &&)
    BOOST_CONTAINER_FORCEINLINE flat_multiset(BOOST_RV_REF(flat_multiset) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : tree_t(boost::move(static_cast<tree_t&>(x)))
    {}
 
@@ -1271,7 +1271,7 @@ class flat_multiset
    BOOST_CONTAINER_FORCEINLINE flat_multiset& operator=(BOOST_RV_REF(flat_multiset) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {  return static_cast<flat_multiset&>(this->tree_t::operator=(BOOST_MOVE_BASE(tree_t, x)));  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -1535,7 +1535,7 @@ class flat_multiset
    //! @copydoc ::boost::container::flat_set::swap
    void swap(flat_multiset& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value );
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value );
 
    //! @copydoc ::boost::container::flat_set::clear
    void clear() BOOST_NOEXCEPT_OR_NOTHROW;

include/boost/container/list.hpp

@@ -57,13 +57,13 @@ namespace boost {
 namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-namespace container_detail {
+namespace dtl {
 
 template<class VoidPointer>
 struct list_hook
 {
-   typedef typename container_detail::bi::make_list_base_hook
-      <container_detail::bi::void_pointer<VoidPointer>, container_detail::bi::link_mode<container_detail::bi::normal_link> >::type type;
+   typedef typename dtl::bi::make_list_base_hook
+      <dtl::bi::void_pointer<VoidPointer>, dtl::bi::link_mode<dtl::bi::normal_link> >::type type;
 };
 
 template <class T, class VoidPointer>
@@ -100,19 +100,19 @@ struct intrusive_list_type
       <typename allocator_traits_type::pointer>::template
          rebind_pointer<void>::type
             void_pointer;
-   typedef typename container_detail::list_node
+   typedef typename dtl::list_node
          <value_type, void_pointer>             node_type;
-   typedef typename container_detail::bi::make_list
+   typedef typename dtl::bi::make_list
       < node_type
-      , container_detail::bi::base_hook<typename list_hook<void_pointer>::type>
-      , container_detail::bi::constant_time_size<true>
-      , container_detail::bi::size_type
+      , dtl::bi::base_hook<typename list_hook<void_pointer>::type>
+      , dtl::bi::constant_time_size<true>
+      , dtl::bi::size_type
          <typename allocator_traits_type::size_type>
       >::type                                   container_type;
    typedef container_type                       type ;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 //! A list is a doubly linked list. That is, it is a Sequence that supports both
@@ -134,26 +134,26 @@ template <class T, class Allocator = new_allocator<T> >
 template <class T, class Allocator>
 #endif
 class list
-   : protected container_detail::node_alloc_holder
-      <Allocator, typename container_detail::intrusive_list_type<Allocator>::type>
+   : protected dtl::node_alloc_holder
+      <Allocator, typename dtl::intrusive_list_type<Allocator>::type>
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    typedef typename
-      container_detail::intrusive_list_type<Allocator>::type Icont;
-   typedef container_detail::node_alloc_holder<Allocator, Icont>  AllocHolder;
+      dtl::intrusive_list_type<Allocator>::type Icont;
+   typedef dtl::node_alloc_holder<Allocator, Icont>  AllocHolder;
    typedef typename AllocHolder::NodePtr                          NodePtr;
    typedef typename AllocHolder::NodeAlloc                        NodeAlloc;
    typedef typename AllocHolder::ValAlloc                         ValAlloc;
    typedef typename AllocHolder::Node                             Node;
-   typedef container_detail::allocator_destroyer<NodeAlloc>       Destroyer;
+   typedef dtl::allocator_destroyer<NodeAlloc>       Destroyer;
    typedef typename AllocHolder::alloc_version                    alloc_version;
    typedef boost::container::allocator_traits<Allocator>          allocator_traits_type;
    typedef boost::container::equal_to_value<Allocator>            equal_to_value_type;
 
    BOOST_COPYABLE_AND_MOVABLE(list)
 
-   typedef container_detail::iterator_from_iiterator<typename Icont::iterator, false>  iterator_impl;
-   typedef container_detail::iterator_from_iiterator<typename Icont::iterator, true>   const_iterator_impl;
+   typedef dtl::iterator_from_iiterator<typename Icont::iterator, false>  iterator_impl;
+   typedef dtl::iterator_from_iiterator<typename Icont::iterator, true>   const_iterator_impl;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
@@ -188,7 +188,7 @@ class list
    //! <b>Throws</b>: If allocator_type's default constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   list() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+   list() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : AllocHolder()
    {}
 
@@ -331,7 +331,7 @@ class list
       if (&x != this){
          NodeAlloc &this_alloc     = this->node_alloc();
          const NodeAlloc &x_alloc  = x.node_alloc();
-         container_detail::bool_<allocator_traits_type::
+         dtl::bool_<allocator_traits_type::
             propagate_on_container_copy_assignment::value> flag;
          if(flag && this_alloc != x_alloc){
             this->clear();
@@ -417,7 +417,7 @@ class list
    template <class InpIt>
    void assign(InpIt first, InpIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_convertible<InpIt, size_type>::type * = 0
+      , typename dtl::disable_if_convertible<InpIt, size_type>::type * = 0
       #endif
       )
    {
@@ -866,10 +866,10 @@ class list
    template <class InpIt>
    iterator insert(const_iterator p, InpIt first, InpIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < !container_detail::is_convertible<InpIt, size_type>::value
-            && (container_detail::is_input_iterator<InpIt>::value
-                || container_detail::is_same<alloc_version, version_1>::value
+      , typename dtl::enable_if_c
+         < !dtl::is_convertible<InpIt, size_type>::value
+            && (dtl::is_input_iterator<InpIt>::value
+                || dtl::is_same<alloc_version, version_1>::value
                )
          >::type * = 0
       #endif
@@ -891,10 +891,10 @@ class list
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
    iterator insert(const_iterator position, FwdIt first, FwdIt last
-      , typename container_detail::enable_if_c
-         < !container_detail::is_convertible<FwdIt, size_type>::value
-            && !(container_detail::is_input_iterator<FwdIt>::value
-                || container_detail::is_same<alloc_version, version_1>::value
+      , typename dtl::enable_if_c
+         < !dtl::is_convertible<FwdIt, size_type>::value
+            && !(dtl::is_input_iterator<FwdIt>::value
+                || dtl::is_same<alloc_version, version_1>::value
                )
          >::type * = 0
       )

include/boost/container/map.hpp

@@ -78,9 +78,9 @@ template <class Key, class T, class Compare, class Allocator, class Options>
 #endif
 class map
    ///@cond
-   : public container_detail::tree
+   : public dtl::tree
       < std::pair<const Key, T>
-      , container_detail::select1st<Key>
+      , dtl::select1st<Key>
       , Compare, Allocator, Options>
    ///@endcond
 {
@@ -88,11 +88,11 @@ class map
    private:
    BOOST_COPYABLE_AND_MOVABLE(map)
 
-   typedef container_detail::select1st<Key>                                select_1st_t;
+   typedef dtl::select1st<Key>                                select_1st_t;
    typedef std::pair<const Key, T>                                         value_type_impl;
-   typedef container_detail::tree
+   typedef dtl::tree
       <value_type_impl, select_1st_t, Compare, Allocator, Options>         base_t;
-   typedef container_detail::pair <Key, T>                                 movable_value_type_impl;
+   typedef dtl::pair <Key, T>                                 movable_value_type_impl;
    typedef typename base_t::value_compare                                  value_compare_impl;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -131,7 +131,7 @@ class map
       (insert_return_type_base<iterator BOOST_MOVE_I node_type>)                    insert_return_type;
 
    //allocator_type::value_type type must be std::pair<CONST Key, T>
-   BOOST_STATIC_ASSERT((container_detail::is_same<typename allocator_type::value_type, std::pair<const Key, T> >::value));
+   BOOST_STATIC_ASSERT((dtl::is_same<typename allocator_type::value_type, std::pair<const Key, T> >::value));
 
    //////////////////////////////////////////////
    //
@@ -143,8 +143,8 @@ class map
    //!
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_FORCEINLINE 
-   map() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                           container_detail::is_nothrow_default_constructible<Compare>::value)
+   map() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value &&
+                           dtl::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
@@ -350,7 +350,7 @@ class map
    //!
    //! <b>Postcondition</b>: x is emptied.
    BOOST_CONTAINER_FORCEINLINE map(BOOST_RV_REF(map) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
 
@@ -388,7 +388,7 @@ class map
    BOOST_CONTAINER_FORCEINLINE map& operator=(BOOST_RV_REF(map) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {  return static_cast<map&>(this->base_t::operator=(BOOST_MOVE_BASE(base_t, x)));  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -1014,7 +1014,7 @@ class map
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(map<Key, T, C2, Allocator, Options>& source)
    {
-      typedef container_detail::tree
+      typedef dtl::tree
          <value_type_impl, select_1st_t, C2, Allocator, Options> base2_t;
       this->merge_unique(static_cast<base2_t&>(source));
    }
@@ -1028,7 +1028,7 @@ class map
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(multimap<Key, T, C2, Allocator, Options>& source)
    {
-      typedef container_detail::tree
+      typedef dtl::tree
          <value_type_impl, select_1st_t, C2, Allocator, Options> base2_t;
       this->base_t::merge_unique(static_cast<base2_t&>(source));
    }
@@ -1046,7 +1046,7 @@ class map
    //! <b>Complexity</b>: Constant.
    void swap(map& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value )
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value )
 
    //! <b>Effects</b>: erase(a.begin(),a.end()).
    //!
@@ -1219,9 +1219,9 @@ template <class Key, class T, class Compare, class Allocator, class Options>
 #endif
 class multimap
    ///@cond
-   : public container_detail::tree
+   : public dtl::tree
       < std::pair<const Key, T>
-      , container_detail::select1st<Key>
+      , dtl::select1st<Key>
       , Compare, Allocator, Options>
    ///@endcond
 {
@@ -1229,11 +1229,11 @@ class multimap
    private:
    BOOST_COPYABLE_AND_MOVABLE(multimap)
 
-   typedef container_detail::select1st<Key>                                      select_1st_t;
+   typedef dtl::select1st<Key>                                      select_1st_t;
    typedef std::pair<const Key, T>                                               value_type_impl;
-   typedef container_detail::tree
+   typedef dtl::tree
       <value_type_impl, select_1st_t, Compare, Allocator, Options>               base_t;
-   typedef container_detail::pair <Key, T>                                       movable_value_type_impl;
+   typedef dtl::pair <Key, T>                                       movable_value_type_impl;
    typedef typename base_t::value_compare                                        value_compare_impl;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -1271,7 +1271,7 @@ class multimap
          <key_type BOOST_MOVE_I mapped_type> >)                                     node_type;
 
    //allocator_type::value_type type must be std::pair<CONST Key, T>
-   BOOST_STATIC_ASSERT((container_detail::is_same<typename allocator_type::value_type, std::pair<const Key, T> >::value));
+   BOOST_STATIC_ASSERT((dtl::is_same<typename allocator_type::value_type, std::pair<const Key, T> >::value));
 
    //////////////////////////////////////////////
    //
@@ -1283,8 +1283,8 @@ class multimap
    //!
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_FORCEINLINE multimap()
-      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                        container_detail::is_nothrow_default_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value &&
+                        dtl::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
@@ -1486,7 +1486,7 @@ class multimap
    //!
    //! <b>Postcondition</b>: x is emptied.
    BOOST_CONTAINER_FORCEINLINE multimap(BOOST_RV_REF(multimap) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
 
@@ -1518,7 +1518,7 @@ class multimap
    BOOST_CONTAINER_FORCEINLINE multimap& operator=(BOOST_RV_REF(multimap) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {  return static_cast<multimap&>(this->base_t::operator=(BOOST_MOVE_BASE(base_t, x)));  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -1790,7 +1790,7 @@ class multimap
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(multimap<Key, T, C2, Allocator, Options>& source)
    {
-      typedef container_detail::tree
+      typedef dtl::tree
          <value_type_impl, select_1st_t, C2, Allocator, Options> base2_t;
       this->base_t::merge_equal(static_cast<base2_t&>(source));
    }
@@ -1804,7 +1804,7 @@ class multimap
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(map<Key, T, C2, Allocator, Options>& source)
    {
-      typedef container_detail::tree
+      typedef dtl::tree
          <value_type_impl, select_1st_t, C2, Allocator, Options> base2_t;
       this->base_t::merge_equal(static_cast<base2_t&>(source));
    }
@@ -1818,7 +1818,7 @@ class multimap
    //! @copydoc ::boost::container::set::swap
    void swap(multiset& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value );
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value );
 
    //! @copydoc ::boost::container::set::clear
    void clear() BOOST_NOEXCEPT_OR_NOTHROW;

include/boost/container/node_allocator.hpp

@@ -74,19 +74,19 @@ class node_allocator
    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
@@ -148,9 +148,9 @@ class node_allocator
          boost::container::throw_bad_alloc();
 
       if(Version == 1 && count == 1){
-         typedef container_detail::shared_node_pool
+         typedef dtl::shared_node_pool
             <sizeof(T), NodesPerBlock> 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{
@@ -167,9 +167,9 @@ class node_allocator
    {
       (void)count;
       if(Version == 1 && count == 1){
-         typedef container_detail::shared_node_pool
+         typedef dtl::shared_node_pool
             <sizeof(T), NodesPerBlock> 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{
@@ -180,9 +180,9 @@ class node_allocator
    //!Deallocates all free blocks of the pool
    static void deallocate_free_blocks() BOOST_NOEXCEPT_OR_NOTHROW
    {
-      typedef container_detail::shared_node_pool
+      typedef dtl::shared_node_pool
          <sizeof(T), NodesPerBlock> 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();
    }
 
@@ -210,9 +210,9 @@ class node_allocator
    pointer allocate_one()
    {
       BOOST_STATIC_ASSERT(( Version > 1 ));
-      typedef container_detail::shared_node_pool
+      typedef dtl::shared_node_pool
          <sizeof(T), NodesPerBlock> 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();
    }
 
@@ -221,9 +221,9 @@ class node_allocator
    void allocate_individual(std::size_t num_elements, multiallocation_chain &chain)
    {
       BOOST_STATIC_ASSERT(( Version > 1 ));
-      typedef container_detail::shared_node_pool
+      typedef dtl::shared_node_pool
          <sizeof(T), NodesPerBlock> 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;
       singleton_t::instance().allocate_nodes(num_elements, ch);
       chain.incorporate_after(chain.before_begin(), (T*)&*ch.begin(), (T*)&*ch.last(), ch.size());
@@ -235,18 +235,18 @@ class node_allocator
    void deallocate_one(pointer p) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_STATIC_ASSERT(( Version > 1 ));
-      typedef container_detail::shared_node_pool
+      typedef dtl::shared_node_pool
          <sizeof(T), NodesPerBlock> 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
    {
       BOOST_STATIC_ASSERT(( Version > 1 ));
-      typedef container_detail::shared_node_pool
+      typedef dtl::shared_node_pool
          <sizeof(T), NodesPerBlock> 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);
    }

include/boost/container/node_handle.hpp

@@ -174,9 +174,9 @@ class node_handle
    //!   of a node handle is void.
    template<class KeyMapped2>
    node_handle( BOOST_RV_REF_BEG node_handle<NodeAllocator, KeyMapped2> BOOST_RV_REF_END nh
-               , typename container_detail::enable_if_c
-                  < ((unsigned)container_detail::is_same<KeyMapped,  void>::value +
-                     (unsigned)container_detail::is_same<KeyMapped2, void>::value) == 1u
+               , typename dtl::enable_if_c
+                  < ((unsigned)dtl::is_same<KeyMapped,  void>::value +
+                     (unsigned)dtl::is_same<KeyMapped2, void>::value) == 1u
                   >::type* = 0) BOOST_NOEXCEPT
       :  m_ptr(nh.get())
    {  this->move_construct_end(nh);  }
@@ -250,7 +250,7 @@ class node_handle
    //! <b>Throws</b>: Nothing.
    value_type& value() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((container_detail::is_same<KeyMapped, void>::value));
+      BOOST_STATIC_ASSERT((dtl::is_same<KeyMapped, void>::value));
       BOOST_ASSERT(!empty());
       return m_ptr->get_data();
    }
@@ -265,7 +265,7 @@ class node_handle
    //! <b>Requires</b>: Modifying the key through the returned reference is permitted.
    key_type& key() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!container_detail::is_same<KeyMapped, void>::value));
+      BOOST_STATIC_ASSERT((!dtl::is_same<KeyMapped, void>::value));
       BOOST_ASSERT(!empty());
       return const_cast<key_type &>(KeyMapped().key_of_value(m_ptr->get_data()));
    }
@@ -278,7 +278,7 @@ class node_handle
    //! <b>Throws</b>: Nothing.
    mapped_type& mapped() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!container_detail::is_same<KeyMapped, void>::value));
+      BOOST_STATIC_ASSERT((!dtl::is_same<KeyMapped, void>::value));
       BOOST_ASSERT(!empty());
       return KeyMapped().mapped_of_value(m_ptr->get_data());
    }

include/boost/container/pmr/polymorphic_allocator.hpp

@@ -104,7 +104,7 @@ class polymorphic_allocator
    void construct(U* p, BOOST_FWD_REF(Args)...args)
    {
       new_allocator<U> na;
-      container_detail::dispatch_uses_allocator
+      dtl::dispatch_uses_allocator
          (na, *this, p, ::boost::forward<Args>(args)...);
    }
 
@@ -117,7 +117,7 @@ class polymorphic_allocator
    void construct(U* p BOOST_MOVE_I##N BOOST_MOVE_UREFQ##N)\
    {\
       new_allocator<U> na;\
-      container_detail::dispatch_uses_allocator\
+      dtl::dispatch_uses_allocator\
          (na, *this, p BOOST_MOVE_I##N BOOST_MOVE_FWDQ##N);\
    }\
    //

include/boost/container/pmr/resource_adaptor.hpp

@@ -57,7 +57,7 @@ class resource_adaptor_imp
    void static_assert_if_not_char_allocator() const
    {
       //This class can only be used with allocators type char
-      BOOST_STATIC_ASSERT((container_detail::is_same<typename Allocator::value_type, char>::value));
+      BOOST_STATIC_ASSERT((dtl::is_same<typename Allocator::value_type, char>::value));
    }
    #endif
 

include/boost/container/scoped_allocator.hpp

@@ -44,7 +44,7 @@ namespace boost { namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-namespace container_detail {
+namespace dtl {
 
 template <typename Allocator>
 struct is_scoped_allocator_imp
@@ -99,16 +99,16 @@ struct outermost_allocator_imp<MaybeScopedAlloc, true>
    {  return outermost_allocator_imp<outer_type>::get(a.outer_allocator());  }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 template <typename Allocator>
 struct is_scoped_allocator
-   : container_detail::is_scoped_allocator_imp<Allocator>
+   : dtl::is_scoped_allocator_imp<Allocator>
 {};
 
 template <typename Allocator>
 struct outermost_allocator
-   : container_detail::outermost_allocator_imp<Allocator>
+   : dtl::outermost_allocator_imp<Allocator>
 {};
 
 template <typename Allocator>
@@ -121,7 +121,7 @@ const typename outermost_allocator<Allocator>::type &
    get_outermost_allocator(const Allocator &a)
 {  return outermost_allocator<Allocator>::get(a);   }
 
-namespace container_detail {
+namespace dtl {
 
 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
@@ -144,19 +144,19 @@ class scoped_allocator_adaptor_base
    typedef allocator_traits<inner_allocator_type>     inner_traits_type;
    typedef scoped_allocator_adaptor
       <OuterAlloc, InnerAllocs...>                    scoped_allocator_type;
-   typedef container_detail::bool_<
+   typedef dtl::bool_<
       outer_traits_type::propagate_on_container_copy_assignment::value ||
       inner_allocator_type::propagate_on_container_copy_assignment::value
       > propagate_on_container_copy_assignment;
-   typedef container_detail::bool_<
+   typedef dtl::bool_<
       outer_traits_type::propagate_on_container_move_assignment::value ||
       inner_allocator_type::propagate_on_container_move_assignment::value
       > propagate_on_container_move_assignment;
-   typedef container_detail::bool_<
+   typedef dtl::bool_<
       outer_traits_type::propagate_on_container_swap::value ||
       inner_allocator_type::propagate_on_container_swap::value
       > propagate_on_container_swap;
-   typedef container_detail::bool_<
+   typedef dtl::bool_<
       outer_traits_type::is_always_equal::value &&
       inner_allocator_type::is_always_equal::value
       > is_always_equal;
@@ -286,20 +286,20 @@ class scoped_allocator_adaptor_base<OuterAlloc, true, BOOST_MOVE_TARG##N>\
    typedef scoped_allocator_adaptor<BOOST_MOVE_TARG##N> inner_allocator_type;\
    typedef scoped_allocator_adaptor<OuterAlloc, BOOST_MOVE_TARG##N> scoped_allocator_type;\
    typedef allocator_traits<inner_allocator_type> inner_traits_type;\
-   typedef container_detail::bool_<\
+   typedef dtl::bool_<\
       outer_traits_type::propagate_on_container_copy_assignment::value ||\
       inner_allocator_type::propagate_on_container_copy_assignment::value\
       > propagate_on_container_copy_assignment;\
-   typedef container_detail::bool_<\
+   typedef dtl::bool_<\
       outer_traits_type::propagate_on_container_move_assignment::value ||\
       inner_allocator_type::propagate_on_container_move_assignment::value\
       > propagate_on_container_move_assignment;\
-   typedef container_detail::bool_<\
+   typedef dtl::bool_<\
       outer_traits_type::propagate_on_container_swap::value ||\
       inner_allocator_type::propagate_on_container_swap::value\
       > propagate_on_container_swap;\
    \
-   typedef container_detail::bool_<\
+   typedef dtl::bool_<\
       outer_traits_type::is_always_equal::value &&\
       inner_allocator_type::is_always_equal::value\
       > is_always_equal;\
@@ -521,7 +521,7 @@ class scoped_allocator_adaptor_base< OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMM
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -578,14 +578,14 @@ template <typename OuterAlloc, BOOST_MOVE_CLASS9>
 class scoped_allocator_adaptor
 #endif
 
-   : public container_detail::scoped_allocator_adaptor_base
+   : public dtl::scoped_allocator_adaptor_base
          <OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMMYTRUE, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER>
 {
    BOOST_COPYABLE_AND_MOVABLE(scoped_allocator_adaptor)
 
    public:
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   typedef container_detail::scoped_allocator_adaptor_base
+   typedef dtl::scoped_allocator_adaptor_base
       <OuterAlloc BOOST_CONTAINER_SCOPEDALLOC_DUMMYTRUE, BOOST_CONTAINER_SCOPEDALLOC_ALLINNER> base_type;
    typedef typename base_type::internal_type_t              internal_type_t;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -810,7 +810,7 @@ class scoped_allocator_adaptor
    template < typename T, class ...Args>
    void construct(T* p, BOOST_FWD_REF(Args)...args)
    {
-      container_detail::dispatch_uses_allocator
+      dtl::dispatch_uses_allocator
          ( (get_outermost_allocator)(this->outer_allocator())
          , this->inner_allocator(), p, ::boost::forward<Args>(args)...);
    }
@@ -823,7 +823,7 @@ class scoped_allocator_adaptor
    template < typename T BOOST_MOVE_I##N BOOST_MOVE_CLASSQ##N >\
    void construct(T* p BOOST_MOVE_I##N BOOST_MOVE_UREFQ##N)\
    {\
-      container_detail::dispatch_uses_allocator\
+      dtl::dispatch_uses_allocator\
          ( (get_outermost_allocator)(this->outer_allocator())\
          , this->inner_allocator(), p BOOST_MOVE_I##N BOOST_MOVE_FWDQ##N);\
    }\
@@ -888,7 +888,7 @@ inline bool operator==(const scoped_allocator_adaptor<OuterA1, BOOST_CONTAINER_S
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    const bool has_zero_inner = sizeof...(InnerAllocs) == 0u;
    #else
-   const bool has_zero_inner = boost::container::container_detail::is_same<P0, void>::value;
+   const bool has_zero_inner = boost::container::dtl::is_same<P0, void>::value;
    #endif
    typedef scoped_allocator_operator_equal<has_zero_inner> equal_t;
    return equal_t::equal_outer(a.outer_allocator(), b.outer_allocator()) &&

include/boost/container/set.hpp

@@ -66,15 +66,15 @@ template <class Key, class Compare, class Allocator, class Options>
 #endif
 class set
    ///@cond
-   : public container_detail::tree
-      < Key, container_detail::identity<Key>, Compare, Allocator, Options>
+   : public dtl::tree
+      < Key, dtl::identity<Key>, Compare, Allocator, Options>
    ///@endcond
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    BOOST_COPYABLE_AND_MOVABLE(set)
-   typedef container_detail::tree
-      < Key, container_detail::identity<Key>, Compare, Allocator, Options> base_t;
+   typedef dtl::tree
+      < Key, dtl::identity<Key>, Compare, Allocator, Options> base_t;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
@@ -114,8 +114,8 @@ class set
    //! <b>Complexity</b>: Constant.
    
    BOOST_CONTAINER_FORCEINLINE set()
-      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                        container_detail::is_nothrow_default_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value &&
+                        dtl::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
@@ -320,7 +320,7 @@ class set
    //!
    //! <b>Postcondition</b>: x is emptied.
    BOOST_CONTAINER_FORCEINLINE set(BOOST_RV_REF(set) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
 
@@ -356,7 +356,7 @@ class set
    BOOST_CONTAINER_FORCEINLINE set& operator=(BOOST_RV_REF(set) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {  return static_cast<set&>(this->base_t::operator=(BOOST_MOVE_BASE(base_t, x)));  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -639,8 +639,8 @@ class set
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(set<Key, C2, Allocator, Options>& source)
    {
-      typedef container_detail::tree
-         <Key, container_detail::identity<Key>, C2, Allocator, Options> base2_t;
+      typedef dtl::tree
+         <Key, dtl::identity<Key>, C2, Allocator, Options> base2_t;
       this->base_t::merge_unique(static_cast<base2_t&>(source));
    }
 
@@ -653,8 +653,8 @@ class set
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(multiset<Key, C2, Allocator, Options>& source)
    {
-      typedef container_detail::tree
-         <Key, container_detail::identity<Key>, C2, Allocator, Options> base2_t;
+      typedef dtl::tree
+         <Key, dtl::identity<Key>, C2, Allocator, Options> base2_t;
       this->base_t::merge_unique(static_cast<base2_t&>(source));
    }
 
@@ -701,7 +701,7 @@ class set
    //! <b>Complexity</b>: Constant.
    void swap(set& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value );
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value );
 
    //! <b>Effects</b>: erase(a.begin(),a.end()).
    //!
@@ -893,15 +893,15 @@ template <class Key, class Compare, class Allocator, class Options>
 #endif
 class multiset
    /// @cond
-   : public container_detail::tree
-      <Key,container_detail::identity<Key>, Compare, Allocator, Options>
+   : public dtl::tree
+      <Key,dtl::identity<Key>, Compare, Allocator, Options>
    /// @endcond
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    BOOST_COPYABLE_AND_MOVABLE(multiset)
-   typedef container_detail::tree
-      <Key,container_detail::identity<Key>, Compare, Allocator, Options> base_t;
+   typedef dtl::tree
+      <Key,dtl::identity<Key>, Compare, Allocator, Options> base_t;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
@@ -938,8 +938,8 @@ class multiset
 
    //! @copydoc ::boost::container::set::set()
    BOOST_CONTAINER_FORCEINLINE multiset()
-      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value &&
-                        container_detail::is_nothrow_default_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value &&
+                        dtl::is_nothrow_default_constructible<Compare>::value)
       : base_t()
    {}
 
@@ -1068,7 +1068,7 @@ class multiset
 
    //! @copydoc ::boost::container::set::set(set &&)
    BOOST_CONTAINER_FORCEINLINE multiset(BOOST_RV_REF(multiset) x)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<Compare>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<Compare>::value)
       : base_t(BOOST_MOVE_BASE(base_t, x))
    {}
 
@@ -1090,7 +1090,7 @@ class multiset
    BOOST_CONTAINER_FORCEINLINE multiset& operator=(BOOST_RV_REF(multiset) x)
       BOOST_NOEXCEPT_IF( (allocator_traits_type::propagate_on_container_move_assignment::value ||
                           allocator_traits_type::is_always_equal::value) &&
-                           boost::container::container_detail::is_nothrow_move_assignable<Compare>::value)
+                           boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {  return static_cast<multiset&>(this->base_t::operator=(BOOST_MOVE_BASE(base_t, x)));  }
 
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
@@ -1269,8 +1269,8 @@ class multiset
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(multiset<Key, C2, Allocator, Options>& source)
    {
-      typedef container_detail::tree
-         <Key, container_detail::identity<Key>, C2, Allocator, Options> base2_t;
+      typedef dtl::tree
+         <Key, dtl::identity<Key>, C2, Allocator, Options> base2_t;
       this->base_t::merge_equal(static_cast<base2_t&>(source));
    }
 
@@ -1283,8 +1283,8 @@ class multiset
    template<class C2>
    BOOST_CONTAINER_FORCEINLINE void merge(set<Key, C2, Allocator, Options>& source)
    {
-      typedef container_detail::tree
-         <Key, container_detail::identity<Key>, C2, Allocator, Options> base2_t;
+      typedef dtl::tree
+         <Key, dtl::identity<Key>, C2, Allocator, Options> base2_t;
       this->base_t::merge_equal(static_cast<base2_t&>(source));
    }
 
@@ -1313,7 +1313,7 @@ class multiset
    //! @copydoc ::boost::container::set::swap
    void swap(multiset& x)
       BOOST_NOEXCEPT_IF(  allocator_traits_type::is_always_equal::value
-                                 && boost::container::container_detail::is_nothrow_swappable<Compare>::value );
+                                 && boost::container::dtl::is_nothrow_swappable<Compare>::value );
 
    //! @copydoc ::boost::container::set::clear
    void clear() BOOST_NOEXCEPT_OR_NOTHROW;

include/boost/container/slist.hpp

@@ -61,13 +61,13 @@ namespace container {
 template <class T, class Allocator>
 class slist;
 
-namespace container_detail {
+namespace dtl {
 
 template<class VoidPointer>
 struct slist_hook
 {
-   typedef typename container_detail::bi::make_slist_base_hook
-      <container_detail::bi::void_pointer<VoidPointer>, container_detail::bi::link_mode<container_detail::bi::normal_link> >::type type;
+   typedef typename dtl::bi::make_slist_base_hook
+      <dtl::bi::void_pointer<VoidPointer>, dtl::bi::link_mode<dtl::bi::normal_link> >::type type;
 };
 
 template <class T, class VoidPointer>
@@ -104,20 +104,20 @@ struct intrusive_slist_type
       <typename allocator_traits_type::pointer>::template
          rebind_pointer<void>::type
             void_pointer;
-   typedef typename container_detail::slist_node
+   typedef typename dtl::slist_node
          <value_type, void_pointer>             node_type;
 
-   typedef typename container_detail::bi::make_slist
+   typedef typename dtl::bi::make_slist
       <node_type
-      ,container_detail::bi::base_hook<typename slist_hook<void_pointer>::type>
-      ,container_detail::bi::constant_time_size<true>
-      , container_detail::bi::size_type
+      ,dtl::bi::base_hook<typename slist_hook<void_pointer>::type>
+      ,dtl::bi::constant_time_size<true>
+      , dtl::bi::size_type
          <typename allocator_traits_type::size_type>
       >::type                                   container_type;
    typedef container_type                       type ;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -162,26 +162,26 @@ template <class T, class Allocator = new_allocator<T> >
 template <class T, class Allocator>
 #endif
 class slist
-   : protected container_detail::node_alloc_holder
-      <Allocator, typename container_detail::intrusive_slist_type<Allocator>::type>
+   : protected dtl::node_alloc_holder
+      <Allocator, typename dtl::intrusive_slist_type<Allocator>::type>
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    typedef typename
-      container_detail::intrusive_slist_type<Allocator>::type           Icont;
-   typedef container_detail::node_alloc_holder<Allocator, Icont>        AllocHolder;
+      dtl::intrusive_slist_type<Allocator>::type           Icont;
+   typedef dtl::node_alloc_holder<Allocator, Icont>        AllocHolder;
    typedef typename AllocHolder::NodePtr                    NodePtr;
    typedef typename AllocHolder::NodeAlloc                  NodeAlloc;
    typedef typename AllocHolder::ValAlloc                   ValAlloc;
    typedef typename AllocHolder::Node                       Node;
-   typedef container_detail::allocator_destroyer<NodeAlloc> Destroyer;
+   typedef dtl::allocator_destroyer<NodeAlloc> Destroyer;
    typedef typename AllocHolder::alloc_version              alloc_version;
    typedef boost::container::
       allocator_traits<Allocator>                           allocator_traits_type;
    typedef boost::container::equal_to_value<Allocator>      equal_to_value_type;
 
    BOOST_COPYABLE_AND_MOVABLE(slist)
-   typedef container_detail::iterator_from_iiterator<typename Icont::iterator, false>  iterator_impl;
-   typedef container_detail::iterator_from_iiterator<typename Icont::iterator, true >  const_iterator_impl;
+   typedef dtl::iterator_from_iiterator<typename Icont::iterator, false>  iterator_impl;
+   typedef dtl::iterator_from_iiterator<typename Icont::iterator, true >  const_iterator_impl;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
    public:
@@ -216,7 +216,7 @@ class slist
    //! <b>Throws</b>: If allocator_type's copy constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   slist() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+   slist() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       :  AllocHolder()
    {}
 
@@ -357,7 +357,7 @@ class slist
       if (&x != this){
          NodeAlloc &this_alloc     = this->node_alloc();
          const NodeAlloc &x_alloc  = x.node_alloc();
-         container_detail::bool_<allocator_traits_type::
+         dtl::bool_<allocator_traits_type::
             propagate_on_container_copy_assignment::value> flag;
          if(flag && this_alloc != x_alloc){
             this->clear();
@@ -442,7 +442,7 @@ class slist
    template <class InpIt>
    void assign(InpIt first, InpIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_convertible<InpIt, size_type>::type * = 0
+      , typename dtl::disable_if_convertible<InpIt, size_type>::type * = 0
       #endif
       )
    {
@@ -846,10 +846,10 @@ class slist
    template <class InpIt>
    iterator insert_after(const_iterator prev_p, InpIt first, InpIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_c
-         < !container_detail::is_convertible<InpIt, size_type>::value
-          && (container_detail::is_input_iterator<InpIt>::value
-                || container_detail::is_same<alloc_version, version_1>::value
+      , typename dtl::enable_if_c
+         < !dtl::is_convertible<InpIt, size_type>::value
+          && (dtl::is_input_iterator<InpIt>::value
+                || dtl::is_same<alloc_version, version_1>::value
                )
          >::type * = 0
       #endif
@@ -884,10 +884,10 @@ class slist
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
    iterator insert_after(const_iterator prev, FwdIt first, FwdIt last
-      , typename container_detail::enable_if_c
-         < !container_detail::is_convertible<FwdIt, size_type>::value
-            && !(container_detail::is_input_iterator<FwdIt>::value
-                || container_detail::is_same<alloc_version, version_1>::value
+      , typename dtl::enable_if_c
+         < !dtl::is_convertible<FwdIt, size_type>::value
+            && !(dtl::is_input_iterator<FwdIt>::value
+                || dtl::is_same<alloc_version, version_1>::value
                )
          >::type * = 0
       )

include/boost/container/small_vector.hpp

@@ -118,11 +118,11 @@ class small_vector_allocator
    typedef typename allocator_traits<Allocator>::propagate_on_container_move_assignment   propagate_on_container_move_assignment;
    typedef typename allocator_traits<Allocator>::propagate_on_container_swap              propagate_on_container_swap;
    //! An integral constant with member `value == false`
-   typedef BOOST_CONTAINER_IMPDEF(container_detail::bool_<false>)                         is_always_equal;
+   typedef BOOST_CONTAINER_IMPDEF(dtl::bool_<false>)                         is_always_equal;
    //! An integral constant with member `value == true`
-   typedef BOOST_CONTAINER_IMPDEF(container_detail::bool_<true>)                          is_partially_propagable;
+   typedef BOOST_CONTAINER_IMPDEF(dtl::bool_<true>)                          is_partially_propagable;
 
-   BOOST_CONTAINER_DOCIGN(typedef container_detail::version_type<small_vector_allocator BOOST_CONTAINER_I 1>  version;)
+   BOOST_CONTAINER_DOCIGN(typedef dtl::version_type<small_vector_allocator BOOST_CONTAINER_I 1>  version;)
 
    //!Obtains an small_vector_allocator that allocates
    //!objects of type T2
@@ -282,7 +282,7 @@ class small_vector_allocator
    pointer internal_storage() const
    {
       typedef typename Allocator::value_type                                              value_type;
-      typedef container_detail::vector_alloc_holder< small_vector_allocator<Allocator> >  vector_alloc_holder_t;
+      typedef dtl::vector_alloc_holder< small_vector_allocator<Allocator> >  vector_alloc_holder_t;
       typedef vector<value_type, small_vector_allocator<Allocator> >                      vector_base;
       typedef small_vector_base<value_type, Allocator>                                    derived_type;
       //
@@ -345,8 +345,8 @@ class small_vector_base
    const base_type &as_base() const { return static_cast<const base_type&>(*this); }
 
    public:
-   typedef typename container_detail::aligned_storage
-      <sizeof(T), container_detail::alignment_of<T>::value>::type storage_type;
+   typedef typename dtl::aligned_storage
+      <sizeof(T), dtl::alignment_of<T>::value>::type storage_type;
    typedef small_vector_allocator<SecondaryAllocator>             allocator_type;
 
    protected:
@@ -419,7 +419,7 @@ struct small_vector_storage_calculator
 {
    typedef small_vector_base<T, Allocator> svh_type;
    typedef vector<T, small_vector_allocator<Allocator> > svhb_type;
-   static const std::size_t s_align = container_detail::alignment_of<Storage>::value;
+   static const std::size_t s_align = dtl::alignment_of<Storage>::value;
    static const std::size_t s_size = sizeof(Storage);
    static const std::size_t svh_sizeof = sizeof(svh_type);
    static const std::size_t svhb_sizeof = sizeof(svhb_type);
@@ -507,7 +507,7 @@ class small_vector : public small_vector_base<T, Allocator>
 
    public:
    BOOST_CONTAINER_FORCEINLINE small_vector()
-      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+      BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : base_type(initial_capacity_t(), internal_capacity())
    {}
 
@@ -541,18 +541,18 @@ class small_vector : public small_vector_base<T, Allocator>
 
    template <class InIt>
    BOOST_CONTAINER_FORCEINLINE small_vector(InIt first, InIt last
-      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename container_detail::disable_if_c
-         < container_detail::is_convertible<InIt BOOST_MOVE_I size_type>::value
-         BOOST_MOVE_I container_detail::nat >::type * = 0)
+      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_c
+         < dtl::is_convertible<InIt BOOST_MOVE_I size_type>::value
+         BOOST_MOVE_I dtl::nat >::type * = 0)
       )
       : base_type(initial_capacity_t(), internal_capacity())
    {  this->assign(first, last); }
 
    template <class InIt>
    BOOST_CONTAINER_FORCEINLINE small_vector(InIt first, InIt last, const allocator_type& a
-      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename container_detail::disable_if_c
-         < container_detail::is_convertible<InIt BOOST_MOVE_I size_type>::value
-         BOOST_MOVE_I container_detail::nat >::type * = 0)
+      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_c
+         < dtl::is_convertible<InIt BOOST_MOVE_I size_type>::value
+         BOOST_MOVE_I dtl::nat >::type * = 0)
       )
       : base_type(initial_capacity_t(), internal_capacity(), a)
    {  this->assign(first, last); }

include/boost/container/stable_vector.hpp

@@ -245,7 +245,7 @@ class stable_vector_iterator
    typedef std::random_access_iterator_tag                                          iterator_category;
    typedef typename non_const_ptr_traits::element_type                              value_type;
    typedef typename non_const_ptr_traits::difference_type                           difference_type;
-   typedef typename ::boost::container::container_detail::if_c
+   typedef typename ::boost::container::dtl::if_c
       < IsConst
       , typename non_const_ptr_traits::template
          rebind_pointer<const value_type>::type
@@ -464,14 +464,14 @@ class stable_vector
    typedef typename node_ptr_traits::reference        node_reference;
    typedef typename const_node_ptr_traits::reference  const_node_reference;
 
-   typedef ::boost::container::container_detail::integral_constant
-      <unsigned, boost::container::container_detail::
+   typedef ::boost::container::dtl::integral_constant
+      <unsigned, boost::container::dtl::
       version<Allocator>::value>                              alloc_version;
    typedef typename allocator_traits_type::
       template portable_rebind_alloc
          <node_type>::type                            node_allocator_type;
 
-   typedef ::boost::container::container_detail::
+   typedef ::boost::container::dtl::
       allocator_version_traits<node_allocator_type>                    allocator_version_traits_t;
    typedef typename allocator_version_traits_t::multiallocation_chain  multiallocation_chain;
 
@@ -540,7 +540,7 @@ class stable_vector
    //! <b>Throws</b>: If allocator_type's default constructor throws.
    //!
    //! <b>Complexity</b>: Constant.
-   stable_vector() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+   stable_vector() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : internal_data(), index()
    {
       STABLE_VECTOR_CHECK_INVARIANT;
@@ -765,14 +765,14 @@ class stable_vector
       if (&x != this){
          node_allocator_type &this_alloc     = this->priv_node_alloc();
          const node_allocator_type &x_alloc  = x.priv_node_alloc();
-         container_detail::bool_<allocator_traits_type::
+         dtl::bool_<allocator_traits_type::
             propagate_on_container_copy_assignment::value> flag;
          if(flag && this_alloc != x_alloc){
             this->clear();
             this->shrink_to_fit();
          }
-         container_detail::assign_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag);
-         container_detail::assign_alloc(this->index.get_stored_allocator(), x.index.get_stored_allocator(), flag);
+         dtl::assign_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag);
+         dtl::assign_alloc(this->index.get_stored_allocator(), x.index.get_stored_allocator(), flag);
          this->assign(x.begin(), x.end());
       }
       return *this;
@@ -799,7 +799,7 @@ class stable_vector
       node_allocator_type &x_alloc    = x.priv_node_alloc();
       const bool propagate_alloc = allocator_traits_type::
             propagate_on_container_move_assignment::value;
-      container_detail::bool_<propagate_alloc> flag;
+      dtl::bool_<propagate_alloc> flag;
       const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
       //Resources can be transferred if both allocators are
       //going to be equal after this function (either propagated or already equal)
@@ -808,7 +808,7 @@ class stable_vector
          //Destroy objects but retain memory in case x reuses it in the future
          this->clear();
          //Move allocator if needed
-         container_detail::move_alloc(this_alloc, x_alloc, flag);
+         dtl::move_alloc(this_alloc, x_alloc, flag);
          //Take resources
          this->index.swap(x.index);
          this->priv_swap_members(x);
@@ -852,7 +852,7 @@ class stable_vector
    //! <b>Complexity</b>: Linear to n.
    template<typename InputIterator>
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-   typename container_detail::disable_if_convertible<InputIterator, size_type>::type
+   typename dtl::disable_if_convertible<InputIterator, size_type>::type
    #else
    void
    #endif
@@ -1537,10 +1537,10 @@ class stable_vector
          #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
          //Put this as argument instead of the return type as old GCC's like 3.4
          //detect this and the next disable_if_or as overloads
-         ,  typename container_detail::disable_if_or
+         ,  typename dtl::disable_if_or
                < void
-               , container_detail::is_convertible<InputIterator, size_type>
-               , container_detail::is_not_input_iterator<InputIterator>
+               , dtl::is_convertible<InputIterator, size_type>
+               , dtl::is_not_input_iterator<InputIterator>
                >::type* = 0
          #endif
          )
@@ -1556,10 +1556,10 @@ class stable_vector
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
-   typename container_detail::disable_if_or
+   typename dtl::disable_if_or
       < iterator
-      , container_detail::is_convertible<FwdIt, size_type>
-      , container_detail::is_input_iterator<FwdIt>
+      , dtl::is_convertible<FwdIt, size_type>
+      , dtl::is_input_iterator<FwdIt>
       >::type
       insert(const_iterator p, FwdIt first, FwdIt last)
    {
@@ -1672,8 +1672,8 @@ class stable_vector
                    allocator_traits_type::is_always_equal::value ||
                    this->get_stored_allocator() == x.get_stored_allocator());
       STABLE_VECTOR_CHECK_INVARIANT;
-      container_detail::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
-      container_detail::swap_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag);
+      dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
+      dtl::swap_alloc(this->priv_node_alloc(), x.priv_node_alloc(), flag);
       //vector's allocator is swapped here
       this->index.swap(x.index);
       this->priv_swap_members(x);
@@ -1956,7 +1956,7 @@ class stable_vector
    void priv_destroy_node(const node_type &n)
    {
       allocator_traits<node_allocator_type>::
-         destroy(this->priv_node_alloc(), container_detail::addressof(n.value));
+         destroy(this->priv_node_alloc(), dtl::addressof(n.value));
       static_cast<const node_base_type*>(&n)->~node_base_type();
    }
 
@@ -1972,7 +1972,7 @@ class stable_vector
       //This can throw
       boost::container::construct_in_place
          ( this->priv_node_alloc()
-         , container_detail::addressof(p->value)
+         , dtl::addressof(p->value)
          , it);
       //This does not throw
       ::new(static_cast<node_base_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t())
@@ -1985,7 +1985,7 @@ class stable_vector
       //This can throw
       boost::container::allocator_traits<node_allocator_type>::construct
          ( this->priv_node_alloc()
-         , container_detail::addressof(p->value)
+         , dtl::addressof(p->value)
          , ::boost::forward<ValueConvertible>(value_convertible));
       //This does not throw
       ::new(static_cast<node_base_type*>(boost::movelib::to_raw_pointer(p)), boost_container_new_t()) node_base_type;

include/boost/container/static_vector.hpp

@@ -33,7 +33,7 @@ namespace boost { namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-namespace container_detail {
+namespace dtl {
 
 template<class T, std::size_t N>
 class static_storage_allocator
@@ -61,7 +61,7 @@ class static_storage_allocator
    std::size_t max_size() const
    {  return N;   }
 
-   typedef boost::container::container_detail::version_type<static_storage_allocator, 0>   version;
+   typedef boost::container::dtl::version_type<static_storage_allocator, 0>   version;
 
    BOOST_CONTAINER_FORCEINLINE friend bool operator==(const static_storage_allocator &, const static_storage_allocator &) BOOST_NOEXCEPT_OR_NOTHROW
    {  return false;  }
@@ -73,7 +73,7 @@ class static_storage_allocator
    typename aligned_storage<sizeof(T)*N, alignment_of<T>::value>::type storage;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -103,10 +103,10 @@ class static_storage_allocator
 //!@tparam Capacity The maximum number of elements static_vector can store, fixed at compile time.
 template <typename Value, std::size_t Capacity>
 class static_vector
-    : public vector<Value, container_detail::static_storage_allocator<Value, Capacity> >
+    : public vector<Value, dtl::static_storage_allocator<Value, Capacity> >
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-   typedef vector<Value, container_detail::static_storage_allocator<Value, Capacity> > base_t;
+   typedef vector<Value, dtl::static_storage_allocator<Value, Capacity> > base_t;
 
    BOOST_COPYABLE_AND_MOVABLE(static_vector)
 
@@ -114,7 +114,7 @@ class static_vector
    friend class static_vector;
 
    public:
-   typedef container_detail::static_storage_allocator<Value, Capacity> allocator_type;
+   typedef dtl::static_storage_allocator<Value, Capacity> allocator_type;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 public:
@@ -259,7 +259,7 @@ public:
     {}
 
     BOOST_CONTAINER_FORCEINLINE static_vector(BOOST_RV_REF(static_vector) other,  const allocator_type &)
-       BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<value_type>::value)
+       BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<value_type>::value)
        : base_t(BOOST_MOVE_BASE(base_t, other))
     {}
 
@@ -294,7 +294,7 @@ public:
     //! @par Complexity
     //!   Linear O(N).
     BOOST_CONTAINER_FORCEINLINE static_vector(BOOST_RV_REF(static_vector) other)
-      BOOST_NOEXCEPT_IF(boost::container::container_detail::is_nothrow_move_constructible<value_type>::value)
+      BOOST_NOEXCEPT_IF(boost::container::dtl::is_nothrow_move_constructible<value_type>::value)
         : base_t(BOOST_MOVE_BASE(base_t, other))
     {}
 
@@ -1228,7 +1228,7 @@ inline void swap(static_vector<V, C1> & x, static_vector<V, C2> & y);
 
 template<typename V, std::size_t C1, std::size_t C2>
 inline void swap(static_vector<V, C1> & x, static_vector<V, C2> & y
-      , typename container_detail::enable_if_c< C1 != C2>::type * = 0)
+      , typename dtl::enable_if_c< C1 != C2>::type * = 0)
 {
    x.swap(y);
 }

include/boost/container/string.hpp

@@ -70,7 +70,7 @@ namespace boost {
 namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
-namespace container_detail {
+namespace dtl {
 // ------------------------------------------------------------
 // Class basic_string_base.
 
@@ -170,8 +170,8 @@ class basic_string_base
    //This type has the same alignment and size as long_t but it's POD
    //so, unlike long_t, it can be placed in a union
 
-   typedef typename container_detail::aligned_storage
-      <sizeof(long_t), container_detail::alignment_of<long_t>::value>::type   long_raw_t;
+   typedef typename dtl::aligned_storage
+      <sizeof(long_t), dtl::alignment_of<long_t>::value>::type   long_raw_t;
 
    protected:
    static const size_type  MinInternalBufferChars = 8;
@@ -274,8 +274,8 @@ class basic_string_base
 
    protected:
 
-   typedef container_detail::integral_constant<unsigned,
-      boost::container::container_detail::version<Allocator>::value> alloc_version;
+   typedef dtl::integral_constant<unsigned,
+      boost::container::dtl::version<Allocator>::value> alloc_version;
 
    pointer allocation_command(allocation_type command,
                          size_type limit_size,
@@ -286,7 +286,7 @@ class basic_string_base
          reuse = 0;
          command &= ~(expand_fwd | expand_bwd);
       }
-      return container_detail::allocator_version_traits<Allocator>::allocation_command
+      return dtl::allocator_version_traits<Allocator>::allocation_command
          (this->alloc(), command, limit_size, prefer_in_recvd_out_size, reuse);
    }
 
@@ -460,7 +460,7 @@ class basic_string_base
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -502,13 +502,13 @@ template <class CharT, class Traits = std::char_traits<CharT>, class Allocator =
 template <class CharT, class Traits, class Allocator>
 #endif
 class basic_string
-   :  private container_detail::basic_string_base<Allocator>
+   :  private dtl::basic_string_base<Allocator>
 {
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    typedef allocator_traits<Allocator> allocator_traits_type;
    BOOST_COPYABLE_AND_MOVABLE(basic_string)
-   typedef container_detail::basic_string_base<Allocator> base_t;
+   typedef dtl::basic_string_base<Allocator> base_t;
    static const typename base_t::size_type InternalBufferChars = base_t::InternalBufferChars;
 
    protected:
@@ -598,7 +598,7 @@ class basic_string
    //! <b>Effects</b>: Default constructs a basic_string.
    //!
    //! <b>Throws</b>: If allocator_type's default constructor throws.
-   basic_string() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+   basic_string() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : base_t()
    { this->priv_terminate_string(); }
 
@@ -689,7 +689,7 @@ class basic_string
          throw_out_of_range("basic_string::basic_string out of range position");
       else
          this->assign
-            (s.begin() + pos, s.begin() + pos + container_detail::min_value(n, s.size() - pos));
+            (s.begin() + pos, s.begin() + pos + dtl::min_value(n, s.size() - pos));
    }
 
    //! <b>Effects</b>: Constructs a basic_string taking the allocator as parameter,
@@ -702,7 +702,7 @@ class basic_string
          throw_out_of_range("basic_string::basic_string out of range position");
       else
          this->assign
-            (s.begin() + pos, s.begin() + pos + container_detail::min_value(n, s.size() - pos));
+            (s.begin() + pos, s.begin() + pos + dtl::min_value(n, s.size() - pos));
    }
 
    //! <b>Effects</b>: Constructs a basic_string taking a default-constructed allocator,
@@ -827,7 +827,7 @@ class basic_string
       if (&x != this){
          allocator_type &this_alloc     = this->alloc();
          const allocator_type &x_alloc  = x.alloc();
-         container_detail::bool_<allocator_traits_type::
+         dtl::bool_<allocator_traits_type::
             propagate_on_container_copy_assignment::value> flag;
          if(flag && this_alloc != x_alloc){
             if(!this->is_short()){
@@ -837,7 +837,7 @@ class basic_string
                this->priv_short_size(0);
             }
          }
-         container_detail::assign_alloc(this->alloc(), x.alloc(), flag);
+         dtl::assign_alloc(this->alloc(), x.alloc(), flag);
          this->assign(x.begin(), x.end());
       }
       return *this;
@@ -861,7 +861,7 @@ class basic_string
       allocator_type &x_alloc    = x.alloc();
       const bool propagate_alloc = allocator_traits_type::
             propagate_on_container_move_assignment::value;
-      container_detail::bool_<propagate_alloc> flag;
+      dtl::bool_<propagate_alloc> flag;
       const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
       //Resources can be transferred if both allocators are
       //going to be equal after this function (either propagated or already equal)
@@ -869,7 +869,7 @@ class basic_string
          //Destroy objects but retain memory in case x reuses it in the future
          this->clear();
          //Move allocator if needed
-         container_detail::move_alloc(this_alloc, x_alloc, flag);
+         dtl::move_alloc(this_alloc, x_alloc, flag);
          //Nothrow swap
          this->swap_data(x);
       }
@@ -1356,7 +1356,7 @@ class basic_string
       if (pos > s.size())
          throw_out_of_range("basic_string::append out of range position");
       return this->append(s.begin() + pos,
-                          s.begin() + pos + container_detail::min_value(n, s.size() - pos));
+                          s.begin() + pos + dtl::min_value(n, s.size() - pos));
    }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
@@ -1457,7 +1457,7 @@ class basic_string
       if (pos > s.size())
          throw_out_of_range("basic_string::assign out of range position");
       return this->assign(s.begin() + pos,
-                          s.begin() + pos + container_detail::min_value(n, s.size() - pos));
+                          s.begin() + pos + dtl::min_value(n, s.size() - pos));
    }
 
    //! <b>Requires</b>: s points to an array of at least n elements of CharT.
@@ -1505,7 +1505,7 @@ class basic_string
    template <class InputIter>
    basic_string& assign(InputIter first, InputIter last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_convertible<InputIter, size_type>::type * = 0
+      , typename dtl::disable_if_convertible<InputIter, size_type>::type * = 0
       #endif
       )
    {
@@ -1567,7 +1567,7 @@ class basic_string
       const size_type str_size = s.size();
       if (pos1 > sz || pos2 > str_size)
          throw_out_of_range("basic_string::insert out of range position");
-      size_type len = container_detail::min_value(n, str_size - pos2);
+      size_type len = dtl::min_value(n, str_size - pos2);
       if (sz > this->max_size() - len)
          throw_length_error("basic_string::insert max_size() exceeded");
       const CharT *beg_ptr = boost::movelib::to_raw_pointer(s.begin()) + pos2;
@@ -1666,10 +1666,10 @@ class basic_string
    template <class InputIter>
    iterator insert(const_iterator p, InputIter first, InputIter last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<InputIter, size_type>
-         , container_detail::is_not_input_iterator<InputIter>
+         , dtl::is_convertible<InputIter, size_type>
+         , dtl::is_not_input_iterator<InputIter>
          >::type * = 0
       #endif
       )
@@ -1684,10 +1684,10 @@ class basic_string
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class ForwardIter>
    iterator insert(const_iterator p, ForwardIter first, ForwardIter last
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<ForwardIter, size_type>
-         , container_detail::is_input_iterator<ForwardIter>
+         , dtl::is_convertible<ForwardIter, size_type>
+         , dtl::is_input_iterator<ForwardIter>
          >::type * = 0
       )
    {
@@ -1834,7 +1834,7 @@ class basic_string
       if (pos > this->size())
          throw_out_of_range("basic_string::erase out of range position");
       const pointer addr = this->priv_addr();
-      erase(addr + pos, addr + pos + container_detail::min_value(n, this->size() - pos));
+      erase(addr + pos, addr + pos + dtl::min_value(n, this->size() - pos));
       return *this;
    }
 
@@ -1903,7 +1903,7 @@ class basic_string
    {
       if (pos1 > this->size())
          throw_out_of_range("basic_string::replace out of range position");
-      const size_type len = container_detail::min_value(n1, this->size() - pos1);
+      const size_type len = dtl::min_value(n1, this->size() - pos1);
       if (this->size() - len >= this->max_size() - str.size())
          throw_length_error("basic_string::replace max_size() exceeded");
       const pointer addr = this->priv_addr();
@@ -1934,7 +1934,7 @@ class basic_string
    {
       if (pos2 > str.size())
          throw_out_of_range("basic_string::replace out of range position");
-      return this->replace(pos1, n1, str.data()+pos2, container_detail::min_value(n2, str.size() - pos2));
+      return this->replace(pos1, n1, str.data()+pos2, dtl::min_value(n2, str.size() - pos2));
    }
 
    //! <b>Throws</b>: out_of_range if pos1 > size() or pos2 > sv.size().
@@ -1949,7 +1949,7 @@ class basic_string
    {
       if (pos2 > sv.size())
          throw_out_of_range("basic_string::replace out of range position");
-      return this->replace(pos1, n1, sv.data()+pos2, container_detail::min_value(n2, sv.size() - pos2));
+      return this->replace(pos1, n1, sv.data()+pos2, dtl::min_value(n2, sv.size() - pos2));
    }
 
    //! <b>Requires</b>: pos1 <= size() and s points to an array of at least n2 elements of CharT.
@@ -1970,7 +1970,7 @@ class basic_string
    {
       if (pos1 > this->size())
          throw_out_of_range("basic_string::replace out of range position");
-      const size_type len = container_detail::min_value(n1, this->size() - pos1);
+      const size_type len = dtl::min_value(n1, this->size() - pos1);
       const size_type max_size = this->max_size();
       if (n2 > max_size || (this->size() - len) >= (max_size - n2))
          throw_length_error("basic_string::replace max_size() exceeded");
@@ -2009,7 +2009,7 @@ class basic_string
    {
       if (pos1 > this->size())
          throw_out_of_range("basic_string::replace out of range position");
-      const size_type len = container_detail::min_value(n1, this->size() - pos1);
+      const size_type len = dtl::min_value(n1, this->size() - pos1);
       if (n2 > this->max_size() || this->size() - len >= this->max_size() - n2)
          throw_length_error("basic_string::replace max_size() exceeded");
       const pointer addr    = this->priv_addr();
@@ -2079,10 +2079,10 @@ class basic_string
    template <class InputIter>
    basic_string& replace(const_iterator i1, const_iterator i2, InputIter j1, InputIter j2
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<InputIter, size_type>
-         , container_detail::is_input_iterator<InputIter>
+         , dtl::is_convertible<InputIter, size_type>
+         , dtl::is_input_iterator<InputIter>
          >::type * = 0
       #endif
       )
@@ -2101,10 +2101,10 @@ class basic_string
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class ForwardIter>
    basic_string& replace(const_iterator i1, const_iterator i2, ForwardIter j1, ForwardIter j2
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<ForwardIter, size_type>
-         , container_detail::is_not_input_iterator<ForwardIter>
+         , dtl::is_convertible<ForwardIter, size_type>
+         , dtl::is_not_input_iterator<ForwardIter>
          >::type * = 0
       )
    {
@@ -2165,7 +2165,7 @@ class basic_string
    {
       if (pos > this->size())
          throw_out_of_range("basic_string::copy out of range position");
-      const size_type len = container_detail::min_value(n, this->size() - pos);
+      const size_type len = dtl::min_value(n, this->size() - pos);
       Traits::copy(s, boost::movelib::to_raw_pointer(this->priv_addr() + pos), len);
       return len;
    }
@@ -2179,8 +2179,8 @@ class basic_string
                                || allocator_traits_type::is_always_equal::value)
    {
       this->base_t::swap_data(x);
-      container_detail::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
-      container_detail::swap_alloc(this->alloc(), x.alloc(), flag);
+      dtl::bool_<allocator_traits_type::propagate_on_container_swap::value> flag;
+      dtl::swap_alloc(this->alloc(), x.alloc(), flag);
    }
 
    //////////////////////////////////////////////
@@ -2340,9 +2340,9 @@ class basic_string
       if (n > len)
          return npos;
       else if (n == 0)
-         return container_detail::min_value(len, pos);
+         return dtl::min_value(len, pos);
       else {
-         const const_iterator last = begin() + container_detail::min_value(len - n, pos) + n;
+         const const_iterator last = begin() + dtl::min_value(len - n, pos) + n;
          const const_iterator result = find_end(begin(), last,
                                                 s, s + n,
                                                 Eq_traits<Traits>());
@@ -2369,7 +2369,7 @@ class basic_string
       if (len < 1)
          return npos;
       else {
-         const const_iterator last = begin() + container_detail::min_value(len - 1, pos) + 1;
+         const const_iterator last = begin() + dtl::min_value(len - 1, pos) + 1;
          const_reverse_iterator rresult =
             boost::container::find_if(const_reverse_iterator(last), rend(),
                   boost::container::bind2nd(Eq_traits<Traits>(), c));
@@ -2467,7 +2467,7 @@ class basic_string
          return npos;
       else {
          const pointer addr    = this->priv_addr();
-         const const_iterator last = addr + container_detail::min_value(len - 1, pos) + 1;
+         const const_iterator last = addr + dtl::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
             boost::container::find_first_of(const_reverse_iterator(last), rend(),
                                s, s + n, Eq_traits<Traits>());
@@ -2588,7 +2588,7 @@ class basic_string
       if (len < 1)
          return npos;
       else {
-         const const_iterator last = begin() + container_detail::min_value(len - 1, pos) + 1;
+         const const_iterator last = begin() + dtl::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
             boost::container::find_if(const_reverse_iterator(last), rend(),
                     Not_within_traits<Traits>(s, s + n));
@@ -2614,7 +2614,7 @@ class basic_string
       if (len < 1)
          return npos;
       else {
-         const const_iterator last = begin() + container_detail::min_value(len - 1, pos) + 1;
+         const const_iterator last = begin() + dtl::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
             boost::container::find_if(const_reverse_iterator(last), rend(),
                   boost::container::not1(boost::container::bind2nd(Eq_traits<Traits>(), c)));
@@ -2636,7 +2636,7 @@ class basic_string
          throw_out_of_range("basic_string::substr out of range position");
       const pointer addr = this->priv_addr();
       return basic_string(addr + pos,
-                          addr + pos + container_detail::min_value(n, size() - pos), this->alloc());
+                          addr + pos + dtl::min_value(n, size() - pos), this->alloc());
    }
 
    //! <b>Effects</b>: Determines the effective length rlen of the string to compare as
@@ -2681,7 +2681,7 @@ class basic_string
       const pointer addr    = this->priv_addr();
       const pointer str_addr = str.priv_addr();
       return s_compare(addr + pos1,
-                        addr + pos1 + container_detail::min_value(n1, this->size() - pos1),
+                        addr + pos1 + dtl::min_value(n1, this->size() - pos1),
                         str_addr, str_addr + str.priv_size());
    }
 
@@ -2697,7 +2697,7 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr    = this->priv_addr() + pos1;
       const CharT* str_addr = sv.data();
-      return s_compare(addr, addr + container_detail::min_value(n1, this->size() - pos1),
+      return s_compare(addr, addr + dtl::min_value(n1, this->size() - pos1),
                        str_addr, str_addr + sv.size());
    }
 
@@ -2715,8 +2715,8 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr     = this->priv_addr() + pos1;
       const pointer str_addr = str.priv_addr() + pos2;
-      return s_compare(addr, addr + container_detail::min_value(n1, this->size() - pos1),
-                        str_addr, str_addr + container_detail::min_value(n2, str.size() - pos2));
+      return s_compare(addr, addr + dtl::min_value(n1, this->size() - pos1),
+                        str_addr, str_addr + dtl::min_value(n2, str.size() - pos2));
    }
 
    //! <b>Requires</b>: pos1 <= size() and pos2 <= str.size()
@@ -2734,8 +2734,8 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr     = this->priv_addr() + pos1;
       const CharT * str_addr = sv.data() + pos2;
-      return s_compare(addr, addr + container_detail::min_value(n1, this->size() - pos1),
-                       str_addr, str_addr + container_detail::min_value(n2, sv.size() - pos2));
+      return s_compare(addr, addr + dtl::min_value(n1, this->size() - pos1),
+                       str_addr, str_addr + dtl::min_value(n2, sv.size() - pos2));
    }
 
    //! <b>Throws</b>: Nothing
@@ -2758,7 +2758,7 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr = this->priv_addr();
       return s_compare( addr + pos1,
-                        addr + pos1 + container_detail::min_value(n1, this->size() - pos1),
+                        addr + pos1 + dtl::min_value(n1, this->size() - pos1),
                         s, s + n2);
    }
 
@@ -2779,7 +2779,7 @@ class basic_string
       }
 
       if (this->capacity() < res_arg){
-         size_type n = container_detail::max_value(res_arg, this->size()) + 1;
+         size_type n = dtl::max_value(res_arg, this->size()) + 1;
          size_type new_cap = this->next_capacity(n);
          pointer reuse = 0;
          pointer new_start = this->allocation_command(allocate_new, n, new_cap, reuse);
@@ -2806,14 +2806,14 @@ class basic_string
       const difference_type n2 = l2 - f2;
       const int cmp = Traits::compare(boost::movelib::to_raw_pointer(f1),
                                       boost::movelib::to_raw_pointer(f2),
-                                      container_detail::min_value(n1, n2));
+                                      dtl::min_value(n1, n2));
       return cmp != 0 ? cmp : (n1 < n2 ? -1 : (n1 > n2 ? 1 : 0));
    }
 
    template<class AllocVersion>
    void priv_shrink_to_fit_dynamic_buffer
       ( AllocVersion
-      , typename container_detail::enable_if<container_detail::is_same<AllocVersion, version_1> >::type* = 0)
+      , typename dtl::enable_if<dtl::is_same<AllocVersion, version_1> >::type* = 0)
    {
       //Allocate a new buffer.
       size_type real_cap = 0;
@@ -2843,7 +2843,7 @@ class basic_string
    template<class AllocVersion>
    void priv_shrink_to_fit_dynamic_buffer
       ( AllocVersion
-      , typename container_detail::enable_if<container_detail::is_same<AllocVersion, version_2> >::type* = 0)
+      , typename dtl::enable_if<dtl::is_same<AllocVersion, version_2> >::type* = 0)
    {
       size_type received_size = this->priv_long_size()+1;
       pointer hint = this->priv_long_addr();
@@ -2920,13 +2920,13 @@ class basic_string
    template <class Integer>
    basic_string& priv_replace_dispatch(const_iterator first, const_iterator last,
                                        Integer n, Integer x,
-                                       container_detail::true_)
+                                       dtl::true_)
    {  return this->replace(first, last, (size_type) n, (CharT) x);   }
 
    template <class InputIter>
    basic_string& priv_replace_dispatch(const_iterator first, const_iterator last,
                                        InputIter f, InputIter l,
-                                       container_detail::false_)
+                                       dtl::false_)
    {
       typedef typename boost::container::iterator_traits<InputIter>::iterator_category Category;
       return this->priv_replace(first, last, f, l, Category());
@@ -3080,7 +3080,7 @@ operator==(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline 
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
       operator==( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
 {
@@ -3091,7 +3091,7 @@ inline
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
       operator==( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
 {
@@ -3118,7 +3118,7 @@ operator!=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator!=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return !(x == y);  }
@@ -3126,7 +3126,7 @@ operator!=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,All
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator!=( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return !(x == y);  }
@@ -3156,7 +3156,7 @@ operator<(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator<( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return y.compare(x) > 0;  }
@@ -3164,7 +3164,7 @@ operator<( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allo
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator<(  const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return x.compare(y) < 0;  }
@@ -3191,7 +3191,7 @@ operator>(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator>( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return y < x;  }
@@ -3199,7 +3199,7 @@ operator>( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allo
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator>( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return y < x;  }
@@ -3225,7 +3225,7 @@ operator<=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator<=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return !(y < x);  }
@@ -3233,7 +3233,7 @@ operator<=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,All
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator<=( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return !(y < x);  }
@@ -3257,7 +3257,7 @@ operator>=(const basic_string<CharT,Traits,Allocator>& x, const CharT* s)
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator>=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,Allocator>& y)
    {  return !(x < y);  }
@@ -3265,7 +3265,7 @@ operator>=( BasicStringView<CharT,Traits> x, const basic_string<CharT,Traits,All
 template <class CharT, class Traits, class Allocator, template <class, class> class BasicStringView>
 inline
    BOOST_CONTAINER_DOC1ST( bool, 
-                           typename container_detail::disable_if
+                           typename dtl::disable_if
                               <is_string< BasicStringView<CharT BOOST_MOVE_I Traits> > BOOST_MOVE_I bool >::type)
 operator>=( const basic_string<CharT,Traits,Allocator>& x, BasicStringView<CharT,Traits> y)
    {  return !(x < y);  }
@@ -3277,7 +3277,7 @@ inline void swap(basic_string<CharT,Traits,Allocator>& x, basic_string<CharT,Tra
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 // I/O.
-namespace container_detail {
+namespace dtl {
 
 template <class CharT, class Traits>
 inline bool
@@ -3294,7 +3294,7 @@ string_fill(std::basic_ostream<CharT, Traits>& os,
    return ok;
 }
 
-}  //namespace container_detail {
+}  //namespace dtl {
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
 template <class CharT, class Traits, class Allocator>
@@ -3316,13 +3316,13 @@ operator<<(std::basic_ostream<CharT, Traits>& os, const basic_string<CharT,Trait
          pad_len = w - n;
 
       if (!left)
-         ok = container_detail::string_fill(os, buf, pad_len);
+         ok = dtl::string_fill(os, buf, pad_len);
 
       ok = ok &&
             buf->sputn(s.data(), std::streamsize(n)) == std::streamsize(n);
 
       if (left)
-         ok = ok && container_detail::string_fill(os, buf, pad_len);
+         ok = ok && dtl::string_fill(os, buf, pad_len);
    }
 
    if (!ok)

include/boost/container/uses_allocator.hpp

@@ -112,7 +112,7 @@ struct constructible_with_allocator_prefix
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-namespace container_detail {
+namespace dtl {
 
 template<typename T, typename Allocator>
 struct uses_allocator_imp
@@ -130,8 +130,8 @@ struct uses_allocator_imp
 
    // Match this function if T::allocator_type exists and it's type is `erased_type`.
    template <class U, class V>
-   static typename container_detail::enable_if
-      < container_detail::is_same<typename U::allocator_type, erased_type>
+   static typename dtl::enable_if
+      < dtl::is_same<typename U::allocator_type, erased_type>
       , yes_type
       >::type  test(const V&);
 
@@ -145,7 +145,7 @@ struct uses_allocator_imp
    static const bool value = sizeof(test<T>(alloc)) == sizeof(yes_type);
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -161,7 +161,7 @@ struct uses_allocator_imp
 //! is an alias `erased_type`. False otherwise.
 template <typename T, typename Allocator>
 struct uses_allocator
-   : container_detail::uses_allocator_imp<T, Allocator>
+   : dtl::uses_allocator_imp<T, Allocator>
 {};
 
 }} //namespace boost::container

include/boost/container/vector.hpp

@@ -73,7 +73,7 @@ namespace container {
 
 #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
-namespace container_detail {
+namespace dtl {
 
 template <class Pointer, bool IsConst>
 class vec_iterator
@@ -244,17 +244,17 @@ struct vector_merge_cursor
    Comp &m_cmp;
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 template<class Pointer, bool IsConst>
-BOOST_CONTAINER_FORCEINLINE const Pointer &vector_iterator_get_ptr(const container_detail::vec_iterator<Pointer, IsConst> &it) BOOST_NOEXCEPT_OR_NOTHROW
+BOOST_CONTAINER_FORCEINLINE const Pointer &vector_iterator_get_ptr(const dtl::vec_iterator<Pointer, IsConst> &it) BOOST_NOEXCEPT_OR_NOTHROW
 {  return   it.get_ptr();  }
 
 template<class Pointer, bool IsConst>
-BOOST_CONTAINER_FORCEINLINE Pointer &get_ptr(container_detail::vec_iterator<Pointer, IsConst> &it) BOOST_NOEXCEPT_OR_NOTHROW
+BOOST_CONTAINER_FORCEINLINE Pointer &get_ptr(dtl::vec_iterator<Pointer, IsConst> &it) BOOST_NOEXCEPT_OR_NOTHROW
 {  return  it.get_ptr();  }
 
-namespace container_detail {
+namespace dtl {
 
 struct uninitialized_size_t {};
 static const uninitialized_size_t uninitialized_size = uninitialized_size_t();
@@ -278,18 +278,18 @@ struct vector_value_traits
    typedef vector_value_traits_base<typename Allocator::value_type> base_t;
    //This is the anti-exception array destructor
    //to deallocate values already constructed
-   typedef typename container_detail::if_c
+   typedef typename dtl::if_c
       <base_t::trivial_dctr
-      ,container_detail::null_scoped_destructor_n<Allocator>
-      ,container_detail::scoped_destructor_n<Allocator>
+      ,dtl::null_scoped_destructor_n<Allocator>
+      ,dtl::scoped_destructor_n<Allocator>
       >::type   ArrayDestructor;
    //This is the anti-exception array deallocator
-   typedef container_detail::scoped_array_deallocator<Allocator> ArrayDeallocator;
+   typedef dtl::scoped_array_deallocator<Allocator> ArrayDeallocator;
 };
 
 //!This struct deallocates and allocated memory
 template < class Allocator
-         , class AllocatorVersion = typename container_detail::version<Allocator>::type
+         , class AllocatorVersion = typename dtl::version<Allocator>::type
          >
 struct vector_alloc_holder
    : public Allocator
@@ -322,7 +322,7 @@ struct vector_alloc_holder
 
    //Constructor, does not throw
    vector_alloc_holder()
-      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+      BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : Allocator(), m_start(), m_size(), m_capacity()
    {}
 
@@ -397,7 +397,7 @@ struct vector_alloc_holder
    }
 
    vector_alloc_holder(pointer p, size_type n)
-      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+      BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : Allocator()
       , m_start(p)
       , m_size()
@@ -422,7 +422,7 @@ struct vector_alloc_holder
    BOOST_CONTAINER_FORCEINLINE pointer allocation_command(boost::container::allocation_type command,
                               size_type limit_size, size_type &prefer_in_recvd_out_size, pointer &reuse)
    {
-      typedef typename container_detail::version<Allocator>::type alloc_version;
+      typedef typename dtl::version<Allocator>::type alloc_version;
       return this->priv_allocation_command(alloc_version(), command, limit_size, prefer_in_recvd_out_size, reuse);
    }
 
@@ -536,7 +536,7 @@ struct vector_alloc_holder<Allocator, version_0>
 
    //Constructor, does not throw
    vector_alloc_holder()
-      BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+      BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : Allocator(), m_size()
    {}
 
@@ -649,7 +649,7 @@ struct vector_alloc_holder<Allocator, version_0>
    }
 };
 
-}  //namespace container_detail {
+}  //namespace dtl {
 
 #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -672,16 +672,16 @@ class vector
          {  return a < b;  }
    };
 
-   typedef typename container_detail::version<Allocator>::type alloc_version;
-   typedef boost::container::container_detail::vector_alloc_holder<Allocator> alloc_holder_t;
+   typedef typename dtl::version<Allocator>::type alloc_version;
+   typedef boost::container::dtl::vector_alloc_holder<Allocator> alloc_holder_t;
    alloc_holder_t m_holder;
    typedef allocator_traits<Allocator>                      allocator_traits_type;
    template <class U, class UAllocator>
    friend class vector;
 
    typedef typename allocator_traits_type::pointer  pointer_impl;
-   typedef container_detail::vec_iterator<pointer_impl, false> iterator_impl;
-   typedef container_detail::vec_iterator<pointer_impl, true > const_iterator_impl;
+   typedef dtl::vec_iterator<pointer_impl, false> iterator_impl;
+   typedef dtl::vec_iterator<pointer_impl, true > const_iterator_impl;
 
    protected:
    static bool is_propagable_from(const Allocator &from_alloc, pointer_impl p, const Allocator &to_alloc, bool const propagate_allocator)
@@ -716,7 +716,7 @@ class vector
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
    BOOST_COPYABLE_AND_MOVABLE(vector)
-   typedef container_detail::vector_value_traits<Allocator> value_traits;
+   typedef dtl::vector_value_traits<Allocator> value_traits;
    typedef constant_iterator<T, difference_type>            cvalue_iterator;
 
    protected:
@@ -748,7 +748,7 @@ class vector
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   vector() BOOST_NOEXCEPT_IF(container_detail::is_nothrow_default_constructible<Allocator>::value)
+   vector() BOOST_NOEXCEPT_IF(dtl::is_nothrow_default_constructible<Allocator>::value)
       : m_holder()
    {}
 
@@ -768,7 +768,7 @@ class vector
    //!
    //! <b>Complexity</b>: Linear to n.
    explicit vector(size_type n)
-      :  m_holder(container_detail::uninitialized_size, n)
+      :  m_holder(dtl::uninitialized_size, n)
    {
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       this->num_alloc += n != 0;
@@ -785,7 +785,7 @@ class vector
    //!
    //! <b>Complexity</b>: Linear to n.
    explicit vector(size_type n, const allocator_type &a)
-      :  m_holder(container_detail::uninitialized_size, a, n)
+      :  m_holder(dtl::uninitialized_size, a, n)
    {
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       this->num_alloc += n != 0;
@@ -804,7 +804,7 @@ class vector
    //!
    //! <b>Note</b>: Non-standard extension
    vector(size_type n, default_init_t)
-      :  m_holder(container_detail::uninitialized_size, n)
+      :  m_holder(dtl::uninitialized_size, n)
    {
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       this->num_alloc += n != 0;
@@ -823,7 +823,7 @@ class vector
    //!
    //! <b>Note</b>: Non-standard extension
    vector(size_type n, default_init_t, const allocator_type &a)
-      :  m_holder(container_detail::uninitialized_size, a, n)
+      :  m_holder(dtl::uninitialized_size, a, n)
    {
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       this->num_alloc += n != 0;
@@ -840,7 +840,7 @@ class vector
    //!
    //! <b>Complexity</b>: Linear to n.
    vector(size_type n, const T& value)
-      :  m_holder(container_detail::uninitialized_size, n)
+      :  m_holder(dtl::uninitialized_size, n)
    {
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       this->num_alloc += n != 0;
@@ -857,7 +857,7 @@ class vector
    //!
    //! <b>Complexity</b>: Linear to n.
    vector(size_type n, const T& value, const allocator_type& a)
-      :  m_holder(container_detail::uninitialized_size, a, n)
+      :  m_holder(dtl::uninitialized_size, a, n)
    {
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       this->num_alloc += n != 0;
@@ -875,9 +875,9 @@ class vector
    //! <b>Complexity</b>: Linear to the range [first, last).
    template <class InIt>
    vector(InIt first, InIt last
-      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename container_detail::disable_if_c
-         < container_detail::is_convertible<InIt BOOST_MOVE_I size_type>::value
-         BOOST_MOVE_I container_detail::nat >::type * = 0)
+      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_c
+         < dtl::is_convertible<InIt BOOST_MOVE_I size_type>::value
+         BOOST_MOVE_I dtl::nat >::type * = 0)
       )
       :  m_holder()
    {  this->assign(first, last); }
@@ -891,9 +891,9 @@ class vector
    //! <b>Complexity</b>: Linear to the range [first, last).
    template <class InIt>
    vector(InIt first, InIt last, const allocator_type& a
-      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename container_detail::disable_if_c
-         < container_detail::is_convertible<InIt BOOST_MOVE_I size_type>::value
-         BOOST_MOVE_I container_detail::nat >::type * = 0)
+      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_c
+         < dtl::is_convertible<InIt BOOST_MOVE_I size_type>::value
+         BOOST_MOVE_I dtl::nat >::type * = 0)
       )
       :  m_holder(a)
    {  this->assign(first, last); }
@@ -907,7 +907,7 @@ class vector
    //!
    //! <b>Complexity</b>: Linear to the elements x contains.
    vector(const vector &x)
-      :  m_holder( container_detail::uninitialized_size
+      :  m_holder( dtl::uninitialized_size
                  , allocator_traits_type::select_on_container_copy_construction(x.m_holder.alloc())
                  , x.size())
    {
@@ -953,8 +953,8 @@ class vector
    //! <b>Note</b>: Non-standard extension to support static_vector
    template<class OtherAllocator>
    vector(BOOST_RV_REF_BEG vector<T, OtherAllocator> BOOST_RV_REF_END x
-         , typename container_detail::enable_if_c
-            < container_detail::is_version<OtherAllocator, 0>::value>::type * = 0
+         , typename dtl::enable_if_c
+            < dtl::is_version<OtherAllocator, 0>::value>::type * = 0
          )
       :  m_holder(boost::move(x.m_holder))
    {}
@@ -970,7 +970,7 @@ class vector
    //!
    //! <b>Complexity</b>: Linear to the elements x contains.
    vector(const vector &x, const allocator_type &a)
-      :  m_holder(container_detail::uninitialized_size, a, x.size())
+      :  m_holder(dtl::uninitialized_size, a, x.size())
    {
       #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
       this->num_alloc += x.size() != 0;
@@ -988,7 +988,7 @@ class vector
    //!
    //! <b>Complexity</b>: Constant if a == x.get_allocator(), linear otherwise.
    vector(BOOST_RV_REF(vector) x, const allocator_type &a)
-      :  m_holder( container_detail::uninitialized_size, a
+      :  m_holder( dtl::uninitialized_size, a
                  , is_propagable_from(x.get_stored_allocator(), x.m_holder.start(), a, true) ? 0 : x.size()
                  )
    {
@@ -1079,10 +1079,10 @@ class vector
    //!
    //! <b>Note</b>: Non-standard extension to support static_vector
    template<class OtherAllocator>
-   BOOST_CONTAINER_FORCEINLINE typename container_detail::enable_if_and
+   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
                            < vector&
-                           , container_detail::is_version<OtherAllocator, 0>
-                           , container_detail::is_different<OtherAllocator, allocator_type>
+                           , dtl::is_version<OtherAllocator, 0>
+                           , dtl::is_different<OtherAllocator, allocator_type>
                            >::type
       operator=(BOOST_RV_REF_BEG vector<value_type, OtherAllocator> BOOST_RV_REF_END x)
    {
@@ -1101,10 +1101,10 @@ class vector
    //!
    //! <b>Note</b>: Non-standard extension to support static_vector
    template<class OtherAllocator>
-   BOOST_CONTAINER_FORCEINLINE typename container_detail::enable_if_and
+   BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_and
                            < vector&
-                           , container_detail::is_version<OtherAllocator, 0>
-                           , container_detail::is_different<OtherAllocator, allocator_type>
+                           , dtl::is_version<OtherAllocator, 0>
+                           , dtl::is_different<OtherAllocator, allocator_type>
                            >::type
       operator=(const vector<value_type, OtherAllocator> &x)
    {
@@ -1122,12 +1122,12 @@ class vector
    //! <b>Complexity</b>: Linear to n.
    template <class InIt>
    void assign(InIt first, InIt last
-      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename container_detail::disable_if_or
+      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_or
          < void
-         BOOST_MOVE_I container_detail::is_convertible<InIt BOOST_MOVE_I size_type>
-         BOOST_MOVE_I container_detail::and_
-            < container_detail::is_different<alloc_version BOOST_MOVE_I version_0>
-            BOOST_MOVE_I container_detail::is_not_input_iterator<InIt>
+         BOOST_MOVE_I dtl::is_convertible<InIt BOOST_MOVE_I size_type>
+         BOOST_MOVE_I dtl::and_
+            < dtl::is_different<alloc_version BOOST_MOVE_I version_0>
+            BOOST_MOVE_I dtl::is_not_input_iterator<InIt>
             >
          >::type * = 0)
       )
@@ -1171,11 +1171,11 @@ class vector
    //! <b>Complexity</b>: Linear to n.
    template <class FwdIt>
    void assign(FwdIt first, FwdIt last
-      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename container_detail::disable_if_or
+      BOOST_CONTAINER_DOCIGN(BOOST_MOVE_I typename dtl::disable_if_or
          < void
-         BOOST_MOVE_I container_detail::is_same<alloc_version BOOST_MOVE_I version_0>
-         BOOST_MOVE_I container_detail::is_convertible<FwdIt BOOST_MOVE_I size_type>
-         BOOST_MOVE_I container_detail::is_input_iterator<FwdIt>
+         BOOST_MOVE_I dtl::is_same<alloc_version BOOST_MOVE_I version_0>
+         BOOST_MOVE_I dtl::is_convertible<FwdIt BOOST_MOVE_I size_type>
+         BOOST_MOVE_I dtl::is_input_iterator<FwdIt>
          >::type * = 0)
       )
    {
@@ -1697,7 +1697,7 @@ class vector
          return *p;
       }
       else{
-         typedef container_detail::insert_emplace_proxy<Allocator, T*, Args...> type;
+         typedef dtl::insert_emplace_proxy<Allocator, T*, Args...> type;
          return *this->priv_forward_range_insert_no_capacity
             (this->back_ptr(), 1, type(::boost::forward<Args>(args)...), alloc_version());
       }
@@ -1738,7 +1738,7 @@ class vector
    {
       BOOST_ASSERT(this->priv_in_range_or_end(position));
       //Just call more general insert(pos, size, value) and return iterator
-      typedef container_detail::insert_emplace_proxy<Allocator, T*, Args...> type;
+      typedef dtl::insert_emplace_proxy<Allocator, T*, Args...> type;
       return this->priv_forward_range_insert( vector_iterator_get_ptr(position), 1
                                             , type(::boost::forward<Args>(args)...));
    }
@@ -1757,7 +1757,7 @@ class vector
          return *p;\
       }\
       else{\
-         typedef container_detail::insert_emplace_proxy_arg##N<Allocator, T* BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
+         typedef dtl::insert_emplace_proxy_arg##N<Allocator, T* BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
          return *this->priv_forward_range_insert_no_capacity\
             ( this->back_ptr(), 1, type(BOOST_MOVE_FWD##N), alloc_version());\
       }\
@@ -1779,7 +1779,7 @@ class vector
    iterator emplace(const_iterator pos BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
    {\
       BOOST_ASSERT(this->priv_in_range_or_end(pos));\
-      typedef container_detail::insert_emplace_proxy_arg##N<Allocator, T* BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
+      typedef dtl::insert_emplace_proxy_arg##N<Allocator, T* BOOST_MOVE_I##N BOOST_MOVE_TARG##N> type;\
       return this->priv_forward_range_insert(vector_iterator_get_ptr(pos), 1, type(BOOST_MOVE_FWD##N));\
    }\
    //
@@ -1845,7 +1845,7 @@ class vector
    iterator insert(const_iterator p, size_type n, const T& x)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      container_detail::insert_n_copies_proxy<Allocator, T*> proxy(x);
+      dtl::insert_n_copies_proxy<Allocator, T*> proxy(x);
       return this->priv_forward_range_insert(vector_iterator_get_ptr(p), n, proxy);
    }
 
@@ -1862,10 +1862,10 @@ class vector
    template <class InIt>
    iterator insert(const_iterator pos, InIt first, InIt last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<InIt, size_type>
-         , container_detail::is_not_input_iterator<InIt>
+         , dtl::is_convertible<InIt, size_type>
+         , dtl::is_not_input_iterator<InIt>
          >::type * = 0
       #endif
       )
@@ -1883,15 +1883,15 @@ class vector
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
    template <class FwdIt>
    iterator insert(const_iterator pos, FwdIt first, FwdIt last
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_convertible<FwdIt, size_type>
-         , container_detail::is_input_iterator<FwdIt>
+         , dtl::is_convertible<FwdIt, size_type>
+         , dtl::is_input_iterator<FwdIt>
          >::type * = 0
       )
    {
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
-      container_detail::insert_range_proxy<Allocator, FwdIt, T*> proxy(first);
+      dtl::insert_range_proxy<Allocator, FwdIt, T*> proxy(first);
       return this->priv_forward_range_insert(vector_iterator_get_ptr(pos), boost::container::iterator_distance(first, last), proxy);
    }
    #endif
@@ -1916,10 +1916,10 @@ class vector
    iterator insert(const_iterator pos, size_type num, InIt first, InIt last)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
-      BOOST_ASSERT(container_detail::is_input_iterator<InIt>::value ||
+      BOOST_ASSERT(dtl::is_input_iterator<InIt>::value ||
                    num == static_cast<size_type>(boost::container::iterator_distance(first, last)));
       (void)last;
-      container_detail::insert_range_proxy<Allocator, InIt, T*> proxy(first);
+      dtl::insert_range_proxy<Allocator, InIt, T*> proxy(first);
       return this->priv_forward_range_insert(vector_iterator_get_ptr(pos), num, proxy);
    }
    #endif
@@ -1997,9 +1997,9 @@ class vector
    void swap(vector& x)
       BOOST_NOEXCEPT_IF( ((allocator_traits_type::propagate_on_container_swap::value
                                     || allocator_traits_type::is_always_equal::value) &&
-                                    !container_detail::is_version<Allocator, 0>::value))
+                                    !dtl::is_version<Allocator, 0>::value))
    {
-      this->priv_swap(x, container_detail::bool_<container_detail::is_version<Allocator, 0>::value>());
+      this->priv_swap(x, dtl::bool_<dtl::is_version<Allocator, 0>::value>());
    }
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -2013,10 +2013,10 @@ class vector
    //! <b>Note</b>: Non-standard extension to support static_vector
    template<class OtherAllocator>
    void swap(vector<T, OtherAllocator> & x
-            , typename container_detail::enable_if_and
+            , typename dtl::enable_if_and
                      < void
-                     , container_detail::is_version<OtherAllocator, 0>
-                     , container_detail::is_different<OtherAllocator, allocator_type>
+                     , dtl::is_version<OtherAllocator, 0>
+                     , dtl::is_different<OtherAllocator, allocator_type>
                      >::type * = 0
             )
    {  this->m_holder.deep_swap(x.m_holder); }
@@ -2101,7 +2101,7 @@ class vector
    template<class BiDirPosConstIt, class BiDirValueIt>
    void insert_ordered_at(const size_type element_count, BiDirPosConstIt last_position_it, BiDirValueIt last_value_it)
    {
-      typedef container_detail::vector_insert_ordered_cursor<BiDirPosConstIt, BiDirValueIt> inserter_t;
+      typedef dtl::vector_insert_ordered_cursor<BiDirPosConstIt, BiDirValueIt> inserter_t;
       return this->priv_insert_ordered_at(element_count, inserter_t(last_position_it, last_value_it));
    }
 
@@ -2111,15 +2111,15 @@ class vector
 
    template<class BidirIt, class Compare>
    void merge(BidirIt first, BidirIt last, Compare comp)
-   {  this->priv_merge(container_detail::false_type(), first, last, comp);  }
+   {  this->priv_merge(dtl::false_type(), first, last, comp);  }
 
    template<class BidirIt>
    void merge_unique(BidirIt first, BidirIt last)
-   {  this->priv_merge(container_detail::true_type(),  first, last, value_less());  }
+   {  this->priv_merge(dtl::true_type(),  first, last, value_less());  }
 
    template<class BidirIt, class Compare>
    void merge_unique(BidirIt first, BidirIt last, Compare comp)
-   {  this->priv_merge(container_detail::true_type(),  first, last, comp);  }
+   {  this->priv_merge(dtl::true_type(),  first, last, comp);  }
 
    private:
    template<class PositionValue>
@@ -2289,10 +2289,10 @@ class vector
 
    template<class OtherAllocator>
    void priv_move_assign(BOOST_RV_REF_BEG vector<T, OtherAllocator> BOOST_RV_REF_END x
-      , typename container_detail::enable_if_c
-         < container_detail::is_version<OtherAllocator, 0>::value >::type * = 0)
+      , typename dtl::enable_if_c
+         < dtl::is_version<OtherAllocator, 0>::value >::type * = 0)
    {
-      if(!container_detail::is_same<OtherAllocator, allocator_type>::value &&
+      if(!dtl::is_same<OtherAllocator, allocator_type>::value &&
           this->capacity() < x.size()){
          throw_bad_alloc();
       }
@@ -2306,10 +2306,10 @@ class vector
 
    template<class OtherAllocator>
    void priv_move_assign(BOOST_RV_REF_BEG vector<T, OtherAllocator> BOOST_RV_REF_END x
-      , typename container_detail::disable_if_or
+      , typename dtl::disable_if_or
          < void
-         , container_detail::is_version<OtherAllocator, 0>
-         , container_detail::is_different<OtherAllocator, allocator_type>
+         , dtl::is_version<OtherAllocator, 0>
+         , dtl::is_different<OtherAllocator, allocator_type>
          >::type * = 0)
    {
       //for move assignment, no aliasing (&x != this) is assummed.
@@ -2341,15 +2341,15 @@ class vector
                      );
       }
       //Move allocator if needed
-      container_detail::move_alloc(this_alloc, x_alloc, container_detail::bool_<propagate_alloc>());
+      dtl::move_alloc(this_alloc, x_alloc, dtl::bool_<propagate_alloc>());
    }
 
    template<class OtherAllocator>
    void priv_copy_assign(const vector<T, OtherAllocator> &x
-      , typename container_detail::enable_if_c
-         < container_detail::is_version<OtherAllocator, 0>::value >::type * = 0)
+      , typename dtl::enable_if_c
+         < dtl::is_version<OtherAllocator, 0>::value >::type * = 0)
    {
-      if(!container_detail::is_same<OtherAllocator, allocator_type>::value &&
+      if(!dtl::is_same<OtherAllocator, allocator_type>::value &&
          this->capacity() < x.size()){
          throw_bad_alloc();
       }
@@ -2362,31 +2362,31 @@ class vector
    }
 
    template<class OtherAllocator>
-   typename container_detail::disable_if_or
+   typename dtl::disable_if_or
       < void
-      , container_detail::is_version<OtherAllocator, 0>
-      , container_detail::is_different<OtherAllocator, allocator_type>
+      , dtl::is_version<OtherAllocator, 0>
+      , dtl::is_different<OtherAllocator, allocator_type>
       >::type
       priv_copy_assign(const vector<T, OtherAllocator> &x)
    {
       allocator_type &this_alloc     = this->m_holder.alloc();
       const allocator_type &x_alloc  = x.m_holder.alloc();
-      container_detail::bool_<allocator_traits_type::
+      dtl::bool_<allocator_traits_type::
          propagate_on_container_copy_assignment::value> flag;
       if(flag && this_alloc != x_alloc){
          this->clear();
          this->shrink_to_fit();
       }
-      container_detail::assign_alloc(this_alloc, x_alloc, flag);
+      dtl::assign_alloc(this_alloc, x_alloc, flag);
       this->assign( x.priv_raw_begin(), x.priv_raw_end() );
    }
 
    template<class Vector>  //Template it to avoid it in explicit instantiations
-   void priv_swap(Vector &x, container_detail::true_type)   //version_0
+   void priv_swap(Vector &x, dtl::true_type)   //version_0
    {  this->m_holder.deep_swap(x.m_holder);  }
 
    template<class Vector>  //Template it to avoid it in explicit instantiations
-   void priv_swap(Vector &x, container_detail::false_type)  //version_N
+   void priv_swap(Vector &x, dtl::false_type)  //version_N
    {
       const bool propagate_alloc = allocator_traits_type::propagate_on_container_swap::value;
       if(are_swap_propagable( this->get_stored_allocator(), this->m_holder.start()
@@ -2413,15 +2413,15 @@ class vector
          big.erase(big.nth(common_elements), big.cend());
       }
       //And now swap the allocator
-      container_detail::swap_alloc(this->m_holder.alloc(), x.m_holder.alloc(), container_detail::bool_<propagate_alloc>());
+      dtl::swap_alloc(this->m_holder.alloc(), x.m_holder.alloc(), dtl::bool_<propagate_alloc>());
    }
 
    void priv_reserve_no_capacity(size_type, version_0)
    {  throw_bad_alloc();  }
 
-   container_detail::insert_range_proxy<Allocator, boost::move_iterator<T*>, T*> priv_dummy_empty_proxy()
+   dtl::insert_range_proxy<Allocator, boost::move_iterator<T*>, T*> priv_dummy_empty_proxy()
    {
-      return container_detail::insert_range_proxy<Allocator, boost::move_iterator<T*>, T*>
+      return dtl::insert_range_proxy<Allocator, boost::move_iterator<T*>, T*>
          (::boost::make_move_iterator((T *)0));
    }
 
@@ -2512,14 +2512,14 @@ class vector
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
       return this->priv_forward_range_insert
-         ( vector_iterator_get_ptr(p), 1, container_detail::get_insert_value_proxy<T*, Allocator>(::boost::forward<U>(x)));
+         ( vector_iterator_get_ptr(p), 1, dtl::get_insert_value_proxy<T*, Allocator>(::boost::forward<U>(x)));
    }
 
-   container_detail::insert_copy_proxy<Allocator, T*> priv_single_insert_proxy(const T &x)
-   {  return container_detail::insert_copy_proxy<Allocator, T*> (x);  }
+   dtl::insert_copy_proxy<Allocator, T*> priv_single_insert_proxy(const T &x)
+   {  return dtl::insert_copy_proxy<Allocator, T*> (x);  }
 
-   container_detail::insert_move_proxy<Allocator, T*> priv_single_insert_proxy(BOOST_RV_REF(T) x)
-   {  return container_detail::insert_move_proxy<Allocator, T*> (x);  }
+   dtl::insert_move_proxy<Allocator, T*> priv_single_insert_proxy(BOOST_RV_REF(T) x)
+   {  return dtl::insert_move_proxy<Allocator, T*> (x);  }
 
    template <class U>
    void priv_push_back(BOOST_FWD_REF(U) u)
@@ -2537,14 +2537,14 @@ class vector
       }
    }
 
-   container_detail::insert_n_copies_proxy<Allocator, T*> priv_resize_proxy(const T &x)
-   {  return container_detail::insert_n_copies_proxy<Allocator, T*>(x);   }
+   dtl::insert_n_copies_proxy<Allocator, T*> priv_resize_proxy(const T &x)
+   {  return dtl::insert_n_copies_proxy<Allocator, T*>(x);   }
 
-   container_detail::insert_default_initialized_n_proxy<Allocator, T*> priv_resize_proxy(default_init_t)
-   {  return container_detail::insert_default_initialized_n_proxy<Allocator, T*>();  }
+   dtl::insert_default_initialized_n_proxy<Allocator, T*> priv_resize_proxy(default_init_t)
+   {  return dtl::insert_default_initialized_n_proxy<Allocator, T*>();  }
 
-   container_detail::insert_value_initialized_n_proxy<Allocator, T*> priv_resize_proxy(value_init_t)
-   {  return container_detail::insert_value_initialized_n_proxy<Allocator, T*>(); }
+   dtl::insert_value_initialized_n_proxy<Allocator, T*> priv_resize_proxy(value_init_t)
+   {  return dtl::insert_value_initialized_n_proxy<Allocator, T*>(); }
 
    template <class U>
    void priv_resize(size_type new_size, const U& u)

src/monotonic_buffer_resource.cpp

@@ -80,7 +80,7 @@ monotonic_buffer_resource::monotonic_buffer_resource(void* buffer, std::size_t b
    , m_current_buffer_size(buffer_size)
    , m_next_buffer_size
       (bi::detail::previous_or_equal_pow2
-         (boost::container::container_detail::max_value(buffer_size, std::size_t(initial_next_buffer_size))))
+         (boost::container::dtl::max_value(buffer_size, std::size_t(initial_next_buffer_size))))
 {  this->increase_next_buffer(); }
 
 monotonic_buffer_resource::~monotonic_buffer_resource()

src/pool_resource.cpp

@@ -66,9 +66,9 @@ class pool_data_t
    void replenish(memory_resource &mr, std::size_t pool_block, std::size_t max_blocks_per_chunk)
    {
       //Limit max value
-      std::size_t blocks_per_chunk = boost::container::container_detail::min_value(max_blocks_per_chunk, next_blocks_per_chunk);
+      std::size_t blocks_per_chunk = boost::container::dtl::min_value(max_blocks_per_chunk, next_blocks_per_chunk);
       //Avoid overflow
-      blocks_per_chunk = boost::container::container_detail::min_value(blocks_per_chunk, std::size_t(-1)/pool_block);
+      blocks_per_chunk = boost::container::dtl::min_value(blocks_per_chunk, std::size_t(-1)/pool_block);
       
       //Minimum block size is at least max_align, so all pools allocate sizes that are multiple of max_align,
       //meaning that all blocks are max_align-aligned.
@@ -108,7 +108,7 @@ void pool_resource::priv_limit_option(std::size_t &val, std::size_t min, std::si
       val = max;
    }
    else{
-      val = val < min ? min : boost::container::container_detail::min_value(val, max);
+      val = val < min ? min : boost::container::dtl::min_value(val, max);
    }
 }
 
@@ -116,7 +116,7 @@ std::size_t pool_resource::priv_pool_index(std::size_t block_size) //static
 {
    //For allocations equal or less than pool_options_minimum_largest_required_pool_block
    //the smallest pool is used
-   block_size = boost::container::container_detail::max_value(block_size, pool_options_minimum_largest_required_pool_block);
+   block_size = boost::container::dtl::max_value(block_size, pool_options_minimum_largest_required_pool_block);
    return bi::detail::ceil_log2(block_size)
       - bi::detail::ceil_log2(pool_options_minimum_largest_required_pool_block);
 }

test/Jamfile.v2

@@ -27,7 +27,7 @@ rule test_all
 
    for local fileb in [ glob *.cpp ]
    {
-      all_rules += [ run $(fileb)  /boost/container//boost_container /boost/timer//boost_timer
+      all_rules += [ run $(fileb)  /boost/container//boost_container
       :  # additional args
       :  # test-files
       :  # requirements

test/allocator_argument_tester.hpp

@@ -27,10 +27,10 @@ class propagation_test_allocator
       typedef propagation_test_allocator<U, Id, HasTrueTypes> other;
    };
 
-   typedef boost::container::container_detail::bool_<HasTrueTypes>  propagate_on_container_copy_assignment;
-   typedef boost::container::container_detail::bool_<HasTrueTypes>  propagate_on_container_move_assignment;
-   typedef boost::container::container_detail::bool_<HasTrueTypes>  propagate_on_container_swap;
-   typedef boost::container::container_detail::bool_<HasTrueTypes>  is_always_equal;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_copy_assignment;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_move_assignment;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_swap;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  is_always_equal;
    typedef T value_type;
 
    propagation_test_allocator()

test/allocator_traits_test.cpp

@@ -27,7 +27,7 @@ class SimpleAllocator
    bool allocate_called_;
    bool deallocate_called_;
 
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       true_type                                 is_always_equal;
 
    typedef T value_type;
@@ -106,20 +106,20 @@ class ComplexAllocator
    typedef SimpleSmartPtr<T>                    pointer;
    typedef SimpleSmartPtr<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 SimpleSmartPtr<void>                 void_pointer;
    typedef SimpleSmartPtr<const void>           const_void_pointer;
    typedef signed short                         difference_type;
    typedef unsigned short                       size_type;
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       true_type                                 propagate_on_container_copy_assignment;
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       true_type                                 propagate_on_container_move_assignment;
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       true_type                                 propagate_on_container_swap;
-   typedef boost::container::container_detail::
+   typedef boost::container::dtl::
       true_type                                 is_partially_propagable;
 
    ComplexAllocator()
@@ -247,7 +247,7 @@ void test_void_allocator()
 
 int main()
 {
-   using namespace boost::container::container_detail;
+   using namespace boost::container::dtl;
    test_void_allocator();
 
    //SimpleAllocator

test/check_equal_containers.hpp

@@ -25,9 +25,9 @@ namespace test{
 
 template< class T1, class T2>
 bool CheckEqual( const T1 &t1, const T2 &t2
-               , typename boost::container::container_detail::enable_if_c
-                  <!boost::container::container_detail::is_pair<T1>::value &&
-                   !boost::container::container_detail::is_pair<T2>::value
+               , typename boost::container::dtl::enable_if_c
+                  <!boost::container::dtl::is_pair<T1>::value &&
+                   !boost::container::dtl::is_pair<T2>::value
                   >::type* = 0)
 {  return t1 == t2;  }
 
@@ -50,9 +50,9 @@ bool CheckEqualIt( const T1 &i1, const T2 &i2, const C1 &c1, const C2 &c2 )
 
 template< class Pair1, class Pair2>
 bool CheckEqual( const Pair1 &pair1, const Pair2 &pair2
-               , typename boost::container::container_detail::enable_if_c
-                  <boost::container::container_detail::is_pair<Pair1>::value &&
-                   boost::container::container_detail::is_pair<Pair2>::value
+               , typename boost::container::dtl::enable_if_c
+                  <boost::container::dtl::is_pair<Pair1>::value &&
+                   boost::container::dtl::is_pair<Pair2>::value
                   >::type* = 0)
 {
    return CheckEqual(pair1.first, pair2.first) && CheckEqual(pair1.second, pair2.second);

test/deque_test.cpp

@@ -51,14 +51,14 @@ template class boost::container::deque
 
 //Function to check if both sets are equal
 template<class V1, class V2>
-bool deque_copyable_only(V1 &, V2 &, container_detail::false_type)
+bool deque_copyable_only(V1 &, V2 &, dtl::false_type)
 {
    return true;
 }
 
 //Function to check if both sets are equal
 template<class V1, class V2>
-bool deque_copyable_only(V1 &cntdeque, V2 &stddeque, container_detail::true_type)
+bool deque_copyable_only(V1 &cntdeque, V2 &stddeque, dtl::true_type)
 {
    typedef typename V1::value_type IntType;
    std::size_t size = cntdeque.size();
@@ -246,7 +246,7 @@ bool do_test()
       }
 
       if(!deque_copyable_only(cntdeque, stddeque
-                     ,container_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
+                     ,dtl::bool_<boost::container::test::is_copyable<IntType>::value>())){
          return false;
       }
 

test/dummy_test_allocator.hpp

@@ -85,11 +85,11 @@ class propagation_test_allocator
 
    public:
    typedef T value_type;
-   typedef boost::container::container_detail::bool_<PropagateOnContCopyAssign>
+   typedef boost::container::dtl::bool_<PropagateOnContCopyAssign>
       propagate_on_container_copy_assignment;
-   typedef boost::container::container_detail::bool_<PropagateOnContMoveAssign>
+   typedef boost::container::dtl::bool_<PropagateOnContMoveAssign>
       propagate_on_container_move_assignment;
-   typedef boost::container::container_detail::bool_<PropagateOnContSwap>
+   typedef boost::container::dtl::bool_<PropagateOnContSwap>
       propagate_on_container_swap;
 
    template<class T2>

test/emplace_test.hpp

@@ -144,7 +144,7 @@ bool test_expected_container(const Container &ec, const std::pair<EmplaceInt, Em
 }
 
 typedef std::pair<EmplaceInt, EmplaceInt> EmplaceIntPair;
-static boost::container::container_detail::aligned_storage<sizeof(EmplaceIntPair)*10>::type pair_storage;
+static boost::container::dtl::aligned_storage<sizeof(EmplaceIntPair)*10>::type pair_storage;
 
 static EmplaceIntPair* initialize_emplace_int_pair()
 {
@@ -160,7 +160,7 @@ static EmplaceIntPair * expected_pair = initialize_emplace_int_pair();
 
 
 template<class Container>
-bool test_emplace_back(container_detail::true_)
+bool test_emplace_back(dtl::true_)
 {
    std::cout << "Starting test_emplace_back." << std::endl << "  Class: "
       << typeid(Container).name() << std::endl;
@@ -209,11 +209,11 @@ bool test_emplace_back(container_detail::true_)
 }
 
 template<class Container>
-bool test_emplace_back(container_detail::false_)
+bool test_emplace_back(dtl::false_)
 {  return true;   }
 
 template<class Container>
-bool test_emplace_front(container_detail::true_)
+bool test_emplace_front(dtl::true_)
 {
    std::cout << "Starting test_emplace_front." << std::endl << "  Class: "
       << typeid(Container).name() << std::endl;
@@ -261,11 +261,11 @@ bool test_emplace_front(container_detail::true_)
 }
 
 template<class Container>
-bool test_emplace_front(container_detail::false_)
+bool test_emplace_front(dtl::false_)
 {  return true;   }
 
 template<class Container>
-bool test_emplace_before(container_detail::true_)
+bool test_emplace_before(dtl::true_)
 {
    std::cout << "Starting test_emplace_before." << std::endl << "  Class: "
       << typeid(Container).name() << std::endl;
@@ -373,11 +373,11 @@ bool test_emplace_before(container_detail::true_)
 }
 
 template<class Container>
-bool test_emplace_before(container_detail::false_)
+bool test_emplace_before(dtl::false_)
 {  return true;   }
 
 template<class Container>
-bool test_emplace_after(container_detail::true_)
+bool test_emplace_after(dtl::true_)
 {
    std::cout << "Starting test_emplace_after." << std::endl << "  Class: "
       << typeid(Container).name() << std::endl;
@@ -459,11 +459,11 @@ bool test_emplace_after(container_detail::true_)
 }
 
 template<class Container>
-bool test_emplace_after(container_detail::false_)
+bool test_emplace_after(dtl::false_)
 {  return true;   }
 
 template<class Container>
-bool test_emplace_assoc(container_detail::true_)
+bool test_emplace_assoc(dtl::true_)
 {
    std::cout << "Starting test_emplace_assoc." << std::endl << "  Class: "
       << typeid(Container).name() << std::endl;
@@ -506,11 +506,11 @@ bool test_emplace_assoc(container_detail::true_)
 }
 
 template<class Container>
-bool test_emplace_assoc(container_detail::false_)
+bool test_emplace_assoc(dtl::false_)
 {  return true;   }
 
 template<class Container>
-bool test_emplace_hint(container_detail::true_)
+bool test_emplace_hint(dtl::true_)
 {
    std::cout << "Starting test_emplace_hint." << std::endl << "  Class: "
       << typeid(Container).name() << std::endl;
@@ -556,11 +556,11 @@ bool test_emplace_hint(container_detail::true_)
 }
 
 template<class Container>
-bool test_emplace_hint(container_detail::false_)
+bool test_emplace_hint(dtl::false_)
 {  return true;   }
 
 template<class Container>
-bool test_emplace_assoc_pair(container_detail::true_)
+bool test_emplace_assoc_pair(dtl::true_)
 {
    std::cout << "Starting test_emplace_assoc_pair." << std::endl << "  Class: "
       << typeid(Container).name() << std::endl;
@@ -594,11 +594,11 @@ bool test_emplace_assoc_pair(container_detail::true_)
 }
 
 template<class Container>
-bool test_emplace_assoc_pair(container_detail::false_)
+bool test_emplace_assoc_pair(dtl::false_)
 {  return true;   }
 
 template<class Container>
-bool test_emplace_hint_pair(container_detail::true_)
+bool test_emplace_hint_pair(dtl::true_)
 {
    std::cout << "Starting test_emplace_hint_pair." << std::endl << "  Class: "
       << typeid(Container).name() << std::endl;
@@ -633,14 +633,14 @@ bool test_emplace_hint_pair(container_detail::true_)
 }
 
 template<class Container>
-bool test_emplace_hint_pair(container_detail::false_)
+bool test_emplace_hint_pair(dtl::false_)
 {  return true;   }
 
 template <EmplaceOptions O, EmplaceOptions Mask>
 struct emplace_active
 {
    static const bool value = (0 != (O & Mask));
-   typedef container_detail::bool_<value> type;
+   typedef dtl::bool_<value> type;
    operator type() const{  return type(); }
 };
 

test/expand_bwd_test_allocator.hpp

@@ -62,14 +62,14 @@ class expand_bwd_test_allocator
    typedef T                                    value_type;
    typedef T *                                  pointer;
    typedef const T *                            const_pointer;
-   typedef typename container_detail::add_reference
+   typedef typename dtl::add_reference
                      <value_type>::type         reference;
-   typedef typename container_detail::add_reference
+   typedef typename dtl::add_reference
                      <const value_type>::type   const_reference;
    typedef std::size_t                          size_type;
    typedef std::ptrdiff_t                       difference_type;
 
-   typedef boost::container::container_detail::version_type<expand_bwd_test_allocator, 2>   version;
+   typedef boost::container::dtl::version_type<expand_bwd_test_allocator, 2>   version;
 
    //Dummy multiallocation chain
    struct multiallocation_chain{};
@@ -95,10 +95,10 @@ class expand_bwd_test_allocator
       , m_offset(other.m_offset),  m_allocations(0){ }
 
    pointer address(reference value)
-   {  return pointer(container_detail::addressof(value));  }
+   {  return pointer(dtl::addressof(value));  }
 
    const_pointer address(const_reference value) const
-   {  return const_pointer(container_detail::addressof(value));  }
+   {  return const_pointer(dtl::addressof(value));  }
 
    pointer allocate(size_type , cvoid_ptr hint = 0)
    {  (void)hint; return 0; }

test/flat_map_test.cpp

@@ -370,13 +370,13 @@ struct GetMapContainer
       typedef flat_map< ValueType
                  , ValueType
                  , std::less<ValueType>
-                 , typename boost::container::container_detail::container_or_allocator_rebind<VoidAllocatorOrContainer, type_t>::type
+                 , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, type_t>::type
                  > map_type;
 
       typedef flat_multimap< ValueType
                  , ValueType
                  , std::less<ValueType>
-                 , typename boost::container::container_detail::container_or_allocator_rebind<VoidAllocatorOrContainer, type_t>::type
+                 , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, type_t>::type
                  > multimap_type;
    };
 };

test/flat_set_test.cpp

@@ -441,12 +441,12 @@ struct GetSetContainer
    {
       typedef flat_set < ValueType
                        , std::less<ValueType>
-                       , typename boost::container::container_detail::container_or_allocator_rebind<VoidAllocatorOrContainer, ValueType>::type
+                       , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, ValueType>::type
                         > set_type;
 
       typedef flat_multiset < ValueType
                             , std::less<ValueType>
-                            , typename boost::container::container_detail::container_or_allocator_rebind<VoidAllocatorOrContainer, ValueType>::type
+                            , typename boost::container::dtl::container_or_allocator_rebind<VoidAllocatorOrContainer, ValueType>::type
                             > multiset_type;
    };
 };

test/flat_tree_test.cpp

@@ -17,14 +17,14 @@
 
 using namespace boost::container;
 
-typedef boost::container::container_detail::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> pair_t;
+typedef boost::container::dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> pair_t;
 
 namespace boost {
 namespace container {
 
 //Explicit instantiation to detect compilation errors
 
-namespace container_detail {
+namespace dtl {
 
 template class flat_tree
    < pair_t
@@ -89,7 +89,7 @@ template class flat_tree
    , static_vector<test::movable_and_copyable_int, 10>
 >;
 
-}  //container_detail {
+}  //dtl {
 }} //boost::container
 
 #if (__cplusplus > 201103L)
@@ -97,7 +97,7 @@ template class flat_tree
 
 namespace boost{
 namespace container{
-namespace container_detail{
+namespace dtl{
 
 template class flat_tree
 < test::movable_and_copyable_int
@@ -113,7 +113,7 @@ template class flat_tree
    , std::vector<pair_t>
 >;
 
-}  //container_detail {
+}  //dtl {
 }} //boost::container
 
 #endif

test/list_test.cpp

@@ -34,7 +34,7 @@ template class boost::container::list
    < test::movable_and_copyable_int
    , adaptive_pool<test::movable_and_copyable_int> >;
 
-namespace container_detail {
+namespace dtl {
 
 template class iterator_from_iiterator
    <intrusive_list_type< std::allocator<int> >::container_type::iterator, true >;

test/list_test.hpp

@@ -28,14 +28,14 @@ namespace container {
 namespace test{
 
 template<class V1, class V2>
-bool list_copyable_only(V1 &, V2 &, boost::container::container_detail::false_type)
+bool list_copyable_only(V1 &, V2 &, boost::container::dtl::false_type)
 {
    return true;
 }
 
 //Function to check if both sets are equal
 template<class V1, class V2>
-bool list_copyable_only(V1 &boostlist, V2 &stdlist, boost::container::container_detail::true_type)
+bool list_copyable_only(V1 &boostlist, V2 &stdlist, boost::container::dtl::true_type)
 {
    typedef typename V1::value_type IntType;
    boostlist.insert(boostlist.end(), 50, IntType(1));
@@ -403,7 +403,7 @@ int list_test (bool copied_allocators_equal = true)
       }
 
       if(!list_copyable_only(boostlist, stdlist
-                     ,container_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
+                     ,dtl::bool_<boost::container::test::is_copyable<IntType>::value>())){
          return 1;
       }
    }

test/map_test.hpp

@@ -42,11 +42,11 @@ namespace container {
 namespace test{
 
 template<class C>
-void map_test_rebalanceable(C &, boost::container::container_detail::false_type)
+void map_test_rebalanceable(C &, boost::container::dtl::false_type)
 {}
 
 template<class C>
-void map_test_rebalanceable(C &c, boost::container::container_detail::true_type)
+void map_test_rebalanceable(C &c, boost::container::dtl::true_type)
 {
    c.rebalance();
 }
@@ -55,17 +55,17 @@ template<class MyBoostMap
         ,class MyStdMap
         ,class MyBoostMultiMap
         ,class MyStdMultiMap>
-int map_test_copyable(boost::container::container_detail::false_type)
+int map_test_copyable(boost::container::dtl::false_type)
 {  return 0; }
 
 template<class MyBoostMap
         ,class MyStdMap
         ,class MyBoostMultiMap
         ,class MyStdMultiMap>
-int map_test_copyable(boost::container::container_detail::true_type)
+int map_test_copyable(boost::container::dtl::true_type)
 {
    typedef typename MyBoostMap::key_type    IntType;
-   typedef container_detail::pair<IntType, IntType>         IntPairType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
    typedef typename MyStdMap::value_type  StdPairType;
 
    const int MaxElem = 50;
@@ -136,7 +136,7 @@ template<class MyBoostMap
 int map_test()
 {
    typedef typename MyBoostMap::key_type    IntType;
-   typedef container_detail::pair<IntType, IntType>         IntPairType;
+   typedef dtl::pair<IntType, IntType>         IntPairType;
    typedef typename MyStdMap::value_type  StdPairType;
    const int MaxElem = 50;
    typedef typename MyStdMap::value_type StdValueType;
@@ -615,13 +615,13 @@ int map_test()
             return 1;
 
          map_test_rebalanceable(boostmap
-            , container_detail::bool_<has_member_rebalance<MyBoostMap>::value>());
+            , dtl::bool_<has_member_rebalance<MyBoostMap>::value>());
          if(!CheckEqualContainers(boostmap, stdmap)){
             std::cout << "Error in boostmap.rebalance()" << std::endl;
             return 1;
          }
          map_test_rebalanceable(boostmultimap
-            , container_detail::bool_<has_member_rebalance<MyBoostMap>::value>());
+            , dtl::bool_<has_member_rebalance<MyBoostMap>::value>());
          if(!CheckEqualContainers(boostmultimap, stdmultimap)){
             std::cout << "Error in boostmultimap.rebalance()" << std::endl;
             return 1;
@@ -898,7 +898,7 @@ int map_test()
    }
 
    if(map_test_copyable<MyBoostMap, MyStdMap, MyBoostMultiMap, MyStdMultiMap>
-      (container_detail::bool_<boost::container::test::is_copyable<IntType>::value>())){
+      (dtl::bool_<boost::container::test::is_copyable<IntType>::value>())){
       return 1;
    }
    return 0;

test/node_handle_test.cpp

@@ -174,16 +174,16 @@ typedef allocator_traits<node_alloc_t>::portable_rebind_alloc<test_pair>::type v
 void test_types()
 {
    //set
-   BOOST_STATIC_ASSERT(( container_detail::is_same<node_handle_set_t::value_type, test_pair>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same<node_handle_set_t::key_type, test_pair>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same<node_handle_set_t::mapped_type, test_pair>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same<node_handle_set_t::allocator_type, value_allocator_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::value_type, test_pair>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::key_type, test_pair>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::mapped_type, test_pair>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_set_t::allocator_type, value_allocator_type>::value ));
 
    //map
-   BOOST_STATIC_ASSERT(( container_detail::is_same<node_handle_map_t::value_type, test_pair>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same<node_handle_map_t::key_type, int>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same<node_handle_map_t::mapped_type, unsigned>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same<node_handle_map_t::allocator_type, value_allocator_type>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::value_type, test_pair>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::key_type, int>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::mapped_type, unsigned>::value ));
+   BOOST_STATIC_ASSERT(( dtl::is_same<node_handle_map_t::allocator_type, value_allocator_type>::value ));
 }
 
 void test_default_constructor()

test/null_iterators_test.cpp

@@ -28,7 +28,7 @@
 
 using namespace boost::container;
 
-typedef boost::container::container_detail::aligned_storage<sizeof(void*)*4>::type buffer_t;
+typedef boost::container::dtl::aligned_storage<sizeof(void*)*4>::type buffer_t;
 
 static buffer_t buffer_0x00;
 static buffer_t buffer_0xFF;

test/pair_test.cpp

@@ -36,50 +36,50 @@ using namespace ::boost::container;
 int main ()
 {
    {
-      container_detail::pair<test::non_copymovable_int, test::non_copymovable_int> p1;
-      container_detail::pair<test::copyable_int, test::copyable_int> p2;
-      container_detail::pair<test::movable_int, test::movable_int> p3;
-      container_detail::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4;
+      dtl::pair<test::non_copymovable_int, test::non_copymovable_int> p1;
+      dtl::pair<test::copyable_int, test::copyable_int> p2;
+      dtl::pair<test::movable_int, test::movable_int> p3;
+      dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4;
    }
    {  //Constructible from two values
-      container_detail::pair<test::non_copymovable_int, test::non_copymovable_int> p1(1, 2);
-      container_detail::pair<test::copyable_int, test::copyable_int> p2(1, 2);
-      container_detail::pair<test::movable_int, test::movable_int> p3(1, 2);
-      container_detail::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4(1, 2);
+      dtl::pair<test::non_copymovable_int, test::non_copymovable_int> p1(1, 2);
+      dtl::pair<test::copyable_int, test::copyable_int> p2(1, 2);
+      dtl::pair<test::movable_int, test::movable_int> p3(1, 2);
+      dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4(1, 2);
    }
 
    {  //Constructible from internal types
-      container_detail::pair<test::copyable_int, test::copyable_int> p2(test::copyable_int(1), test::copyable_int(2));
+      dtl::pair<test::copyable_int, test::copyable_int> p2(test::copyable_int(1), test::copyable_int(2));
       {
          test::movable_int a(1), b(2);
-         container_detail::pair<test::movable_int, test::movable_int> p3(::boost::move(a), ::boost::move(b));
+         dtl::pair<test::movable_int, test::movable_int> p3(::boost::move(a), ::boost::move(b));
       }
       {
          test::movable_and_copyable_int a(1), b(2);
-         container_detail::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4(::boost::move(a), ::boost::move(b));
+         dtl::pair<test::movable_and_copyable_int, test::movable_and_copyable_int> p4(::boost::move(a), ::boost::move(b));
       }
    }
    {  //piecewise construct from boost tuple
       using namespace boost::tuples;
       {
-         boost::container::container_detail::pair<int, float> p(piecewise_construct, tuple<>(), tuple<>());
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<>());
          BOOST_TEST(p.first == 0);
          BOOST_TEST(p.second == 0.f);
       }
       {
-         boost::container::container_detail::pair<int, float> p(piecewise_construct, tuple<>(), tuple<float>(2.f));
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<float>(2.f));
          BOOST_TEST(p.first == 0);
          BOOST_TEST(p.second == 2.f);
       }
       {
-         boost::container::container_detail::pair<int, float> p(piecewise_construct, tuple<int>(2), tuple<float>(1.f));
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<int>(2), tuple<float>(1.f));
          BOOST_TEST(p.first == 2);
          BOOST_TEST(p.second == 1.f);
       }
       {
-         boost::container::container_detail::pair
-            < boost::container::container_detail::pair<int, float>
-            , boost::container::container_detail::pair<double, char>
+         boost::container::dtl::pair
+            < boost::container::dtl::pair<int, float>
+            , boost::container::dtl::pair<double, char>
             > p(piecewise_construct, tuple<int, float>(3, 4.f), tuple<double, char>(8.,'a'));
          BOOST_TEST(p.first.first   == 3);
          BOOST_TEST(p.first.second  == 4.f);
@@ -87,7 +87,7 @@ int main ()
          BOOST_TEST(p.second.second == 'a');
       }
       {
-         boost::container::container_detail::pair
+         boost::container::dtl::pair
             < tuple<int, float, double>
             , char
             > p(piecewise_construct, tuple<int, float, double>(3, 16.f, 32.), tuple<char>('b'));
@@ -101,24 +101,24 @@ int main ()
    {  //piecewise construct from std tuple
       using std::tuple;
       {
-         boost::container::container_detail::pair<int, float> p(piecewise_construct, tuple<>(), tuple<>());
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<>());
          BOOST_TEST(p.first == 0);
          BOOST_TEST(p.second == 0.f);
       }
       {
-         boost::container::container_detail::pair<int, float> p(piecewise_construct, tuple<>(), tuple<float>(2.f));
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<>(), tuple<float>(2.f));
          BOOST_TEST(p.first == 0);
          BOOST_TEST(p.second == 2.f);
       }
       {
-         boost::container::container_detail::pair<int, float> p(piecewise_construct, tuple<int>(2), tuple<float>(1.f));
+         boost::container::dtl::pair<int, float> p(piecewise_construct, tuple<int>(2), tuple<float>(1.f));
          BOOST_TEST(p.first == 2);
          BOOST_TEST(p.second == 1.f);
       }
       {
-         boost::container::container_detail::pair
-            < boost::container::container_detail::pair<int, float>
-            , boost::container::container_detail::pair<double, char>
+         boost::container::dtl::pair
+            < boost::container::dtl::pair<int, float>
+            , boost::container::dtl::pair<double, char>
             > p(piecewise_construct, tuple<int, float>(3, 4.f), tuple<double, char>(8.,'a'));
          BOOST_TEST(p.first.first   == 3);
          BOOST_TEST(p.first.second  == 4.f);
@@ -126,7 +126,7 @@ int main ()
          BOOST_TEST(p.second.second == 'a');
       }
       {
-         boost::container::container_detail::pair
+         boost::container::dtl::pair
             < tuple<int, float, double>
             , char
             > p(piecewise_construct, tuple<int, float, double>(3, 16.f, 32.), tuple<char>('b'));
@@ -136,12 +136,12 @@ int main ()
          BOOST_TEST(p.second == 'b');
       }
       #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) && !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
-      typedef container_detail::pair<test::movable_int, test::movable_int> movable_pair_t;
-      typedef container_detail::pair<movable_pair_t, movable_pair_t> movable_pair_pair_t;
+      typedef dtl::pair<test::movable_int, test::movable_int> movable_pair_t;
+      typedef dtl::pair<movable_pair_t, movable_pair_t> movable_pair_pair_t;
       test::movable_int a(1), b(2), c(3), d(4);
       movable_pair_pair_t p( piecewise_construct
-                           , container_detail::forward_as_tuple(boost::move(a), boost::move(b))
-                           , container_detail::forward_as_tuple(boost::move(c), boost::move(d))
+                           , dtl::forward_as_tuple(boost::move(a), boost::move(b))
+                           , dtl::forward_as_tuple(boost::move(c), boost::move(d))
                            );
       BOOST_TEST(p.first.first   == 1);
       BOOST_TEST(p.first.second  == 2);

test/pmr_deque_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef deque<int, pmr::polymorphic_allocator<int> > intcontainer_t;
    BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::deque_of<int>::type >::value ));

test/pmr_flat_map_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef flat_map<int, float, std::less<int>, pmr::polymorphic_allocator<std::pair<int, float> > > intcontainer_t;
    BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_map_of<int, float>::type >::value ));

test/pmr_flat_set_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef flat_set<int, std::less<int>, pmr::polymorphic_allocator<int> > intcontainer_t;
    BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::flat_set_of<int>::type >::value ));

test/pmr_list_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef list<int, pmr::polymorphic_allocator<int> > intcontainer_t;
    BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::list_of<int>::type >::value ));

test/pmr_map_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef map<int, float, std::less<int>, pmr::polymorphic_allocator<std::pair<const int, float> > > intcontainer_t;
    BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::map_of<int, float>::type >::value ));

test/pmr_set_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef set<int, std::less<int>, pmr::polymorphic_allocator<int> > intcontainer_t;
    BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::set_of<int>::type >::value ));

test/pmr_small_vector_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef small_vector<int, 2, pmr::polymorphic_allocator<int> > intcontainer_t;
    BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::small_vector_of<int, 2>::type >::value ));

test/pmr_stable_vector_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef stable_vector<int, pmr::polymorphic_allocator<int> > intcontainer_t;
    BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::stable_vector_of<int>::type >::value ));

test/pmr_string_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef basic_string<char, std::char_traits<char>, pmr::polymorphic_allocator<char> > string_t;
    typedef basic_string<wchar_t, std::char_traits<wchar_t>, pmr::polymorphic_allocator<wchar_t> > wstring_t;

test/pmr_vector_test.cpp

@@ -15,7 +15,7 @@
 int main()
 {
    using namespace boost::container;
-   using boost::container::container_detail::is_same;
+   using boost::container::dtl::is_same;
 
    typedef vector<int, pmr::polymorphic_allocator<int> > intcontainer_t;
    BOOST_STATIC_ASSERT(( is_same<intcontainer_t, pmr::vector_of<int>::type >::value ));

test/polymorphic_allocator_test.cpp

@@ -63,7 +63,7 @@ void test_allocate()
    BOOST_TEST(d.do_allocate_return == &dummy);
    //It shall allocate 2*sizeof(int), alignment_of<int>
    BOOST_TEST(d.do_allocate_bytes == 2*sizeof(int));
-   BOOST_TEST(d.do_allocate_alignment == container_detail::alignment_of<int>::value);
+   BOOST_TEST(d.do_allocate_alignment == dtl::alignment_of<int>::value);
 }
 
 void test_deallocate()
@@ -77,7 +77,7 @@ void test_deallocate()
    //It shall deallocate 2*sizeof(int), alignment_of<int>
    BOOST_TEST(d.do_deallocate_p == &dummy);
    BOOST_TEST(d.do_deallocate_bytes == 3*sizeof(int));
-   BOOST_TEST(d.do_deallocate_alignment == container_detail::alignment_of<int>::value);
+   BOOST_TEST(d.do_deallocate_alignment == dtl::alignment_of<int>::value);
 }
 
 void test_construct()

test/propagation_test_allocator.hpp

@@ -29,10 +29,10 @@ class propagation_test_allocator
       typedef propagation_test_allocator<U, Id, HasTrueTypes> other;
    };
 
-   typedef boost::container::container_detail::bool_<HasTrueTypes>  propagate_on_container_copy_assignment;
-   typedef boost::container::container_detail::bool_<HasTrueTypes>  propagate_on_container_move_assignment;
-   typedef boost::container::container_detail::bool_<HasTrueTypes>  propagate_on_container_swap;
-   typedef boost::container::container_detail::bool_<HasTrueTypes>  is_always_equal;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_copy_assignment;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_move_assignment;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  propagate_on_container_swap;
+   typedef boost::container::dtl::bool_<HasTrueTypes>  is_always_equal;
    typedef T value_type;
 
    propagation_test_allocator()

test/scoped_allocator_adaptor_test.cpp

@@ -98,81 +98,81 @@ int main()
                                    , InnerAlloc2 >          Rebound9Scoped2Inner;
 
    //outer_allocator_type
-   BOOST_STATIC_ASSERT(( container_detail::is_same< OuterAlloc
+   BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
                        , Scoped0Inner::outer_allocator_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< OuterAlloc
+   BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
                        , Scoped1Inner::outer_allocator_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< OuterAlloc
+   BOOST_STATIC_ASSERT(( dtl::is_same< OuterAlloc
                        , Scoped2Inner::outer_allocator_type>::value ));
    //value_type
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::value_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
                        , Scoped0Inner::value_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::value_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
                        , Scoped1Inner::value_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::value_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::value_type
                        , Scoped2Inner::value_type>::value ));
    //size_type
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::size_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
                        , Scoped0Inner::size_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::size_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
                        , Scoped1Inner::size_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::size_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::size_type
                        , Scoped2Inner::size_type>::value ));
 
    //difference_type
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::difference_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
                        , Scoped0Inner::difference_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::difference_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
                        , Scoped1Inner::difference_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::difference_type
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::difference_type
                        , Scoped2Inner::difference_type>::value ));
 
    //pointer
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
                        , Scoped0Inner::pointer>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
                        , Scoped1Inner::pointer>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::pointer
                        , Scoped2Inner::pointer>::value ));
 
    //const_pointer
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
                        , Scoped0Inner::const_pointer>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
                        , Scoped1Inner::const_pointer>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_pointer
                        , Scoped2Inner::const_pointer>::value ));
 
    //void_pointer
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::void_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
                        , Scoped0Inner::void_pointer>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::void_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
                        , Scoped1Inner::void_pointer>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::void_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::void_pointer
                        , Scoped2Inner::void_pointer>::value ));
 
    //const_void_pointer
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_void_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
                        , Scoped0Inner::const_void_pointer>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_void_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
                        , Scoped1Inner::const_void_pointer>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< allocator_traits<OuterAlloc>::const_void_pointer
+   BOOST_STATIC_ASSERT(( dtl::is_same< allocator_traits<OuterAlloc>::const_void_pointer
                        , Scoped2Inner::const_void_pointer>::value ));
 
    //rebind
-   BOOST_STATIC_ASSERT(( container_detail::is_same<Scoped0Inner::rebind< tagged_integer<9> >::other
+   BOOST_STATIC_ASSERT(( dtl::is_same<Scoped0Inner::rebind< tagged_integer<9> >::other
                        , Rebound9Scoped0Inner >::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same<Scoped1Inner::rebind< tagged_integer<9> >::other
+   BOOST_STATIC_ASSERT(( dtl::is_same<Scoped1Inner::rebind< tagged_integer<9> >::other
                        , Rebound9Scoped1Inner >::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same<Scoped2Inner::rebind< tagged_integer<9> >::other
+   BOOST_STATIC_ASSERT(( dtl::is_same<Scoped2Inner::rebind< tagged_integer<9> >::other
                        , Rebound9Scoped2Inner >::value ));
 
    //inner_allocator_type
-   BOOST_STATIC_ASSERT(( container_detail::is_same< Scoped0Inner
+   BOOST_STATIC_ASSERT(( dtl::is_same< Scoped0Inner
                        , Scoped0Inner::inner_allocator_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< scoped_allocator_adaptor<InnerAlloc1>
+   BOOST_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1>
                        , Scoped1Inner::inner_allocator_type>::value ));
-   BOOST_STATIC_ASSERT(( container_detail::is_same< scoped_allocator_adaptor<InnerAlloc1, InnerAlloc2>
+   BOOST_STATIC_ASSERT(( dtl::is_same< scoped_allocator_adaptor<InnerAlloc1, InnerAlloc2>
                        , Scoped2Inner::inner_allocator_type>::value ));
 
    {
@@ -685,15 +685,15 @@ int main()
          //Check outer_allocator_type is scoped
          BOOST_STATIC_ASSERT(( is_scoped_allocator
             <ScopedScoped0Inner::outer_allocator_type>::value ));
-         BOOST_STATIC_ASSERT(( container_detail::is_same
+         BOOST_STATIC_ASSERT(( dtl::is_same
             < outermost_allocator<ScopedScoped0Inner>::type
             , Outer10IdAlloc
             >::value ));
-         BOOST_STATIC_ASSERT(( container_detail::is_same
+         BOOST_STATIC_ASSERT(( dtl::is_same
             < ScopedScoped0Inner::outer_allocator_type
             , scoped_allocator_adaptor<Outer10IdAlloc>
             >::value ));
-         BOOST_STATIC_ASSERT(( container_detail::is_same
+         BOOST_STATIC_ASSERT(( dtl::is_same
             < scoped_allocator_adaptor<Outer10IdAlloc>::outer_allocator_type
             , Outer10IdAlloc
             >::value ));
@@ -768,15 +768,15 @@ int main()
          //Check outer_allocator_type is scoped
          BOOST_STATIC_ASSERT(( is_scoped_allocator
             <ScopedScoped1Inner::outer_allocator_type>::value ));
-         BOOST_STATIC_ASSERT(( container_detail::is_same
+         BOOST_STATIC_ASSERT(( dtl::is_same
             < outermost_allocator<ScopedScoped1Inner>::type
             , Outer10IdAlloc
             >::value ));
-         BOOST_STATIC_ASSERT(( container_detail::is_same
+         BOOST_STATIC_ASSERT(( dtl::is_same
             < ScopedScoped1Inner::outer_allocator_type
             , scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1>
             >::value ));
-         BOOST_STATIC_ASSERT(( container_detail::is_same
+         BOOST_STATIC_ASSERT(( dtl::is_same
             < scoped_allocator_adaptor<Outer10IdAlloc, Inner11IdAlloc1>::outer_allocator_type
             , Outer10IdAlloc
             >::value ));
@@ -856,7 +856,7 @@ int main()
       //used to construct types.
       ////////////////////////////////////////////////////////////
       {
-         using container_detail::pair;
+         using dtl::pair;
          typedef propagation_test_allocator< pair< tagged_integer<0>
                                , tagged_integer<0> >, 0> OuterPairAlloc;
          //

test/scoped_allocator_usage_test.cpp

@@ -341,7 +341,7 @@ bool test_value_and_state_equals(const alloc_int &r, int value, int state)
 {  return r.get_value() == value && r.get_allocator_state() == state;  }
 
 template<class F, class S>
-bool test_value_and_state_equals(const container_detail::pair<F, S> &p, int value, int state)
+bool test_value_and_state_equals(const dtl::pair<F, S> &p, int value, int state)
 {  return test_value_and_state_equals(p.first, value, state) && test_alloc_state_equals(p.second, value, state);  }
 
 template<class F, class S>