passenger 5.3.3 → 5.3.4

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

@@ -0,0 +1,55 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying file
+// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/container for documentation.
+//
+//////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_CONTAINER_PAIR_KEY_MAPPED_OF_VALUE_HPP
+#define BOOST_CONTAINER_PAIR_KEY_MAPPED_OF_VALUE_HPP
+
+#ifndef BOOST_CONFIG_HPP
+#  include <boost/config.hpp>
+#endif
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
+
+#include <boost/container/detail/config_begin.hpp>
+#include <boost/container/detail/workaround.hpp>
+
+namespace boost {
+namespace container {
+
+template<class Key, class Mapped>
+struct pair_key_mapped_of_value
+{
+   typedef Key    key_type;
+   typedef Mapped mapped_type;
+
+   template<class Pair>
+   const key_type & key_of_value(const Pair &p) const
+   {  return p.first;  }
+
+   template<class Pair>
+   const mapped_type & mapped_of_value(const Pair &p) const
+   {  return p.second;  }
+
+   template<class Pair>
+   key_type & key_of_value(Pair &p) const
+   {  return const_cast<key_type&>(p.first);  }
+
+   template<class Pair>
+   mapped_type & mapped_of_value(Pair &p) const
+   {  return p.second;  }
+
+};
+
+}}
+
+#include <boost/container/detail/config_end.hpp>
+
+#endif   // BOOST_CONTAINER_PAIR_KEY_MAPPED_OF_VALUE_HPP

data/src/cxx_supportlib/vendor-modified/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 {
 

data/src/cxx_supportlib/vendor-modified/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 {
 

data/src/cxx_supportlib/vendor-modified/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
 

data/src/cxx_supportlib/vendor-modified/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>

data/src/cxx_supportlib/vendor-modified/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
@@ -429,25 +429,40 @@ struct key_node_compare
    {  return this->key_comp()(key_of_value()(nonkey1.get_data()), key_of_value()(nonkey2.get_data()));  }
 };
 
-template <class T, class KeyOfValue,
-          class Compare, class Allocator,
-          class Options = tree_assoc_defaults>
+template<class Options>
+struct get_tree_opt
+{
+   typedef Options type;
+};
+
+template<>
+struct get_tree_opt<void>
+{
+   typedef tree_assoc_defaults type;
+};
+
+template <class T, class KeyOfValue, class Compare, class Allocator, class Options>
 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
+         , get_tree_opt<Options>::type::tree_type
+         , get_tree_opt<Options>::type::optimize_size
+         >::type
       >
 {
    typedef tree_value_compare
       < typename allocator_traits<Allocator>::pointer
       , Compare, KeyOfValue>                                ValComp;
-   typedef typename container_detail::intrusive_tree_type
-         < Allocator, ValComp, Options::tree_type
-         , Options::optimize_size>::type                    Icont;
-   typedef container_detail::node_alloc_holder
+   typedef typename get_tree_opt<Options>::type             options_type;
+   typedef typename dtl::intrusive_tree_type
+         < Allocator, ValComp
+         , options_type::tree_type
+         , options_type::optimize_size
+         >::type                                            Icont;
+   typedef dtl::node_alloc_holder
       <Allocator, Icont>                                    AllocHolder;
    typedef typename AllocHolder::NodePtr                    NodePtr;
    typedef tree < T, KeyOfValue
@@ -459,9 +474,9 @@ 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;
+   typedef intrusive_tree_proxy<options_type::tree_type>    intrusive_tree_proxy_t;
 
    BOOST_COPYABLE_AND_MOVABLE(tree)
 
@@ -484,16 +499,16 @@ 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;
    typedef boost::container::reverse_iterator
       <const_iterator>                                const_reverse_iterator;
    typedef node_handle
-      < Node, value_type, allocator_type, void>       node_type;
+      < NodeAlloc, void>                              node_type;
    typedef insert_return_type_base
       <iterator, node_type>                           insert_return_type;
 
@@ -509,7 +524,11 @@ class tree
       : AllocHolder()
    {}
 
-   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp, const allocator_type& a = allocator_type())
+   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp)
+      : AllocHolder(ValComp(comp))
+   {}
+
+   BOOST_CONTAINER_FORCEINLINE explicit tree(const key_compare& comp, const allocator_type& a)
       : AllocHolder(ValComp(comp), a)
    {}
 
@@ -518,110 +537,153 @@ class tree
    {}
 
    template <class InputIterator>
-   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
-          const allocator_type& a
-      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_or
-         < void
-         , container_detail::is_same<alloc_version, version_1>
-         , container_detail::is_input_iterator<InputIterator>
-         >::type * = 0
-      #endif
-         )
+   tree(bool unique_insertion, InputIterator first, InputIterator last)
+      : AllocHolder(value_compare(key_compare()))
+   {
+      this->tree_construct(unique_insertion, first, last);
+      //AllocHolder clears in case of exception
+   }
+
+   template <class InputIterator>
+   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp)
+      : AllocHolder(value_compare(comp))
+   {
+      this->tree_construct(unique_insertion, first, last);
+      //AllocHolder clears in case of exception
+   }
+
+   template <class InputIterator>
+   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp, const allocator_type& a)
       : AllocHolder(value_compare(comp), a)
+   {
+      this->tree_construct(unique_insertion, first, last);
+      //AllocHolder clears in case of exception
+   }
+
+   //construct with ordered range
+   template <class InputIterator>
+   tree( ordered_range_t, InputIterator first, InputIterator last)
+      : AllocHolder(value_compare(key_compare()))
+   {
+      this->tree_construct(ordered_range_t(), first, last);
+   }
+
+   template <class InputIterator>
+   tree( ordered_range_t, InputIterator first, InputIterator last, const key_compare& comp)
+      : AllocHolder(value_compare(comp))
+   {
+      this->tree_construct(ordered_range_t(), first, last);
+   }
+
+   template <class InputIterator>
+   tree( ordered_range_t, InputIterator first, InputIterator last
+         , const key_compare& comp, const allocator_type& a)
+      : AllocHolder(value_compare(comp), a)
+   {
+      this->tree_construct(ordered_range_t(), first, last);
+   }
+
+   private:
+
+   template <class InputIterator>
+   void tree_construct(bool unique_insertion, InputIterator first, InputIterator last)
    {
       //Use cend() as hint to achieve linear time for
       //ordered ranges as required by the standard
       //for the constructor
-      const const_iterator end_it(this->cend());
       if(unique_insertion){
+         const const_iterator end_it(this->cend());
          for ( ; first != last; ++first){
             this->insert_unique_convertible(end_it, *first);
          }
       }
       else{
-         for ( ; first != last; ++first){
-            this->insert_equal_convertible(end_it, *first);
-         }
+         this->tree_construct_non_unique(first, last);
       }
    }
 
    template <class InputIterator>
-   tree(bool unique_insertion, InputIterator first, InputIterator last, const key_compare& comp,
-          const allocator_type& a
+   void tree_construct_non_unique(InputIterator first, InputIterator last
       #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::disable_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
          )
-      : AllocHolder(value_compare(comp), a)
    {
-      if(unique_insertion){
-         //Use cend() as hint to achieve linear time for
-         //ordered ranges as required by the standard
-         //for the constructor
-         const const_iterator end_it(this->cend());
-         for ( ; first != last; ++first){
-            this->insert_unique_convertible(end_it, *first);
-         }
-      }
-      else{
-         //Optimized allocation and construction
-         this->allocate_many_and_construct
-            ( first, boost::container::iterator_distance(first, last)
-            , insert_equal_end_hint_functor<Node, Icont>(this->icont()));
+      //Use cend() as hint to achieve linear time for
+      //ordered ranges as required by the standard
+      //for the constructor
+      const const_iterator end_it(this->cend());
+      for ( ; first != last; ++first){
+         this->insert_equal_convertible(end_it, *first);
       }
    }
 
    template <class InputIterator>
-   tree( ordered_range_t, InputIterator first, InputIterator last
-         , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
-         #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
-      , typename container_detail::enable_if_or
+   void tree_construct_non_unique(InputIterator first, InputIterator last
+      #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+      , 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
+      #endif
          )
-      : AllocHolder(value_compare(comp), a)
    {
-      for ( ; first != last; ++first){
-         this->push_back_impl(*first);
-      }
+      //Optimized allocation and construction
+      this->allocate_many_and_construct
+         ( first, boost::container::iterator_distance(first, last)
+         , insert_equal_end_hint_functor<Node, Icont>(this->icont()));
    }
 
    template <class InputIterator>
-   tree( ordered_range_t, InputIterator first, InputIterator last
-         , const key_compare& comp = key_compare(), const allocator_type& a = allocator_type()
+   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
          )
-      : AllocHolder(value_compare(comp), a)
    {
       //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 dtl::enable_if_or
+         < void
+         , dtl::is_same<alloc_version, version_1>
+         , dtl::is_input_iterator<InputIterator>
+         >::type * = 0
+         #endif
+         )
+   {
+      for ( ; first != last; ++first){
+         this->push_back_impl(*first);
+      }
+   }
+
+   public:
+
    BOOST_CONTAINER_FORCEINLINE tree(const tree& x)
-      :  AllocHolder(x.value_comp(), x)
+      :  AllocHolder(x, x.value_comp())
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
    }
 
    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())
    {}
 
@@ -630,6 +692,7 @@ class tree
    {
       this->icont().clone_from
          (x.icont(), typename AllocHolder::cloner(*this), Destroyer(this->node_alloc()));
+      //AllocHolder clears in case of exception
    }
 
    tree(BOOST_RV_REF(tree) x, const allocator_type &a)
@@ -642,6 +705,7 @@ class tree
          this->icont().clone_from
             (boost::move(x.icont()), typename AllocHolder::move_cloner(*this), Destroyer(this->node_alloc()));
       }
+      //AllocHolder clears in case of exception
    }
 
    BOOST_CONTAINER_FORCEINLINE ~tree()
@@ -652,7 +716,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();
@@ -681,7 +745,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();
@@ -807,7 +871,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:
@@ -1142,7 +1206,7 @@ class tree
             this->insert_unique_check(hint, KeyOfValue()(nh.value()), data);
          if(ret.second){
             irt.inserted = true;
-            irt.position = iterator(this->icont().insert_unique_commit(*nh.get_node_pointer(), data));
+            irt.position = iterator(this->icont().insert_unique_commit(*nh.get(), data));
             nh.release();
          }
          else{
@@ -1266,7 +1330,7 @@ class tree
    {  x.swap(y);  }
 };
 
-} //namespace container_detail {
+} //namespace dtl {
 } //namespace container {
 
 template <class T>
@@ -1277,7 +1341,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>
    >
 {