passenger 6.0.22 → 6.0.24

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

@@ -26,7 +26,6 @@
 
 #include <boost/move/utility_core.hpp>
 
-#include <boost/container/detail/pair.hpp>
 #include <boost/container/vector.hpp>
 #include <boost/container/allocator_traits.hpp>
 
@@ -43,11 +42,11 @@
 
 #include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
 
-#include <boost/move/make_unique.hpp>
 #include <boost/move/iterator.hpp>
 #include <boost/move/adl_move_swap.hpp>
 #include <boost/move/detail/iterator_to_raw_pointer.hpp>
 #include <boost/move/detail/force_ptr.hpp>
+#include <boost/move/detail/launder.hpp>
 #include <boost/move/algo/adaptive_sort.hpp>
 #include <boost/move/algo/detail/pdqsort.hpp>
 
@@ -583,7 +582,7 @@ class flat_tree
       (boost::container::dtl::, container_type
       ,stored_allocator_type, allocator_type)               stored_allocator_type;
 
-   static const bool has_stored_allocator_type =
+   BOOST_STATIC_CONSTEXPR bool has_stored_allocator_type =
       BOOST_INTRUSIVE_HAS_TYPE(boost::container::dtl::, container_type, stored_allocator_type);
 
    private:
@@ -955,6 +954,7 @@ class flat_tree
    template <class InIt>
    void insert_equal(ordered_range_t, InIt first, InIt last)
    {
+      BOOST_ASSERT((is_sorted)(first, last, this->priv_value_comp()));
       const bool value = boost::container::dtl::
          has_member_function_callable_with_merge_unique<container_type, InIt, InIt, value_compare>::value;
       (flat_tree_merge_equal)(this->m_data.m_seq, first, last, this->priv_value_comp(), dtl::bool_<value>());
@@ -963,6 +963,7 @@ class flat_tree
    template <class InIt>
    void insert_unique(ordered_unique_range_t, InIt first, InIt last)
    {
+      BOOST_ASSERT((is_sorted_and_unique)(this->m_data.m_seq.cbegin(), this->m_data.m_seq.cend(), this->priv_value_comp()));
       const bool value = boost::container::dtl::
          has_member_function_callable_with_merge_unique<container_type, InIt, InIt, value_compare>::value;
       (flat_tree_merge_unique)(this->m_data.m_seq, first, last, this->priv_value_comp(), dtl::bool_<value>());
@@ -975,8 +976,8 @@ class flat_tree
    {
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
-      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(args)... );
-      value_type *pval = move_detail::force_ptr<value_type *>(&v);
+      stored_allocator_traits::construct(a, (value_type *)(&v), ::boost::forward<Args>(args)... );
+      value_type *pval = move_detail::launder_cast<value_type *>(&v);
       value_destructor<stored_allocator_type, value_type> d(a, *pval);
       return this->insert_unique(::boost::move(*pval));
    }
@@ -987,8 +988,8 @@ class flat_tree
       //hint checked in insert_unique
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
-      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(args)... );
-      value_type *pval = move_detail::force_ptr<value_type *>(&v);
+      stored_allocator_traits::construct(a, (value_type*)(&v), ::boost::forward<Args>(args)... );
+      value_type *pval = move_detail::launder_cast<value_type *>(&v);
       value_destructor<stored_allocator_type, value_type> d(a, *pval);
       return this->insert_unique(hint, ::boost::move(*pval));
    }
@@ -998,8 +999,8 @@ class flat_tree
    {
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
-      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(args)... );
-      value_type *pval = move_detail::force_ptr<value_type *>(&v);
+      stored_allocator_traits::construct(a, (value_type*)(&v), ::boost::forward<Args>(args)... );
+      value_type *pval = move_detail::launder_cast<value_type *>(&v);
       value_destructor<stored_allocator_type, value_type> d(a, *pval);
       return this->insert_equal(::boost::move(*pval));
    }
@@ -1010,8 +1011,8 @@ class flat_tree
       //hint checked in insert_equal
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();
-      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v), ::boost::forward<Args>(args)... );
-      value_type *pval = move_detail::force_ptr<value_type *>(&v);
+      stored_allocator_traits::construct(a, (value_type*)(&v), ::boost::forward<Args>(args)... );
+      value_type *pval = move_detail::launder_cast<value_type *>(&v);
       value_destructor<stored_allocator_type, value_type> d(a, *pval);
       return this->insert_equal(hint, ::boost::move(*pval));
    }
@@ -1044,8 +1045,8 @@ class flat_tree
    {\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
-      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_type *pval = move_detail::force_ptr<value_type *>(&v);\
+      stored_allocator_traits::construct(a, (value_type *)(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_type *pval = move_detail::launder_cast<value_type *>(&v);\
       value_destructor<stored_allocator_type, value_type> d(a, *pval);\
       return this->insert_unique(::boost::move(*pval));\
    }\
@@ -1055,8 +1056,8 @@ class flat_tree
    {\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
-      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_type *pval = move_detail::force_ptr<value_type *>(&v);\
+      stored_allocator_traits::construct(a, (value_type *)(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_type *pval = move_detail::launder_cast<value_type *>(&v);\
       value_destructor<stored_allocator_type, value_type> d(a, *pval);\
       return this->insert_unique(hint, ::boost::move(*pval));\
    }\
@@ -1066,8 +1067,8 @@ class flat_tree
    {\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
-      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_type *pval = move_detail::force_ptr<value_type *>(&v);\
+      stored_allocator_traits::construct(a, (value_type *)(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_type *pval = move_detail::launder_cast<value_type *>(&v);\
       value_destructor<stored_allocator_type, value_type> d(a, *pval);\
       return this->insert_equal(::boost::move(*pval));\
    }\
@@ -1077,8 +1078,8 @@ class flat_tree
    {\
       typename dtl::aligned_storage <sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\
       get_stored_allocator_noconst_return_t a = this->get_stored_allocator();\
-      stored_allocator_traits::construct(a, move_detail::force_ptr<value_type *>(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
-      value_type *pval = move_detail::force_ptr<value_type *>(&v);\
+      stored_allocator_traits::construct(a, (value_type *)(&v) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
+      value_type *pval = move_detail::launder_cast<value_type *>(&v);\
       value_destructor<stored_allocator_type, value_type> d(a, *pval);\
       return this->insert_equal(hint, ::boost::move(*pval));\
    }\
@@ -1126,9 +1127,6 @@ class flat_tree
       return ret;
    }
 
-   inline iterator erase(const_iterator position)
-   {  return this->m_data.m_seq.erase(position);  }
-
    size_type erase(const key_type& k)
    {
       std::pair<iterator,iterator > itp = this->equal_range(k);
@@ -1148,6 +1146,40 @@ class flat_tree
       return ret;
    }
 
+   template <class K>
+   inline typename dtl::enable_if_c<
+      dtl::is_transparent<key_compare>::value &&      //transparent
+      !dtl::is_convertible<K, iterator>::value &&     //not convertible to iterator
+      !dtl::is_convertible<K, const_iterator>::value  //not convertible to const_iterator
+      , size_type>::type
+      erase(const K& k)
+   {
+      std::pair<iterator, iterator > itp = this->equal_range(k);
+      size_type ret = static_cast<size_type>(itp.second - itp.first);
+      if (ret) {
+         this->m_data.m_seq.erase(itp.first, itp.second);
+      }
+      return ret;
+   }
+
+   template <class K>
+   inline typename dtl::enable_if_c<
+      dtl::is_transparent<key_compare>::value &&      //transparent
+      !dtl::is_convertible<K, iterator>::value &&     //not convertible to iterator
+      !dtl::is_convertible<K, const_iterator>::value  //not convertible to const_iterator
+      , size_type>::type
+      erase_unique(const K& k)
+   {
+      const_iterator i = static_cast<const flat_tree&>(*this).find(k);
+      size_type ret = static_cast<size_type>(i != this->cend());
+      if (ret)
+         this->erase(i);
+      return ret;
+   }
+
+   inline iterator erase(const_iterator position)
+   {  return this->m_data.m_seq.erase(position);  }
+
    inline iterator erase(const_iterator first, const_iterator last)
    {  return this->m_data.m_seq.erase(first, last);  }
 
@@ -1700,7 +1732,7 @@ struct has_trivial_destructor_after_move<boost::container::dtl::flat_tree<T, Key
    typedef boost::container::dtl::flat_tree<T, KeyOfValue, Compare, AllocatorOrContainer> flat_tree;
    typedef typename flat_tree::container_type container_type;
    typedef typename flat_tree::key_compare key_compare;
-   static const bool value = ::boost::has_trivial_destructor_after_move<container_type>::value &&
+   BOOST_STATIC_CONSTEXPR bool value = ::boost::has_trivial_destructor_after_move<container_type>::value &&
                              ::boost::has_trivial_destructor_after_move<key_compare>::value;
 };
 

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

@@ -80,7 +80,7 @@ namespace function_detector {
       template <class U> \
       static NotFoundType Test( ... ); \
    public : \
-      static const int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType));\
+      BOOST_STATIC_CONSTEXPR int check = NotFound + (sizeof(Test<T>(0, 0)) - sizeof(NotFoundType));\
    };\
 }}} //namespace boost::container::function_detector {
 

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

@@ -51,7 +51,7 @@ namespace dtl {
 template <class Container>
 struct is_container
 {
-   static const bool value =
+   BOOST_STATIC_CONSTEXPR bool value =
       boost::container::is_container_detail::
          has_member_function_callable_with_size <const Container>::value &&
       boost::container::is_container_detail::
@@ -61,7 +61,7 @@ struct is_container
 template <>
 struct is_container<void>
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 

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

@@ -51,7 +51,7 @@ namespace dtl {
 template <class Container>
 struct is_contiguous_container
 {
-   static const bool value =
+   BOOST_STATIC_CONSTEXPR bool value =
       boost::container::is_contiguous_container_detail::
          has_member_function_callable_with_data<Container>::value && 
       boost::container::is_contiguous_container_detail::

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

@@ -61,25 +61,25 @@ struct pair;
 template <class T>
 struct is_pair
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template <class T1, class T2>
 struct is_pair< pair<T1, T2> >
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 template <class T1, class T2>
 struct is_pair< std::pair<T1, T2> >
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 template <class T>
 struct is_not_pair
 {
-   static const bool value = !is_pair<T>::value;
+   BOOST_STATIC_CONSTEXPR bool value = !is_pair<T>::value;
 };
 
 }  //namespace dtl {

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

@@ -723,50 +723,50 @@ struct has_iterator_category
    template <typename X>
    static two test(int, ...);
 
-   static const bool value = (1 == sizeof(test<T>(0, 0)));
+   BOOST_STATIC_CONSTEXPR bool value = (1 == sizeof(test<T>(0, 0)));
 };
 
 
 template<class T, bool = has_iterator_category<T>::value >
 struct is_input_iterator
 {
-   static const bool value = is_same<typename T::iterator_category, std::input_iterator_tag>::value;
+   BOOST_STATIC_CONSTEXPR bool value = is_same<typename T::iterator_category, std::input_iterator_tag>::value;
 };
 
 template<class T>
 struct is_input_iterator<T, false>
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template<class T>
 struct is_not_input_iterator
 {
-   static const bool value = !is_input_iterator<T>::value;
+   BOOST_STATIC_CONSTEXPR bool value = !is_input_iterator<T>::value;
 };
 
 template<class T, bool = has_iterator_category<T>::value >
 struct is_forward_iterator
 {
-   static const bool value = is_same<typename T::iterator_category, std::forward_iterator_tag>::value;
+   BOOST_STATIC_CONSTEXPR bool value = is_same<typename T::iterator_category, std::forward_iterator_tag>::value;
 };
 
 template<class T>
 struct is_forward_iterator<T, false>
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template<class T, bool = has_iterator_category<T>::value >
 struct is_bidirectional_iterator
 {
-   static const bool value = is_same<typename T::iterator_category, std::bidirectional_iterator_tag>::value;
+   BOOST_STATIC_CONSTEXPR bool value = is_same<typename T::iterator_category, std::bidirectional_iterator_tag>::value;
 };
 
 template<class T>
 struct is_bidirectional_iterator<T, false>
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template<class IINodeType>

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

@@ -100,7 +100,7 @@ struct upper_power_of_2_loop_ct
    template <Integer I, Integer P>
    struct apply
    {
-      static const Integer value =
+      BOOST_STATIC_CONSTEXPR Integer value =
          upper_power_of_2_loop_ct<Integer, (I > P*2)>::template apply<I, P*2>::value;
    };
 };
@@ -111,14 +111,14 @@ struct upper_power_of_2_loop_ct<Integer, false>
    template <Integer I, Integer P>
    struct apply
    {
-      static const Integer value = P;
+      BOOST_STATIC_CONSTEXPR Integer value = P;
    };
 };
 
 template <typename Integer, Integer I>
 struct upper_power_of_2_ct
 {
-   static const Integer value = upper_power_of_2_loop_ct<Integer, (I > 1)>::template apply<I, 2>::value;
+   BOOST_STATIC_CONSTEXPR Integer value = upper_power_of_2_loop_ct<Integer, (I > 1)>::template apply<I, 2>::value;
 };
 
 //This function uses binary search to discover the
@@ -144,27 +144,27 @@ inline std::size_t floor_log2 (std::size_t x)
 template<std::size_t I1, std::size_t I2>
 struct gcd_ct
 {
-   static const std::size_t Max = I1 > I2 ? I1 : I2;
-   static const std::size_t Min = I1 < I2 ? I1 : I2;
-   static const std::size_t value = gcd_ct<Min, Max % Min>::value;
+   BOOST_STATIC_CONSTEXPR std::size_t Max = I1 > I2 ? I1 : I2;
+   BOOST_STATIC_CONSTEXPR std::size_t Min = I1 < I2 ? I1 : I2;
+   BOOST_STATIC_CONSTEXPR std::size_t value = gcd_ct<Min, Max % Min>::value;
 };
 
 template<std::size_t I1>
 struct gcd_ct<I1, 0>
 {
-   static const std::size_t value = I1;
+   BOOST_STATIC_CONSTEXPR std::size_t value = I1;
 };
 
 template<std::size_t I1>
 struct gcd_ct<0, I1>
 {
-   static const std::size_t value = I1;
+   BOOST_STATIC_CONSTEXPR std::size_t value = I1;
 };
 
 template<std::size_t I1, std::size_t I2>
 struct lcm_ct
 {
-   static const std::size_t value = I1 * I2 / gcd_ct<I1, I2>::value;
+   BOOST_STATIC_CONSTEXPR std::size_t value = I1 * I2 / gcd_ct<I1, I2>::value;
 };
 
 } // namespace dtl

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

@@ -84,13 +84,13 @@ struct void_t { typedef void type; };
 template <class T, class=void>
 struct is_transparent_base
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template <class T>
 struct is_transparent_base<T, typename void_t<typename T::is_transparent>::type>
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 template <class T>
@@ -112,7 +112,7 @@ template<typename...> using variadic_void_t = void;
 template<typename Allocator, typename = void>
 struct is_allocator
 {
-   static const bool value = false;
+   BOOST_STATIC_CONSTEXPR bool value = false;
 };
 
 template <typename T>
@@ -123,7 +123,7 @@ struct is_allocator < Allocator,
    variadic_void_t< typename Allocator::value_type
                   , decltype(ctad_declval<Allocator&>().allocate(size_t{})) >>
 {
-   static const bool value = true;
+   BOOST_STATIC_CONSTEXPR bool value = true;
 };
 
 template<class T>

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

@@ -25,15 +25,17 @@
 #include <boost/container/container_fwd.hpp>
 // container/detail
 #include <boost/move/detail/to_raw_pointer.hpp>
-#include <boost/container/detail/transform_iterator.hpp>
 #include <boost/container/detail/type_traits.hpp>
 #include <boost/container/detail/placement_new.hpp>
+#include <boost/container/detail/iterator.hpp>
 // intrusive
 #include <boost/intrusive/slist.hpp>
 #include <boost/intrusive/pointer_traits.hpp>
 #include <boost/intrusive/detail/twin.hpp>
 // move
 #include <boost/move/utility_core.hpp>
+#include <boost/move/detail/iterator_to_raw_pointer.hpp>
+
 
 namespace boost {
 namespace container {
@@ -187,15 +189,100 @@ class basic_multiallocation_chain
    }
 };
 
-template<class T>
-struct cast_functor
+template <class Iterator, class T>
+class multialloc_iterator
+   : public boost::container::iterator
+      < typename Iterator::iterator_category
+      , T
+      , typename Iterator::difference_type
+      , T*
+      , T&
+      >
 {
-   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));  }
+   public:
+   inline explicit multialloc_iterator(const Iterator &it)
+      :  m_it(it)
+   {}
+
+   inline explicit multialloc_iterator()
+      :  m_it()
+   {}
+
+   //Constructors
+   inline multialloc_iterator& operator++()
+   { increment();   return *this;   }
+
+      inline multialloc_iterator operator++(int)
+   {
+      multialloc_iterator result (*this);
+      increment();
+      return result;
+   }
+
+   inline friend bool operator== (const multialloc_iterator& i, const multialloc_iterator& i2)
+   { return i.equal(i2); }
+
+   inline friend bool operator!= (const multialloc_iterator& i, const multialloc_iterator& i2)
+   { return !(i == i2); }
+
+   inline friend typename Iterator::difference_type operator- (const multialloc_iterator& i, const multialloc_iterator& i2)
+   { return i2.distance_to(i); }
+
+   //Arithmetic
+   inline multialloc_iterator& operator+=(typename Iterator::difference_type off)
+   {  this->advance(off); return *this;   }
+
+   inline multialloc_iterator operator+(typename Iterator::difference_type off) const
+   {
+      multialloc_iterator other(*this);
+      other.advance(off);
+      return other;
+   }
+
+   inline friend multialloc_iterator operator+(typename Iterator::difference_type off, const multialloc_iterator& right)
+   {  return right + off; }
+
+   inline multialloc_iterator& operator-=(typename Iterator::difference_type off)
+   {  this->advance(-off); return *this;   }
+
+   inline multialloc_iterator operator-(typename Iterator::difference_type off) const
+   {  return *this + (-off);  }
+
+   inline T& operator*() const
+   { return *this->operator->(); }
+
+   inline T* operator->() const
+   {  return static_cast<T*>(static_cast<void*>(boost::movelib::iterator_to_raw_pointer(m_it)));   }
+
+   inline Iterator & base()
+   {  return m_it;   }
+
+   inline const Iterator & base() const
+   {  return m_it;   }
+
+   private:
+   Iterator m_it;
+
+   inline void increment()
+   { ++m_it; }
+
+   inline void decrement()
+   { --m_it; }
+
+   inline bool equal(const multialloc_iterator &other) const
+   {  return m_it == other.m_it;   }
+
+   inline bool less(const multialloc_iterator &other) const
+   {  return other.m_it < m_it;   }
+
+   inline void advance(typename Iterator::difference_type n)
+   {  boost::container::iterator_advance(m_it, n); }
+
+   inline typename Iterator::difference_type distance_to(const multialloc_iterator &other)const
+   {  return boost::container::iterator_distance(other.m_it, m_it); }
 };
 
+
 template<class MultiallocationChain, class T>
 class transform_multiallocation_chain
    : public MultiallocationChain
@@ -217,9 +304,8 @@ class transform_multiallocation_chain
    {  return pointer_traits::static_cast_from(p);  }
 
    public:
-   typedef transform_iterator
-      < typename MultiallocationChain::iterator
-      , dtl::cast_functor <T> >                          iterator;
+   typedef multialloc_iterator
+      <typename MultiallocationChain::iterator, T>       iterator;
    typedef typename MultiallocationChain::size_type      size_type;
    typedef boost::intrusive::twin<pointer>               pointer_pair;
 

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

@@ -31,12 +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>
@@ -119,16 +121,16 @@ struct base_node
    }
 
    inline T &get_data()
-   {  return *move_detail::force_ptr<T*>(this->m_storage.data);   }
+   {  return *move_detail::force_ptr<T*>(&this->m_storage);   }
 
    inline const T &get_data() const
-   {  return *move_detail::force_ptr<const T*>(this->m_storage.data);  }
+   {  return *move_detail::launder_cast<const T*>(&this->m_storage);  }
 
    inline internal_type &get_real_data()
-   {  return *move_detail::force_ptr<internal_type*>(this->m_storage.data);   }
+   {  return *move_detail::launder_cast<internal_type*>(&this->m_storage);   }
 
    inline const internal_type &get_real_data() const
-   {  return *move_detail::force_ptr<const internal_type*>(this->m_storage.data);  }
+   {  return *move_detail::launder_cast<const internal_type*>(&this->m_storage);  }
 
    #if defined(BOOST_CONTAINER_DISABLE_ALIASING_WARNING)
       #pragma GCC diagnostic pop
@@ -534,6 +536,19 @@ struct node_alloc_holder
       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
    {

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()