passenger 6.0.14 → 6.0.27

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

@@ -31,11 +31,14 @@
 #include <boost/container/detail/construct_in_place.hpp>
 #include <boost/container/detail/destroyers.hpp>
 #include <boost/move/detail/iterator_to_raw_pointer.hpp>
+#include <boost/move/detail/launder.hpp>
 #include <boost/container/detail/mpl.hpp>
 #include <boost/container/detail/placement_new.hpp>
 #include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/version_type.hpp>
+#include <boost/container/detail/is_pair.hpp>
+#include <boost/container/detail/pair.hpp>
 // intrusive
 #include <boost/intrusive/detail/mpl.hpp>
 #include <boost/intrusive/options.hpp>
@@ -44,18 +47,152 @@
 #if defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
-// other
-#include <boost/core/no_exceptions_support.hpp>
 
 
 namespace boost {
 namespace container {
+
+//This trait is used to type-pun std::pair because in C++03
+//compilers std::pair is useless for C++11 features
+template<class T, bool>
+struct node_internal_data_type
+{
+   typedef T type;
+};
+
+template<class T>
+struct node_internal_data_type< T, true>
+{
+   typedef dtl::pair< typename dtl::remove_const<typename T::first_type>::type
+                     , typename T::second_type>
+                     type;
+};
+
+template <class T, class HookDefiner, bool PairBased = false>
+struct base_node
+   :  public HookDefiner::type
+{
+   public:
+   typedef T value_type;
+   typedef typename node_internal_data_type<T, PairBased && dtl::is_pair<T>::value>::type internal_type;
+   typedef typename HookDefiner::type hook_type;
+
+   typedef typename dtl::aligned_storage<sizeof(T), dtl::alignment_of<T>::value>::type storage_t;
+   storage_t m_storage;
+
+   #if defined(BOOST_GCC) && (BOOST_GCC >= 40600) && (BOOST_GCC < 80000)
+      #pragma GCC diagnostic push
+      #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+      #define BOOST_CONTAINER_DISABLE_ALIASING_WARNING
+   #  endif
+   public:
+
+   #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+   template<class Alloc, class ...Args>
+   explicit base_node(Alloc &a, Args &&...args)
+      : hook_type()
+   {
+      ::boost::container::allocator_traits<Alloc>::construct
+         (a, &this->get_real_data(), ::boost::forward<Args>(args)...);
+   }
+
+   #else //defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+   #define BOOST_CONTAINER_BASE_NODE_CONSTRUCT_IMPL(N) \
+   template< class Alloc BOOST_MOVE_I##N BOOST_MOVE_CLASS##N > \
+   explicit base_node(Alloc &a BOOST_MOVE_I##N BOOST_MOVE_UREF##N)\
+      : hook_type()\
+   {\
+      ::boost::container::allocator_traits<Alloc>::construct\
+         (a, &this->get_real_data() BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+   }\
+   //
+   BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_BASE_NODE_CONSTRUCT_IMPL)
+   #undef BOOST_CONTAINER_BASE_NODE_CONSTRUCT_IMPL
+
+   #endif   // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
+
+   template<class Alloc, class It>
+   explicit base_node(iterator_arg_t, Alloc &a, It it)
+      : hook_type()
+   {
+      ::boost::container::construct_in_place(a, &this->get_real_data(), it);
+   }
+
+   inline T &get_data()
+   {  return *move_detail::force_ptr<T*>(&this->m_storage);   }
+
+   inline const T &get_data() const
+   {  return *move_detail::launder_cast<const T*>(&this->m_storage);  }
+
+   inline internal_type &get_real_data()
+   {  return *move_detail::launder_cast<internal_type*>(&this->m_storage);   }
+
+   inline const internal_type &get_real_data() const
+   {  return *move_detail::launder_cast<const internal_type*>(&this->m_storage);  }
+
+   #if defined(BOOST_CONTAINER_DISABLE_ALIASING_WARNING)
+      #pragma GCC diagnostic pop
+      #undef BOOST_CONTAINER_DISABLE_ALIASING_WARNING
+   #  endif
+
+   template<class Alloc>
+   inline void destructor(Alloc &a) BOOST_NOEXCEPT
+   {
+      allocator_traits<Alloc>::destroy
+         (a, &this->get_real_data());
+      this->~base_node();
+   }
+
+   template<class Pair>
+   inline
+   typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
+      do_assign(const Pair &p)
+   {
+      typedef typename Pair::first_type first_type;
+      const_cast<typename dtl::remove_const<first_type>::type &>(this->get_real_data().first) = p.first;
+      this->get_real_data().second  = p.second;
+   }
+
+   template<class V>
+   inline 
+   typename dtl::disable_if< dtl::is_pair<V>, void >::type
+      do_assign(const V &v)
+   {  this->get_real_data() = v; }
+
+   template<class Pair>
+   inline 
+   typename dtl::enable_if< dtl::is_pair<Pair>, void >::type
+      do_move_assign(Pair &p)
+   {
+      typedef typename Pair::first_type first_type;
+      const_cast<first_type&>(this->get_real_data().first) = ::boost::move(p.first);
+      this->get_real_data().second = ::boost::move(p.second);
+   }
+
+   template<class V>
+   inline 
+   typename dtl::disable_if< dtl::is_pair<V>, void >::type
+      do_move_assign(V &v)
+   {  this->get_real_data() = ::boost::move(v); }
+
+   private:
+   base_node();
+
+   inline ~base_node()
+   { }
+};
+
+
 namespace dtl {
 
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(key_compare)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(key_equal)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(hasher)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(predicate_type)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(bucket_traits)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(bucket_type)
 
 template<class Allocator, class ICont>
 struct node_alloc_holder
@@ -66,13 +203,7 @@ struct node_alloc_holder
    //be of type node_compare<>. If not an associative container val_compare will be a "nat" type.
    typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
       ( boost::container::dtl::
-      , ICont, key_compare, dtl::nat)                 intrusive_val_compare;
-   //In that case obtain the value predicate from the node predicate via predicate_type
-   //if intrusive_val_compare is node_compare<>, nat otherwise
-   typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
-      ( boost::container::dtl::
-      , intrusive_val_compare
-      , predicate_type, dtl::nat)                    val_compare;
+      , ICont, key_compare, dtl::nat)                 intrusive_key_compare;
 
    //If the intrusive container is a hash container, obtain the predicate, which will
    //be of type node_compare<>. If not an associative container val_equal will be a "nat" type.
@@ -81,9 +212,15 @@ struct node_alloc_holder
          , ICont, key_equal, dtl::nat2)              intrusive_val_equal;
    typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
    (boost::container::dtl::
-      , ICont, hasher, dtl::nat3)                     intrusive_val_hasher;
+      , ICont, hasher, dtl::nat3)                    intrusive_val_hasher;
+   typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
+   (boost::container::dtl::
+      , ICont, bucket_traits, dtl::natN<0>)           intrusive_bucket_traits;
+   typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
+   (boost::container::dtl::
+      , ICont, bucket_type, dtl::natN<1>)            intrusive_bucket_type;
    //In that case obtain the value predicate from the node predicate via predicate_type
-   //if intrusive_val_compare is node_compare<>, nat otherwise
+   //if intrusive_key_compare is node_compare<>, nat otherwise
    typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
    (boost::container::dtl::
       , intrusive_val_equal
@@ -111,7 +248,7 @@ struct node_alloc_holder
          version<NodeAlloc>::value>                               alloc_version;
    typedef typename ICont::iterator                               icont_iterator;
    typedef typename ICont::const_iterator                         icont_citerator;
-   typedef allocator_destroyer<NodeAlloc>                         Destroyer;
+   typedef allocator_node_destroyer<NodeAlloc>                         Destroyer;
    typedef allocator_traits<NodeAlloc>                            NodeAllocTraits;
    typedef allocator_version_traits<NodeAlloc>                    AllocVersionTraits;
 
@@ -121,34 +258,43 @@ struct node_alloc_holder
    public:
 
    //Constructors for sequence containers
-   node_alloc_holder()
+   inline node_alloc_holder()
+   {}
+
+   explicit node_alloc_holder(const intrusive_bucket_traits& bt)
+      : m_icont(bt)
    {}
 
    explicit node_alloc_holder(const ValAlloc &a)
       : NodeAlloc(a)
    {}
 
+   node_alloc_holder(const intrusive_bucket_traits& bt, const ValAlloc& a)
+      : NodeAlloc(a)
+      , m_icont(bt)
+   {}
+
    //Constructors for associative containers
-   node_alloc_holder(const val_compare &c, const ValAlloc &a)
-      : NodeAlloc(a), m_icont(typename ICont::key_compare(c))
+   node_alloc_holder(const intrusive_key_compare &c, const ValAlloc &a)
+      : NodeAlloc(a), m_icont(c)
    {}
 
-   node_alloc_holder(const val_hasher &hf, const val_equal &eql, const ValAlloc &a)
+   node_alloc_holder(const intrusive_bucket_traits & bt, const val_hasher &hf, const val_equal &eql, const ValAlloc &a)
       : NodeAlloc(a)
-      , m_icont(typename ICont::bucket_traits()
+      , m_icont(bt
          , typename ICont::hasher(hf)
          , typename ICont::key_equal(eql))
    {}
 
-   node_alloc_holder(const val_hasher &hf, const ValAlloc &a)
+   node_alloc_holder(const intrusive_bucket_traits& bt, const val_hasher &hf, const ValAlloc &a)
       : NodeAlloc(a)
-      , m_icont(typename ICont::bucket_traits()
+      , m_icont(bt
          , typename ICont::hasher(hf)
          , typename ICont::key_equal())
    {}
 
-   node_alloc_holder(const val_hasher &hf)
-      : m_icont(typename ICont::bucket_traits()
+   node_alloc_holder(const intrusive_bucket_traits& bt, const val_hasher &hf)
+      : m_icont(bt
          , typename ICont::hasher(hf)
          , typename ICont::key_equal())
    {}
@@ -157,68 +303,68 @@ struct node_alloc_holder
       : NodeAlloc(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()))
    {}
 
-   node_alloc_holder(const node_alloc_holder &x, const val_compare &c)
+   node_alloc_holder(const node_alloc_holder &x, const intrusive_key_compare &c)
       : NodeAlloc(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()))
-      , m_icont(typename ICont::key_compare(c))
+      , m_icont(c)
    {}
 
-   node_alloc_holder(const node_alloc_holder &x, const val_hasher &hf, const val_equal &eql)
+   node_alloc_holder(const node_alloc_holder &x, const intrusive_bucket_traits& bt, const val_hasher &hf, const val_equal &eql)
       : NodeAlloc(NodeAllocTraits::select_on_container_copy_construction(x.node_alloc()))
-      , m_icont( typename ICont::bucket_traits()
+      , m_icont( bt
                , typename ICont::hasher(hf)
                , typename ICont::key_equal(eql))
    {}
 
-   node_alloc_holder(const val_hasher &hf, const val_equal &eql)
-      : m_icont(typename ICont::bucket_traits()
+   node_alloc_holder(const val_hasher &hf, const intrusive_bucket_traits& bt, const val_equal &eql)
+      : m_icont(bt
          , typename ICont::hasher(hf)
          , typename ICont::key_equal(eql))
    {}
 
    explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x)
-      : NodeAlloc(boost::move(x.node_alloc()))
+      : NodeAlloc(boost::move(BOOST_MOVE_TO_LV(x).node_alloc()))
    {  this->icont().swap(x.icont());  }
 
-   explicit node_alloc_holder(const val_compare &c)
-      : m_icont(typename ICont::key_compare(c))
+   explicit node_alloc_holder(const intrusive_key_compare &c)
+      : m_icont(c)
    {}
 
    //helpers for move assignments
-   explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x, const val_compare &c)
-      : NodeAlloc(boost::move(x.node_alloc())), m_icont(typename ICont::key_compare(c))
+   explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x, const intrusive_key_compare &c)
+      : NodeAlloc(boost::move(BOOST_MOVE_TO_LV(x).node_alloc())), m_icont(c)
    {  this->icont().swap(x.icont());  }
 
-   explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x, const val_hasher &hf, const val_equal &eql)
-      : NodeAlloc(boost::move(x.node_alloc()))
-      , m_icont( typename ICont::bucket_traits()
+   explicit node_alloc_holder(BOOST_RV_REF(node_alloc_holder) x, const intrusive_bucket_traits& bt, const val_hasher &hf, const val_equal &eql)
+      : NodeAlloc(boost::move(BOOST_MOVE_TO_LV(x).node_alloc()))
+      , m_icont( bt
                , typename ICont::hasher(hf)
                , typename ICont::key_equal(eql))
-   {  this->icont().swap(x.icont());   }
+   {  this->icont().swap(BOOST_MOVE_TO_LV(x).icont());   }
 
-   void copy_assign_alloc(const node_alloc_holder &x)
+   inline void copy_assign_alloc(const node_alloc_holder &x)
    {
       dtl::bool_<allocator_traits_type::propagate_on_container_copy_assignment::value> flag;
       dtl::assign_alloc( static_cast<NodeAlloc &>(*this)
                        , static_cast<const NodeAlloc &>(x), flag);
    }
 
-   void move_assign_alloc( node_alloc_holder &x)
+   inline void move_assign_alloc( node_alloc_holder &x)
    {
       dtl::bool_<allocator_traits_type::propagate_on_container_move_assignment::value> flag;
       dtl::move_alloc( static_cast<NodeAlloc &>(*this)
                      , static_cast<NodeAlloc &>(x), flag);
    }
 
-   ~node_alloc_holder()
+   inline ~node_alloc_holder()
    {  this->clear(alloc_version()); }
 
-   size_type max_size() const
+   inline size_type max_size() const
    {  return allocator_traits_type::max_size(this->node_alloc());  }
 
-   NodePtr allocate_one()
+   inline NodePtr allocate_one()
    {  return AllocVersionTraits::allocate_one(this->node_alloc());   }
 
-   void deallocate_one(const NodePtr &p)
+   inline void deallocate_one(const NodePtr &p)
    {  AllocVersionTraits::deallocate_one(this->node_alloc(), p);  }
 
    #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
@@ -227,18 +373,11 @@ struct node_alloc_holder
    NodePtr create_node(Args &&...args)
    {
       NodePtr p = this->allocate_one();
-      BOOST_TRY{
-         ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) Node;
-         allocator_traits<NodeAlloc>::construct
-            (this->node_alloc()
-            , p->get_real_data_ptr(), boost::forward<Args>(args)...);
-      }
-      BOOST_CATCH(...) {
-         p->destroy_header();
-         this->node_alloc().deallocate(p, 1);
-         BOOST_RETHROW
-      }
-      BOOST_CATCH_END
+      NodeAlloc &nalloc = this->node_alloc();
+      Deallocator node_deallocator(p, nalloc);
+      ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t())
+         Node(nalloc, boost::forward<Args>(args)...);
+      node_deallocator.release();
       return (p);
    }
 
@@ -249,19 +388,11 @@ struct node_alloc_holder
    NodePtr create_node(BOOST_MOVE_UREF##N)\
    {\
       NodePtr p = this->allocate_one();\
-      BOOST_TRY{\
-         ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) Node;\
-         allocator_traits<NodeAlloc>::construct\
-            ( this->node_alloc()\
-            , p->get_real_data_ptr()\
-             BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      }\
-      BOOST_CATCH(...) {\
-         p->destroy_header();\
-         this->node_alloc().deallocate(p, 1);\
-         BOOST_RETHROW\
-      }\
-      BOOST_CATCH_END\
+      NodeAlloc &nalloc = this->node_alloc();\
+      Deallocator node_deallocator(p, nalloc);\
+      ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t())\
+         Node(nalloc BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      node_deallocator.release();\
       return (p);\
    }\
    //
@@ -274,16 +405,11 @@ struct node_alloc_holder
    NodePtr create_node_from_it(const It &it)
    {
       NodePtr p = this->allocate_one();
-      BOOST_TRY{
-         ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) Node;
-         ::boost::container::construct_in_place(this->node_alloc(), p->get_real_data_ptr(), it);
-      }
-      BOOST_CATCH(...) {
-         p->destroy_header();
-         this->node_alloc().deallocate(p, 1);
-         BOOST_RETHROW
-      }
-      BOOST_CATCH_END
+      NodeAlloc &nalloc = this->node_alloc();
+      Deallocator node_deallocator(p, nalloc);
+      ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t())
+         Node(iterator_arg_t(), nalloc, it);
+      node_deallocator.release();
       return (p);
    }
 
@@ -291,32 +417,32 @@ struct node_alloc_holder
    NodePtr create_node_from_key(BOOST_FWD_REF(KeyConvertible) key)
    {
       NodePtr p = this->allocate_one();
-      BOOST_TRY{
+      BOOST_CONTAINER_TRY{
          ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t()) Node;
          NodeAlloc &na = this->node_alloc();
          node_allocator_traits_type::construct
             (na, dtl::addressof(p->get_real_data().first), boost::forward<KeyConvertible>(key));
-         BOOST_TRY{
+         BOOST_CONTAINER_TRY{
             node_allocator_traits_type::construct(na, dtl::addressof(p->get_real_data().second));
          }
-         BOOST_CATCH(...){
+         BOOST_CONTAINER_CATCH(...){
             node_allocator_traits_type::destroy(na, dtl::addressof(p->get_real_data().first));
-            BOOST_RETHROW;
+            BOOST_CONTAINER_RETHROW;
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
-      BOOST_CATCH(...) {
+      BOOST_CONTAINER_CATCH(...) {
          p->destroy_header();
          this->node_alloc().deallocate(p, 1);
-         BOOST_RETHROW
+         BOOST_CONTAINER_RETHROW
       }
-      BOOST_CATCH_END
+      BOOST_CONTAINER_CATCH_END
       return (p);
    }
 
    void destroy_node(const NodePtr &nodep)
    {
-      allocator_traits<NodeAlloc>::destroy(this->node_alloc(), boost::movelib::to_raw_pointer(nodep));
+      boost::movelib::to_raw_pointer(nodep)->destructor(this->node_alloc());
       this->deallocate_one(nodep);
    }
 
@@ -329,7 +455,7 @@ struct node_alloc_holder
 
    template<class FwdIterator, class Inserter>
    void allocate_many_and_construct
-      (FwdIterator beg, difference_type n, Inserter inserter)
+      (FwdIterator beg, size_type n, Inserter inserter)
    {
       if(n){
          typedef typename node_allocator_version_traits_type::multiallocation_chain multiallocation_chain_t;
@@ -344,47 +470,44 @@ struct node_alloc_holder
          chain.clear();
 
          Node *p = 0;
-            BOOST_TRY{
+            BOOST_CONTAINER_TRY{
             Deallocator node_deallocator(NodePtr(), nalloc);
-            dtl::scoped_destructor<NodeAlloc> sdestructor(nalloc, 0);
+            dtl::scoped_node_destructor<NodeAlloc> sdestructor(nalloc, 0);
             while(n){
                --n;
                p = boost::movelib::iterator_to_raw_pointer(itbeg);
                ++itbeg; //Increment iterator before overwriting pointed memory
                //This does not throw
-               p = ::new(p, boost_container_new_t()) Node;
-               node_deallocator.set(p);
-               //This can throw
-               boost::container::construct_in_place(nalloc, p->get_real_data_ptr(), beg);
+               ::new(boost::movelib::iterator_to_raw_pointer(p), boost_container_new_t())
+                  Node(iterator_arg_t(), nalloc, beg);
                sdestructor.set(p);
                ++beg;
                //This can throw in some containers (predicate might throw).
                //(sdestructor will destruct the node and node_deallocator will deallocate it in case of exception)
                inserter(*p);
-               sdestructor.set(0);
+               sdestructor.release();
             }
             sdestructor.release();
             node_deallocator.release();
          }
-         BOOST_CATCH(...){
-            p->destroy_header();
+         BOOST_CONTAINER_CATCH(...){
             chain.incorporate_after(chain.last(), &*itbeg, &*itlast, n);
             node_allocator_version_traits_type::deallocate_individual(this->node_alloc(), chain);
-            BOOST_RETHROW
+            BOOST_CONTAINER_RETHROW
          }
-         BOOST_CATCH_END
+         BOOST_CONTAINER_CATCH_END
       }
    }
 
-   void clear(version_1)
+   inline void clear(version_1)
    {  this->icont().clear_and_dispose(Destroyer(this->node_alloc()));   }
 
    void clear(version_2)
    {
       typename NodeAlloc::multiallocation_chain chain;
-      allocator_destroyer_and_chain_builder<NodeAlloc> builder(this->node_alloc(), chain);
+      allocator_node_destroyer_and_chain_builder<NodeAlloc> builder(this->node_alloc(), chain);
       this->icont().clear_and_dispose(builder);
-      //BOOST_STATIC_ASSERT((::boost::has_move_emulation_enabled<typename NodeAlloc::multiallocation_chain>::value == true));
+      //BOOST_CONTAINER_STATIC_ASSERT((::boost::has_move_emulation_enabled<typename NodeAlloc::multiallocation_chain>::value == true));
       if(!chain.empty())
          this->node_alloc().deallocate_individual(chain);
    }
@@ -394,34 +517,46 @@ struct node_alloc_holder
 
    icont_iterator erase_range(const icont_iterator &first, const icont_iterator &last, version_2)
    {
-      typedef typename NodeAlloc::multiallocation_chain multiallocation_chain;
       NodeAlloc & nalloc = this->node_alloc();
-      multiallocation_chain chain;
-      allocator_destroyer_and_chain_builder<NodeAlloc> chain_builder(nalloc, chain);
+      typename NodeAlloc::multiallocation_chain chain;
+      allocator_node_destroyer_and_chain_builder<NodeAlloc> chain_builder(nalloc, chain);
       icont_iterator ret_it = this->icont().erase_and_dispose(first, last, chain_builder);
       nalloc.deallocate_individual(chain);
       return ret_it;
    }
 
-   template<class Key, class Comparator>
-   size_type erase_key(const Key& k, const Comparator &comp, version_1)
-   {  return this->icont().erase_and_dispose(k, comp, Destroyer(this->node_alloc())); }
+   template<class Key>
+   inline size_type erase_key(const Key& k, version_1)
+   {  return this->icont().erase_and_dispose(k, Destroyer(this->node_alloc())); }
 
-   template<class Key, class Comparator>
-   size_type erase_key(const Key& k, const Comparator &comp, version_2)
+   template<class Key>
+   inline size_type erase_key(const Key& k, version_2)
    {
       allocator_multialloc_chain_node_deallocator<NodeAlloc> chain_holder(this->node_alloc());
-      return this->icont().erase_and_dispose(k, comp, chain_holder.get_chain_builder());
+      return this->icont().erase_and_dispose(k, chain_holder.get_chain_builder());
+   }
+
+   template<class Key, class KeyCompare>
+   inline size_type erase_key(const Key& k, KeyCompare cmp, version_1)
+   {
+      return this->icont().erase_and_dispose(k, cmp, Destroyer(this->node_alloc()));
+   }
+
+   template<class Key, class KeyCompare>
+   inline size_type erase_key(const Key& k, KeyCompare cmp, version_2)
+   {
+      allocator_multialloc_chain_node_deallocator<NodeAlloc> chain_holder(this->node_alloc());
+      return this->icont().erase_and_dispose(k, cmp, chain_holder.get_chain_builder());
    }
 
    protected:
    struct cloner
    {
-      explicit cloner(node_alloc_holder &holder)
+      inline explicit cloner(node_alloc_holder &holder)
          :  m_holder(holder)
       {}
 
-      NodePtr operator()(const Node &other) const
+      inline NodePtr operator()(const Node &other) const
       {  return m_holder.create_node(other.get_real_data());  }
 
       node_alloc_holder &m_holder;
@@ -429,11 +564,11 @@ struct node_alloc_holder
 
    struct move_cloner
    {
-      move_cloner(node_alloc_holder &holder)
+      inline move_cloner(node_alloc_holder &holder)
          :  m_holder(holder)
       {}
 
-      NodePtr operator()(Node &other)
+      inline NodePtr operator()(Node &other)
       {  //Use get_real_data() instead of get_real_data to allow moving const key in [multi]map
          return m_holder.create_node(::boost::move(other.get_real_data()));
       }
@@ -441,27 +576,40 @@ struct node_alloc_holder
       node_alloc_holder &m_holder;
    };
 
-   ICont &non_const_icont() const
+   inline ICont &non_const_icont() const
    {  return const_cast<ICont&>(this->m_icont);   }
 
-   NodeAlloc &node_alloc()
+   inline NodeAlloc &node_alloc()
    {  return static_cast<NodeAlloc &>(*this);   }
 
-   const NodeAlloc &node_alloc() const
+   inline const NodeAlloc &node_alloc() const
    {  return static_cast<const NodeAlloc &>(*this);   }
 
    public:
-   ICont &icont()
+   inline ICont &icont()
    {  return this->m_icont;   }
 
-   const ICont &icont() const
+   inline const ICont &icont() const
    {  return this->m_icont;   }
 
-   private:
+   protected:
    //The intrusive container
    ICont m_icont;
 };
 
+template<class Node, class KeyOfValue>
+struct key_of_node : KeyOfValue
+{
+   typedef typename KeyOfValue::type type;
+
+   inline key_of_node()
+   {}
+
+   inline const type& operator()(const Node& x) const
+   {  return this->KeyOfValue::operator()(x.get_data());  }
+};
+
+
 }  //namespace dtl {
 }  //namespace container {
 }  //namespace boost {

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

@@ -52,7 +52,7 @@ class private_node_pool
 
    public:
    typedef typename base_t::multiallocation_chain multiallocation_chain;
-   static const std::size_t nodes_per_block = NodesPerBlock;
+   BOOST_STATIC_CONSTEXPR std::size_t nodes_per_block = NodesPerBlock;
 
    //!Constructor from a segment manager. Never throws
    private_node_pool()