passenger 6.0.3 → 6.0.8

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

@@ -69,11 +69,11 @@ struct select1st
    typedef FirstType type;
 
    template<class T>
-   const type& operator()(const T& x) const
+   BOOST_CONTAINER_FORCEINLINE const type& operator()(const T& x) const
    {  return x.first;   }
 
    template<class T>
-   type& operator()(T& x)
+   BOOST_CONTAINER_FORCEINLINE type& operator()(T& x)
    {  return const_cast<type&>(x.first);   }
 };
 

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

@@ -24,6 +24,7 @@
 #include <boost/container/detail/config_begin.hpp>
 #include <boost/container/detail/workaround.hpp>
 
+#include <boost/static_assert.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/mpl.hpp>
@@ -188,8 +189,36 @@ void get(T); //to enable ADL
 
 ///@endcond
 
+#ifdef  _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
+//Libc++, in some versions, has an ABI breakage that needs some
+//padding in dtl::pair, as "std::pair::first" is not at offset zero.
+//See: https://reviews.llvm.org/D56357 for more information.
+//
+template <class T1, class T2, std::size_t N>
+struct pair_padding
+{
+   char padding[N];
+};
+
+template <class T1, class T2>
+struct pair_padding<T1, T2, 0>
+{
+};
+
+template <class T1, class T2>
+struct simple_pair
+{
+   T1 first;
+   T2 second;
+};
+
+#endif
+
 template <class T1, class T2>
 struct pair
+#ifdef  _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
+   : pair_padding<T1, T2, sizeof(std::pair<T1, T2>) - sizeof(simple_pair<T1, T2>)>
+#endif
 {
    private:
    BOOST_COPYABLE_AND_MOVABLE(pair)
@@ -204,64 +233,88 @@ struct pair
    //Default constructor
    pair()
       : first(), second()
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    //pair copy assignment
    pair(const pair& x)
       : first(x.first), second(x.second)
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    //pair move constructor
    pair(BOOST_RV_REF(pair) p)
       : first(::boost::move(p.first)), second(::boost::move(p.second))
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    template <class D, class S>
    pair(const pair<D, S> &p)
       : first(p.first), second(p.second)
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    template <class D, class S>
    pair(BOOST_RV_REF_BEG pair<D, S> BOOST_RV_REF_END p)
       : first(::boost::move(p.first)), second(::boost::move(p.second))
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    //pair from two values
    pair(const T1 &t1, const T2 &t2)
       : first(t1)
       , second(t2)
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    template<class U, class V>
    pair(BOOST_FWD_REF(U) u, BOOST_FWD_REF(V) v)
       : first(::boost::forward<U>(u))
       , second(::boost::forward<V>(v))
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    //And now compatibility with std::pair
    pair(const std::pair<T1, T2>& x)
       : first(x.first), second(x.second)
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    template <class D, class S>
    pair(const std::pair<D, S>& p)
       : first(p.first), second(p.second)
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    pair(BOOST_RV_REF_BEG std::pair<T1, T2> BOOST_RV_REF_END p)
       : first(::boost::move(p.first)), second(::boost::move(p.second))
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    template <class D, class S>
    pair(BOOST_RV_REF_BEG std::pair<D, S> BOOST_RV_REF_END p)
       : first(::boost::move(p.first)), second(::boost::move(p.second))
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
    template< class KeyType, class ...Args>
    pair(try_emplace_t, BOOST_FWD_REF(KeyType) k, Args && ...args)
       : first(boost::forward<KeyType>(k)), second(::boost::forward<Args>(args)...)\
-   {}
+   {
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+   }
    #else
 
    //piecewise construction from boost::tuple
@@ -269,7 +322,9 @@ struct pair
    template< class KeyType BOOST_MOVE_I##N BOOST_MOVE_CLASS##N > \
    pair( try_emplace_t, BOOST_FWD_REF(KeyType) k BOOST_MOVE_I##N BOOST_MOVE_UREF##N )\
       : first(boost::forward<KeyType>(k)), second(BOOST_MOVE_FWD##N)\
-   {}\
+   {\
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+   }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_PAIR_TRY_EMPLACE_CONSTRUCT_CODE)
    #undef BOOST_PAIR_TRY_EMPLACE_CONSTRUCT_CODE
@@ -289,7 +344,9 @@ struct pair
          >::type* = 0\
        )\
       : first(BOOST_MOVE_TMPL_GET##N), second(BOOST_MOVE_TMPL_GETQ##M)\
-   { (void)p; (void)q; }\
+   { (void)p; (void)q;\
+      BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+   }\
    //
    BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_PAIR_PIECEWISE_CONSTRUCT_BOOST_TUPLE_CODE)
    #undef BOOST_PAIR_PIECEWISE_CONSTRUCT_BOOST_TUPLE_CODE
@@ -309,7 +366,9 @@ struct pair
               , class = typename pair_impl::disable_if_boost_tuple< Tuple<Args1...> >::type>
       pair(piecewise_construct_t, Tuple<Args1...> t1, Tuple<Args2...> t2)
          : pair(t1, t2, typename build_number_seq<sizeof...(Args1)>::type(), typename build_number_seq<sizeof...(Args2)>::type())
-      {}
+      {
+         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      }
    #  else
       //piecewise construction from variadic tuple (suboptimal, without delegating constructors)
       private:
@@ -327,7 +386,9 @@ struct pair
       pair(piecewise_construct_t, Tuple<Args1...> t1, Tuple<Args2...> t2)
          : first  (build_from_args<first_type> (::boost::move(t1)))
          , second (build_from_args<second_type>(::boost::move(t2)))
-      {}
+      {
+         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));
+      }
    #  endif   //BOOST_NO_CXX11_VARIADIC_TEMPLATES
    #elif defined(BOOST_MSVC) && (_CPPLIB_VER == 520)
       //MSVC 2010 tuple implementation
@@ -338,7 +399,9 @@ struct pair
           , 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)\
          : first(BOOST_MOVE_GET_IDX##N), second(BOOST_MOVE_GET_IDXQ##M)\
-      { (void)p; (void)q; }\
+      { (void)p; (void)q;\
+         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+      }\
       //
       BOOST_MOVE_ITER2D_0TOMAX(9, BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2010_TUPLE_CODE)
       #undef BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2010_TUPLE_CODE
@@ -357,7 +420,9 @@ struct pair
           , 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\
           , StdTuple<BOOST_MOVE_TARGQ##M BOOST_MOVE_I##M BOOST_MOVE_REPEAT(BOOST_MOVE_SUB(BOOST_MOVE_ADD(_VARIADIC_MAX, 3),M),::std::_Nil) > q)\
          : first(BOOST_MOVE_GET_IDX##N), second(BOOST_MOVE_GET_IDXQ##M)\
-      { (void)p; (void)q; }\
+      { (void)p; (void)q;\
+         BOOST_STATIC_ASSERT((sizeof(std::pair<T1, T2>) == sizeof(pair<T1, T2>)));\
+      }\
       //
       BOOST_MOVE_ITER2D_0TOMAX(BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_MAX_IT, BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2012_TUPLE_CODE)
       #undef BOOST_PAIR_PIECEWISE_CONSTRUCT_MSVC2010_TUPLE_CODE

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

@@ -104,7 +104,7 @@ namespace container {
 namespace dtl {
 
 #ifdef BOOST_PLAT_WINDOWS_UWP
-extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSectionEx(::_RTL_CRITICAL_SECTION *, unsigned long, unsigned long);
+extern "C" __declspec(dllimport) int __stdcall InitializeCriticalSectionEx(::_RTL_CRITICAL_SECTION *, unsigned long, unsigned long);
 #else
 extern "C" __declspec(dllimport) void __stdcall InitializeCriticalSection(::_RTL_CRITICAL_SECTION *);
 #endif
@@ -142,25 +142,25 @@ class thread_mutex
    thread_mutex()
    {
       #ifdef BOOST_PLAT_WINDOWS_UWP
-      InitializeCriticalSectionEx(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect), 4000, 0);
+      (InitializeCriticalSectionEx)(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect), 4000, 0);
       #else
-      InitializeCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+      (InitializeCriticalSection)(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
       #endif
    }
 
    void lock()
    {
-      EnterCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+      (EnterCriticalSection)(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
    }
 
    void unlock()
    {
-      LeaveCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+      (LeaveCriticalSection)(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
    }
 
    ~thread_mutex()
    {
-      DeleteCriticalSection(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
+      (DeleteCriticalSection)(reinterpret_cast< ::_RTL_CRITICAL_SECTION* >(&m_crit_sect));
    }
   
    private:

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

@@ -484,32 +484,65 @@ struct get_tree_opt<void>
    typedef tree_assoc_defaults type;
 };
 
+template<class, class KeyOfValue>
+struct real_key_of_value
+{
+   typedef KeyOfValue type;
+};
+
+template<class T>
+struct real_key_of_value<T, void>
+{
+   typedef dtl::identity<T> type;
+};
+
+template<class T1, class T2>
+struct real_key_of_value<std::pair<T1, T2>, int>
+{
+   typedef dtl::select1st<T1> type;
+};
+
+template<class T1, class T2>
+struct real_key_of_value<boost::container::pair<T1, T2>, int>
+{
+   typedef dtl::select1st<T1> type;
+};
+
 template <class T, class KeyOfValue, class Compare, class Allocator, class Options>
 class tree
    : public dtl::node_alloc_holder
-      < Allocator
+      < typename real_allocator<T, Allocator>::type
       , typename dtl::intrusive_tree_type
-         < Allocator, tree_value_compare
-            <typename allocator_traits<Allocator>::pointer, Compare, KeyOfValue>
+         < typename real_allocator<T, Allocator>::type
+         , tree_value_compare
+            <typename allocator_traits<typename real_allocator<T, Allocator>::type>::pointer, Compare, typename real_key_of_value<T, KeyOfValue>::type>
          , get_tree_opt<Options>::type::tree_type
          , get_tree_opt<Options>::type::optimize_size
          >::type
       >
 {
+   typedef tree < T, KeyOfValue
+                , Compare, Allocator, Options>              ThisType;
+   public:
+   typedef typename real_allocator<T, Allocator>::type      allocator_type;
+
+   private:
+   typedef allocator_traits<allocator_type>                 allocator_traits_t;
+   typedef typename real_key_of_value<T, KeyOfValue>::type  key_of_value_t;
    typedef tree_value_compare
-      < typename allocator_traits<Allocator>::pointer
-      , Compare, KeyOfValue>                                ValComp;
+      < typename allocator_traits_t::pointer
+      , Compare
+      , key_of_value_t>                                     ValComp;
    typedef typename get_tree_opt<Options>::type             options_type;
    typedef typename dtl::intrusive_tree_type
-         < Allocator, ValComp
+         < allocator_type, ValComp
          , options_type::tree_type
          , options_type::optimize_size
          >::type                                            Icont;
    typedef dtl::node_alloc_holder
-      <Allocator, Icont>                                    AllocHolder;
+      <allocator_type, Icont>                               AllocHolder;
    typedef typename AllocHolder::NodePtr                    NodePtr;
-   typedef tree < T, KeyOfValue
-                , Compare, Allocator, Options>              ThisType;
+
    typedef typename AllocHolder::NodeAlloc                  NodeAlloc;
    typedef boost::container::
       allocator_traits<NodeAlloc>                           allocator_traits_type;
@@ -525,41 +558,40 @@ class tree
 
    public:
 
-   typedef typename KeyOfValue::type                  key_type;
-   typedef T                                          value_type;
-   typedef Allocator                                  allocator_type;
-   typedef Compare                                    key_compare;
-   typedef ValComp                                    value_compare;
+   typedef typename key_of_value_t::type                    key_type;
+   typedef T                                                value_type;
+   typedef Compare                                          key_compare;
+   typedef ValComp                                          value_compare;
    typedef typename boost::container::
-      allocator_traits<Allocator>::pointer            pointer;
+      allocator_traits<allocator_type>::pointer             pointer;
    typedef typename boost::container::
-      allocator_traits<Allocator>::const_pointer      const_pointer;
+      allocator_traits<allocator_type>::const_pointer       const_pointer;
    typedef typename boost::container::
-      allocator_traits<Allocator>::reference          reference;
+      allocator_traits<allocator_type>::reference           reference;
    typedef typename boost::container::
-      allocator_traits<Allocator>::const_reference    const_reference;
+      allocator_traits<allocator_type>::const_reference     const_reference;
    typedef typename boost::container::
-      allocator_traits<Allocator>::size_type          size_type;
+      allocator_traits<allocator_type>::size_type           size_type;
    typedef typename boost::container::
-      allocator_traits<Allocator>::difference_type    difference_type;
+      allocator_traits<allocator_type>::difference_type     difference_type;
    typedef dtl::iterator_from_iiterator
-      <iiterator, false>                              iterator;
+      <iiterator, false>                                    iterator;
    typedef dtl::iterator_from_iiterator
-      <iiterator, true >                              const_iterator;
+      <iiterator, true >                                    const_iterator;
    typedef boost::container::reverse_iterator
-      <iterator>                                      reverse_iterator;
+      <iterator>                                            reverse_iterator;
    typedef boost::container::reverse_iterator
-      <const_iterator>                                const_reverse_iterator;
+      <const_iterator>                                      const_reverse_iterator;
    typedef node_handle
-      < NodeAlloc, void>                              node_type;
+      < NodeAlloc, void>                                    node_type;
    typedef insert_return_type_base
-      <iterator, node_type>                           insert_return_type;
+      <iterator, node_type>                                 insert_return_type;
 
-   typedef NodeAlloc                                  stored_allocator_type;
+   typedef NodeAlloc                                        stored_allocator_type;
 
    private:
 
-   typedef key_node_compare<key_compare, KeyOfValue>  KeyNodeCompare;
+   typedef key_node_compare<key_compare, key_of_value_t>  KeyNodeCompare;
 
    public:
 
@@ -756,7 +788,7 @@ class tree
 
    tree& operator=(BOOST_COPY_ASSIGN_REF(tree) x)
    {
-      if (&x != this){
+      if (BOOST_LIKELY(this != &x)) {
          NodeAlloc &this_alloc     = this->get_stored_allocator();
          const NodeAlloc &x_alloc  = x.get_stored_allocator();
          dtl::bool_<allocator_traits<NodeAlloc>::
@@ -790,39 +822,40 @@ class tree
                           allocator_traits_type::is_always_equal::value) &&
                            boost::container::dtl::is_nothrow_move_assignable<Compare>::value)
    {
-      BOOST_ASSERT(this != &x);
-      NodeAlloc &this_alloc = this->node_alloc();
-      NodeAlloc &x_alloc    = x.node_alloc();
-      const bool propagate_alloc = allocator_traits<NodeAlloc>::
-            propagate_on_container_move_assignment::value;
-      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)
-      if(propagate_alloc || allocators_equal){
-         //Destroy
-         this->clear();
-         //Move allocator if needed
-         this->AllocHolder::move_assign_alloc(x);
-         //Obtain resources
-         this->icont() = boost::move(x.icont());
-      }
-      //Else do a one by one move
-      else{
-         //Transfer all the nodes to a temporary tree
-         //If anything goes wrong, all the nodes will be destroyed
-         //automatically
-         Icont other_tree(::boost::move(this->icont()));
-
-         //Now recreate the source tree reusing nodes stored by other_tree
-         this->icont().clone_from
-            (::boost::move(x.icont())
-            , RecyclingCloner<AllocHolder, true>(*this, other_tree)
-            , Destroyer(this->node_alloc()));
-
-         //If there are remaining nodes, destroy them
-         NodePtr p;
-         while((p = other_tree.unlink_leftmost_without_rebalance())){
-            AllocHolder::destroy_node(p);
+      if (BOOST_LIKELY(this != &x)) {
+         NodeAlloc &this_alloc = this->node_alloc();
+         NodeAlloc &x_alloc    = x.node_alloc();
+         const bool propagate_alloc = allocator_traits<NodeAlloc>::
+               propagate_on_container_move_assignment::value;
+         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)
+         if(propagate_alloc || allocators_equal){
+            //Destroy
+            this->clear();
+            //Move allocator if needed
+            this->AllocHolder::move_assign_alloc(x);
+            //Obtain resources
+            this->icont() = boost::move(x.icont());
+         }
+         //Else do a one by one move
+         else{
+            //Transfer all the nodes to a temporary tree
+            //If anything goes wrong, all the nodes will be destroyed
+            //automatically
+            Icont other_tree(::boost::move(this->icont()));
+
+            //Now recreate the source tree reusing nodes stored by other_tree
+            this->icont().clone_from
+               (::boost::move(x.icont())
+               , RecyclingCloner<AllocHolder, true>(*this, other_tree)
+               , Destroyer(this->node_alloc()));
+
+            //If there are remaining nodes, destroy them
+            NodePtr p;
+            while((p = other_tree.unlink_leftmost_without_rebalance())){
+               AllocHolder::destroy_node(p);
+            }
          }
       }
       return *this;
@@ -955,7 +988,7 @@ class tree
    {
       insert_commit_data data;
       std::pair<iterator,bool> ret =
-         this->insert_unique_check(KeyOfValue()(v), data);
+         this->insert_unique_check(key_of_value_t()(v), data);
       if(ret.second){
          ret.first = this->insert_unique_commit(boost::forward<MovableConvertible>(v), data);
       }
@@ -998,7 +1031,7 @@ class tree
       insert_commit_data data;
       scoped_destroy_deallocator<NodeAlloc> destroy_deallocator(p, this->node_alloc());
       std::pair<iterator,bool> ret =
-         this->insert_unique_check(KeyOfValue()(v), data);
+         this->insert_unique_check(key_of_value_t()(v), data);
       if(!ret.second){
          return ret;
       }
@@ -1015,7 +1048,7 @@ class tree
       value_type &v = p->get_data();
       insert_commit_data data;
       std::pair<iterator,bool> ret =
-         this->insert_unique_check(hint, KeyOfValue()(v), data);
+         this->insert_unique_check(hint, key_of_value_t()(v), data);
       if(!ret.second){
          Destroyer(this->node_alloc())(p);
          return ret.first;
@@ -1131,7 +1164,7 @@ class tree
       BOOST_ASSERT((priv_is_linked)(hint));
       insert_commit_data data;
       std::pair<iterator,bool> ret =
-         this->insert_unique_check(hint, KeyOfValue()(v), data);
+         this->insert_unique_check(hint, key_of_value_t()(v), data);
       if(!ret.second)
          return ret.first;
       return this->insert_unique_commit(boost::forward<MovableConvertible>(v), data);
@@ -1246,7 +1279,7 @@ class tree
       if(!nh.empty()){
          insert_commit_data data;
          std::pair<iterator,bool> ret =
-            this->insert_unique_check(hint, KeyOfValue()(nh.value()), data);
+            this->insert_unique_check(hint, key_of_value_t()(nh.value()), data);
          if(ret.second){
             irt.inserted = true;
             irt.position = iterator(this->icont().insert_unique_commit(*nh.get(), data));
@@ -1483,8 +1516,9 @@ struct has_trivial_destructor_after_move
          <T, KeyOfValue, Compare, Allocator, Options>
    >
 {
-   typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer;
-   static const bool value = ::boost::has_trivial_destructor_after_move<Allocator>::value &&
+   typedef typename ::boost::container::dtl::tree<T, KeyOfValue, Compare, Allocator, Options>::allocator_type allocator_type;
+   typedef typename ::boost::container::allocator_traits<allocator_type>::pointer pointer;
+   static const bool value = ::boost::has_trivial_destructor_after_move<allocator_type>::value &&
                              ::boost::has_trivial_destructor_after_move<pointer>::value &&
                              ::boost::has_trivial_destructor_after_move<Compare>::value;
 };