passenger 6.0.13 → 6.0.15

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

@@ -64,6 +64,7 @@ using ::boost::move_detail::aligned_storage;
 using ::boost::move_detail::nat;
 using ::boost::move_detail::nat2;
 using ::boost::move_detail::nat3;
+using ::boost::move_detail::natN;
 using ::boost::move_detail::max_align_t;
 using ::boost::move_detail::is_convertible;
 

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

@@ -98,10 +98,11 @@
    #define BOOST_CONTAINER_FORCEINLINE inline
 #elif defined(BOOST_CONTAINER_FORCEINLINE_IS_BOOST_FORCELINE)
    #define BOOST_CONTAINER_FORCEINLINE BOOST_FORCEINLINE
-#elif defined(BOOST_MSVC) && defined(_DEBUG)
-   //"__forceinline" and MSVC seems to have some bugs in debug mode
+#elif defined(BOOST_MSVC) && (_MSC_VER < 1900 || defined(_DEBUG))
+   //"__forceinline" and MSVC seems to have some bugs in old versions and in debug mode
    #define BOOST_CONTAINER_FORCEINLINE inline
-#elif defined(__GNUC__) && ((__GNUC__ < 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ < 5)))
+//#elif defined(__GNUC__) && ((__GNUC__ < 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ < 5)))
+#elif defined(__GNUC__) && (__GNUC__ <= 5)
    //Older GCCs have problems with forceinline
    #define BOOST_CONTAINER_FORCEINLINE inline
 #else
@@ -129,13 +130,7 @@
 #endif
 
 
-#if (__cplusplus >= 201703L)
-   //CTAD supported
-   #ifdef __INTEL_COMPILER
-      //Intel compilers do not offer this feature yet
-      #define BOOST_CONTAINER_NO_CXX17_CTAD
-   #endif
-#else
+#if (BOOST_CXX_VERSION < 201703L) || !defined(__cpp_deduction_guides)
    #define BOOST_CONTAINER_NO_CXX17_CTAD
 #endif
 

data/src/cxx_supportlib/vendor-modified/boost/container/devector.hpp

@@ -47,6 +47,7 @@
 #include <boost/move/utility_core.hpp>
 #include <boost/move/detail/to_raw_pointer.hpp>
 #include <boost/move/algo/detail/merge.hpp>
+#include <boost/move/detail/force_ptr.hpp>
 
 #include <boost/type_traits/is_nothrow_move_constructible.hpp>
 
@@ -179,7 +180,7 @@ class devector
    typedef typename detail::allocation_guard<allocator_type> allocation_guard;
 
    // Random access pseudo iterator always yielding to the same result
-   typedef constant_iterator<T, difference_type> cvalue_iterator;
+   typedef constant_iterator<T> cvalue_iterator;
 
    #endif // ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -223,7 +224,7 @@ class devector
    * **Complexity**: Constant.
    */
    devector(size_type n, reserve_only_tag_t, const allocator_type& allocator = allocator_type())
-      : m_(allocator, this->allocate(n), 0u, 0u, n)
+      : m_(allocator, 0u, 0u, n)
    {}
 
    /**
@@ -239,7 +240,7 @@ class devector
    * **Complexity**: Constant.
    */
    devector(size_type front_cap, size_type back_cap, reserve_only_tag_t, const allocator_type& allocator = allocator_type())
-      : m_(allocator, this->allocate(front_cap + back_cap), front_cap, front_cap, front_cap + back_cap)
+      : m_( allocator, front_cap, back_cap, front_cap + back_cap)
    {}
 
    /**
@@ -256,7 +257,7 @@ class devector
    * **Complexity**: Linear in `n`.
    */
    explicit devector(size_type n, const allocator_type& allocator = allocator_type())
-      : m_(allocator, n ? allocate(n): pointer(), 0u, n, n)
+      : m_(allocator, 0u, n, n)
    {
       // Cannot use construct_from_range/constant_iterator and copy_range,
       // because we are not allowed to default construct T
@@ -346,9 +347,9 @@ class devector
          BOOST_MOVE_I dtl::is_input_iterator<ForwardIterator>
          >::type * = 0)
       )
-      : m_(allocator, pointer(), 0u, 0u, 0u)
+      : m_(allocator)
    {
-      const size_type n = boost::container::iterator_distance(first, last);
+      const size_type n = boost::container::iterator_udistance(first, last);
       m_.buffer = n ? allocate(n) : pointer();
       m_.front_idx = 0u;
       //this->allocate(n) will take care of overflows
@@ -375,8 +376,7 @@ class devector
    * **Complexity**: Linear in the size of `x`.
    */
    devector(const devector& x)
-      : m_( allocator_traits_type::select_on_container_copy_construction(x.get_allocator_ref())
-          , pointer(), 0u, 0u, 0u)
+      : m_( allocator_traits_type::select_on_container_copy_construction(x.get_allocator_ref()))
    {
       const size_type n = x.size();
       m_.buffer = n ? allocate(n) : pointer();
@@ -466,7 +466,7 @@ class devector
    * **Equivalent to**: `devector(il.begin(), il.end())` or `devector(il.begin(), il.end(), allocator)`.
    */
    devector(const std::initializer_list<T>& il, const allocator_type& allocator = allocator_type())
-      : m_(allocator, pointer(), 0u, 0u, 0u)
+      : m_(allocator)
    {
       const size_type n = il.size();
       m_.buffer = n ? allocate(n) : pointer();
@@ -703,7 +703,7 @@ class devector
          >::type * = 0)
       )
    {
-      const size_type n = boost::container::iterator_distance(first, last);
+      const size_type n = boost::container::iterator_udistance(first, last);
 
       if (capacity() >= n)
       {
@@ -943,7 +943,7 @@ class devector
   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
    size_type size() const BOOST_NOEXCEPT
   {
-    return m_.back_idx - m_.front_idx;
+    return size_type(m_.back_idx - m_.front_idx);
   }
 
   /**
@@ -991,7 +991,7 @@ class devector
   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
    size_type back_free_capacity() const BOOST_NOEXCEPT
   {
-    return m_.capacity - m_.back_idx;
+    return size_type(m_.capacity - m_.back_idx);
   }
 
   /** **Equivalent to**: `resize_back(sz)` */
@@ -1643,7 +1643,7 @@ class devector
       }
       else
       {
-         size_type new_elem_index = position - begin();
+         size_type new_elem_index = size_type(position - begin());
          return this->emplace_slow_path(new_elem_index, boost::forward<Args>(args)...);
       }
    }
@@ -1668,7 +1668,7 @@ class devector
          return begin();\
       }\
       else{\
-         size_type new_elem_index = position - begin();\
+         size_type new_elem_index = size_type(position - begin());\
          return this->emplace_slow_path(new_elem_index BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       }\
    }\
@@ -1900,9 +1900,9 @@ class devector
    */
    iterator erase(iterator first, iterator last)
    {
-      size_type front_distance = last - begin();
-      size_type back_distance = end() - first;
-      size_type n = boost::container::iterator_distance(first, last);
+      size_type front_distance = size_type(last - begin());
+      size_type back_distance  = size_type(end() - first);
+      size_type n = boost::container::iterator_udistance(first, last);
 
       if (front_distance < back_distance)
       {
@@ -2058,15 +2058,11 @@ class devector
 
    pointer allocate(size_type capacity)
    {
-      //First detect overflow on smaller stored_size_types
-      if (capacity > stored_size_type(-1)){
-         boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
-      }
-      //(clamp_by_stored_size_type<size_type>)(prefer_in_recvd_out_size, stored_size_type());
+      pointer const p = impl::do_allocate(get_allocator_ref(), capacity);
       #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
       ++m_.capacity_alloc_count;
       #endif // BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-      return allocator_traits_type::allocate(get_allocator_ref(), capacity);
+      return p;
    }
 
    void destroy_elements(pointer begin, pointer end)
@@ -2081,7 +2077,7 @@ class devector
    {
       if (m_.buffer)
       {
-      allocator_traits_type::deallocate(get_allocator_ref(), m_.buffer, m_.capacity);
+         allocator_traits_type::deallocate(get_allocator_ref(), m_.buffer, m_.capacity);
       }
    }
 
@@ -2152,7 +2148,7 @@ class devector
 
    BOOST_CONTAINER_FORCEINLINE size_type back_capacity() const
    {
-      return m_.capacity - m_.front_idx;
+      return size_type(m_.capacity - m_.front_idx);
    }
 
    size_type calculate_new_capacity(size_type requested_capacity)
@@ -2549,7 +2545,7 @@ class devector
       {\
          BOOST_ASSERT(size() >= 1);\
          typename dtl::aligned_storage<sizeof(T), dtl::alignment_of<T>::value>::type v;\
-         T *vp = reinterpret_cast<T *>(v.data);\
+         T *vp = move_detail::force_ptr<T *>(v.data);\
          allocator_traits_type::construct(get_stored_allocator(), vp BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
          T &tmp = *vp;\
          dtl::value_destructor<allocator_type> on_exit(get_stored_allocator(), tmp); (void)on_exit;\
@@ -2564,7 +2560,7 @@ class devector
       else if (back_free_capacity()) {\
          BOOST_ASSERT(size() >= 1);\
          typename dtl::aligned_storage<sizeof(T), dtl::alignment_of<T>::value>::type v;\
-         T *vp = reinterpret_cast<T *>(v.data);\
+         T *vp = move_detail::force_ptr<T *>(v.data);\
          allocator_traits_type::construct(get_stored_allocator(), vp BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
          T &tmp = *vp;\
          dtl::value_destructor<allocator_type> on_exit(get_stored_allocator(), tmp); (void)on_exit;\
@@ -2671,7 +2667,7 @@ class devector
       m_.buffer = new_buffer;
       //Safe cast, allocate() will handle stored_size_type overflow
       m_.set_capacity(new_capacity);
-      m_.set_back_idx(m_.back_idx - m_.front_idx + buffer_offset);
+      m_.set_back_idx(size_type(m_.back_idx - m_.front_idx) + buffer_offset);
       m_.set_front_idx(buffer_offset);
 
       BOOST_ASSERT(invariants_ok());
@@ -2680,7 +2676,7 @@ class devector
    template <typename ForwardIterator>
    iterator insert_range(const_iterator position, ForwardIterator first, ForwardIterator last)
    {
-      size_type n = boost::container::iterator_distance(first, last);
+      size_type n = boost::container::iterator_udistance(first, last);
 
       if (position == end() && back_free_capacity() >= n) {// fast path
          iterator r(this->end());
@@ -2701,8 +2697,8 @@ class devector
    template <typename ForwardIterator>
    iterator insert_range_slow_path(const_iterator position, ForwardIterator first, ForwardIterator last)
    {
-      size_type n = boost::container::iterator_distance(first, last);
-      size_type index = position - begin();
+      size_type n = boost::container::iterator_udistance(first, last);
+      size_type index = size_type(position - begin());
 
       if (front_free_capacity() + back_free_capacity() >= n) {
          // if we move enough, it can be done without reallocation
@@ -2834,7 +2830,7 @@ class devector
    template <typename ForwardIterator>
    void allocate_and_copy_range(ForwardIterator first, ForwardIterator last)
    {
-      size_type n = boost::container::iterator_distance(first, last);
+      size_type n = boost::container::iterator_udistance(first, last);
 
       pointer new_buffer = n ? allocate(n) : pointer();
       allocation_guard new_buffer_guard(new_buffer, n, get_allocator_ref());
@@ -2861,7 +2857,7 @@ class devector
    template <typename ForwardIterator>
    void overwrite_buffer_impl(ForwardIterator first, ForwardIterator last, dtl::true_)
    {
-      const size_type n = boost::container::iterator_distance(first, last);
+      const size_type n = boost::container::iterator_udistance(first, last);
 
       BOOST_ASSERT(capacity() >= n);
       boost::container::uninitialized_copy_alloc_n
@@ -2901,7 +2897,7 @@ class devector
       back_guard.release();
 
       m_.front_idx = 0;
-      m_.set_back_idx(pos - begin());
+      m_.set_back_idx(size_type(pos - begin()));
       return first;
    }
 
@@ -2921,17 +2917,49 @@ class devector
 
    struct impl : allocator_type
    {
+      private:
+      impl(const impl &i);
+
+      public:
+      allocator_type &get_al()
+      {  return *this;  }
+
+      static pointer do_allocate(allocator_type &a, size_type cap)
+      {
+         if (cap) {
+            //First detect overflow on smaller stored_size_types
+            if (cap > stored_size_type(-1)){
+               boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
+            }
+            return allocator_traits_type::allocate(a, cap);
+         }
+         else {
+            return pointer();
+         }
+      }
+
       impl()
          : allocator_type(), buffer(), front_idx(), back_idx(), capacity()
          #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-         , capacity_alloc_count()
+         , capacity_alloc_count(0)
          #endif
       {}
 
       explicit impl(const allocator_type &a)
          : allocator_type(a), buffer(), front_idx(), back_idx(), capacity()
          #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-         , capacity_alloc_count()
+         , capacity_alloc_count(0)
+         #endif
+      {}
+
+      impl(const allocator_type &a, size_type f, size_type b, size_type c)
+         : allocator_type(a), buffer(do_allocate(get_al(), c))
+         //static cast sizes, as the allocation function will take care of overflows
+         , front_idx(static_cast<stored_size_type>(f))
+         , back_idx(static_cast<stored_size_type>(b))
+         , capacity(static_cast<stored_size_type>(c))
+         #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
+         , capacity_alloc_count(size_type(buffer != pointer()))
          #endif
       {}
 
@@ -2942,7 +2970,7 @@ class devector
          , back_idx(static_cast<stored_size_type>(b))
          , capacity(static_cast<stored_size_type>(c))
          #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-         , capacity_alloc_count()
+         , capacity_alloc_count(0)
          #endif
       {}
 
@@ -2953,7 +2981,7 @@ class devector
          , back_idx(static_cast<stored_size_type>(b))
          , capacity(static_cast<stored_size_type>(c))
          #ifdef BOOST_CONTAINER_DEVECTOR_ALLOC_STATS
-         , capacity_alloc_count()
+         , capacity_alloc_count(0)
          #endif
       {}
 

data/src/cxx_supportlib/vendor-modified/boost/container/flat_map.hpp

@@ -39,6 +39,7 @@
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 #include <boost/move/detail/move_helpers.hpp>
+#include <boost/move/detail/force_ptr.hpp>
 // intrusive
 #include <boost/intrusive/detail/minimal_pair_header.hpp>      //pair
 #include <boost/intrusive/detail/minimal_less_equal_header.hpp>//less, equal
@@ -61,12 +62,16 @@ namespace dtl{
 
 template<class D, class S>
 BOOST_CONTAINER_FORCEINLINE static D &force(S &s)
-{  return *reinterpret_cast<D*>(&s); }
+{  return *move_detail::force_ptr<D*>(&s); }
+
+template<class D, class S>
+BOOST_CONTAINER_FORCEINLINE static const D &force(const S &s)
+{  return *move_detail::force_ptr<const D*>(&s); }
 
 template<class D, class S>
 BOOST_CONTAINER_FORCEINLINE static D force_copy(const S &s)
 {
-   const D *const vp = reinterpret_cast<const D *>(&s);
+   const D *const vp = move_detail::force_ptr<const D *>(&s);
    D ret_val(*vp);
    return ret_val;
 }
@@ -103,7 +108,7 @@ BOOST_CONTAINER_FORCEINLINE static D force_copy(const S &s)
 //!   - The allocator to allocate <code>value_type</code>s (e.g. <i>allocator< std::pair<Key, T> > </i>).
 //!     (in this case <i>sequence_type</i> will be vector<value_type, AllocatorOrContainer>)
 //!   - The SequenceContainer to be used as the underlying <i>sequence_type</i>. It must be a vector-like
-//!     sequence container with random-access iterators..
+//!     sequence container with random-access iterators.
 #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED
 template <class Key, class T, class Compare = std::less<Key>, class AllocatorOrContainer = new_allocator< std::pair< Key, T> > >
 #else
@@ -1265,14 +1270,14 @@ class flat_map
          (m_flat_tree.erase(dtl::force_copy<impl_const_iterator>(p)));
    }
 
-   //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
+   //! <b>Effects</b>: If present, erases the element in the container with key equivalent to x.
    //!
-   //! <b>Returns</b>: Returns the number of erased elements.
+   //! <b>Returns</b>: Returns the number of erased elements (0/1).
    //!
    //! <b>Complexity</b>: Logarithmic search time plus erasure time
    //!   linear to the elements with bigger keys.
    BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
-      { return m_flat_tree.erase(x); }
+      { return m_flat_tree.erase_unique(x); }
 
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
    //!
@@ -1568,6 +1573,14 @@ class flat_map
    BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_unique_range_t, BOOST_RV_REF(sequence_type) seq)
    {  this->m_flat_tree.adopt_sequence_unique(ordered_unique_range_t(), boost::move(dtl::force<impl_sequence_type>(seq)));  }
 
+   //! <b>Effects</b>: Returns a const view of the underlying sequence.
+   //!
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing
+   BOOST_CONTAINER_FORCEINLINE const sequence_type & sequence() const BOOST_NOEXCEPT
+   {  return dtl::force<sequence_type>(m_flat_tree.get_sequence_cref());  }
+
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.
@@ -2886,9 +2899,7 @@ class flat_multimap
    //! <b>Throws</b>: If secuence_type's move constructor throws 
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       sequence_type extract_sequence()
-   {
-      return boost::move(dtl::force<sequence_type>(m_flat_tree.get_sequence_ref()));
-   }
+   {  return boost::move(dtl::force<sequence_type>(m_flat_tree.get_sequence_ref()));   }
 
    //! <b>Effects</b>: Discards the internally hold sequence container and adopts the
    //!   one passed externally using the move assignment.
@@ -2910,6 +2921,14 @@ class flat_multimap
    BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_range_t, BOOST_RV_REF(sequence_type) seq)
    {  this->m_flat_tree.adopt_sequence_equal(ordered_range_t(), boost::move(dtl::force<impl_sequence_type>(seq)));  }
 
+   //! <b>Effects</b>: Returns a const view of the underlying sequence.
+   //!
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing
+   BOOST_CONTAINER_FORCEINLINE const sequence_type & sequence() const BOOST_NOEXCEPT
+   {  return dtl::force<sequence_type>(m_flat_tree.get_sequence_cref());  }
+
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
    //! <b>Complexity</b>: Linear to the number of elements in the container.

data/src/cxx_supportlib/vendor-modified/boost/container/flat_set.hpp

@@ -767,6 +767,15 @@ class flat_set
    BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG flat_multiset<Key, C2, AllocatorOrContainer> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<flat_multiset<Key, C2, AllocatorOrContainer>&>(source));   }
 
+   //! <b>Effects</b>: If present, erases the element in the container with key equivalent to x.
+   //!
+   //! <b>Returns</b>: Returns the number of erased elements (0/1).
+   //!
+   //! <b>Complexity</b>: Logarithmic search time plus erasure time
+   //!   linear to the elements with bigger keys.
+   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
+   {  return this->tree_t::erase_unique(x);   }
+
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Erases the element pointed to by p.
@@ -781,14 +790,6 @@ class flat_set
    //!   not less than the erased element.
    iterator erase(const_iterator p);
 
-   //! <b>Effects</b>: Erases all elements in the container with key equivalent to x.
-   //!
-   //! <b>Returns</b>: Returns the number of erased elements.
-   //!
-   //! <b>Complexity</b>: Logarithmic search time plus erasure time
-   //!   linear to the elements with bigger keys.
-   size_type erase(const key_type& x);
-
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
    //!
    //! <b>Returns</b>: Returns last.
@@ -909,6 +910,8 @@ class flat_set
    //! <b>Note</b>: Non-standard extension
    size_type index_of(const_iterator p) const BOOST_NOEXCEPT_OR_NOTHROW;
 
+   #else
+   using tree_t::erase;
    #endif   //   #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
@@ -1119,6 +1122,14 @@ class flat_set
    //! <b>Throws</b>: If the move assignment throws
    BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_unique_range_t, BOOST_RV_REF(sequence_type) seq)
    {  this->tree_t::adopt_sequence_unique(ordered_unique_range_t(), boost::move(seq));  }
+
+   //! <b>Effects</b>: Returns a const view of the underlying sequence.
+   //!
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing
+   BOOST_CONTAINER_FORCEINLINE const sequence_type & sequence() const BOOST_NOEXCEPT
+   {  return this->get_sequence_cref();  }
 };
 
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD
@@ -1842,6 +1853,14 @@ class flat_multiset
    //! <b>Throws</b>: If the move assignment throws
    BOOST_CONTAINER_FORCEINLINE void adopt_sequence(ordered_range_t, BOOST_RV_REF(sequence_type) seq)
    {  this->tree_t::adopt_sequence_equal(ordered_range_t(), boost::move(seq));  }
+
+   //! <b>Effects</b>: Returns a const view of the underlying sequence.
+   //!
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing
+   BOOST_CONTAINER_FORCEINLINE const sequence_type & sequence() const BOOST_NOEXCEPT
+   {  return this->get_sequence_cref();  }
 };
 
 #ifndef BOOST_CONTAINER_NO_CXX17_CTAD

data/src/cxx_supportlib/vendor-modified/boost/container/list.hpp

@@ -43,6 +43,7 @@
 #  include <boost/move/detail/fwd_macros.hpp>
 #endif
 #include <boost/move/detail/move_helpers.hpp>
+#include <boost/move/detail/force_ptr.hpp>
 
 // intrusive
 #include <boost/intrusive/pointer_traits.hpp>
@@ -68,61 +69,8 @@ struct list_hook
 };
 
 template <class T, class VoidPointer>
-struct list_node
-   :  public list_hook<VoidPointer>::type
+struct iiterator_node_value_type< base_node<T, list_hook<VoidPointer> > >
 {
-   public:
-   typedef T value_type;
-   typedef T internal_type;
-   typedef typename list_hook<VoidPointer>::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
-
-   BOOST_CONTAINER_FORCEINLINE T &get_data()
-   {  return *reinterpret_cast<T*>(this->m_storage.data);   }
-
-   BOOST_CONTAINER_FORCEINLINE const T &get_data() const
-   {  return *reinterpret_cast<const T*>(this->m_storage.data);  }
-
-   BOOST_CONTAINER_FORCEINLINE T *get_data_ptr()
-   {  return reinterpret_cast<T*>(this->m_storage.data);  }
-
-   BOOST_CONTAINER_FORCEINLINE const T *get_data_ptr() const
-   {  return reinterpret_cast<T*>(this->m_storage.data);  }
-
-   BOOST_CONTAINER_FORCEINLINE internal_type &get_real_data()
-   {  return *reinterpret_cast<internal_type*>(this->m_storage.data);   }
-
-   BOOST_CONTAINER_FORCEINLINE const internal_type &get_real_data() const
-   {  return *reinterpret_cast<const internal_type*>(this->m_storage.data);  }
-
-   BOOST_CONTAINER_FORCEINLINE internal_type *get_real_data_ptr()
-   {  return reinterpret_cast<internal_type*>(this->m_storage.data);  }
-
-   BOOST_CONTAINER_FORCEINLINE const internal_type *get_real_data_ptr() const
-   {  return reinterpret_cast<internal_type*>(this->m_storage.data);  }
-
-   BOOST_CONTAINER_FORCEINLINE ~list_node()
-   {  reinterpret_cast<T*>(this->m_storage.data)->~T();  }
-
-   #if defined(BOOST_CONTAINER_DISABLE_ALIASING_WARNING)
-      #pragma GCC diagnostic pop
-      #undef BOOST_CONTAINER_DISABLE_ALIASING_WARNING
-   #  endif
-
-   BOOST_CONTAINER_FORCEINLINE void destroy_header()
-   {  static_cast<hook_type*>(this)->~hook_type();  }
-};
-
-template <class T, class VoidPointer>
-struct iiterator_node_value_type< list_node<T,VoidPointer> > {
   typedef T type;
 };
 
@@ -135,8 +83,7 @@ struct intrusive_list_type
       <typename allocator_traits_type::pointer>::template
          rebind_pointer<void>::type
             void_pointer;
-   typedef typename dtl::list_node
-         <value_type, void_pointer>             node_type;
+   typedef base_node<value_type, list_hook<void_pointer> > node_type;
    typedef typename dtl::bi::make_list
       < node_type
       , dtl::bi::base_hook<typename list_hook<void_pointer>::type>
@@ -183,7 +130,7 @@ class list
    typedef typename AllocHolder::NodeAlloc                        NodeAlloc;
    typedef typename AllocHolder::ValAlloc                         ValAlloc;
    typedef typename AllocHolder::Node                             Node;
-   typedef dtl::allocator_destroyer<NodeAlloc>                    Destroyer;
+   typedef dtl::allocator_node_destroyer<NodeAlloc>                    Destroyer;
    typedef typename AllocHolder::alloc_version                    alloc_version;
    typedef boost::container::allocator_traits<ValueAllocator>     allocator_traits_type;
    typedef boost::container::equal_to_value
@@ -444,7 +391,7 @@ class list
    //! <b>Complexity</b>: Linear to n.
    BOOST_CONTAINER_FORCEINLINE void assign(size_type n, const T& val)
    {
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->assign(cvalue_iterator(val, n), cvalue_iterator());
    }
 
@@ -676,7 +623,7 @@ class list
    void resize(size_type new_size)
    {
       if(!priv_try_shrink(new_size)){
-         typedef value_init_construct_iterator<value_type, difference_type> value_init_iterator;
+         typedef value_init_construct_iterator<value_type> value_init_iterator;
          this->insert(this->cend(), value_init_iterator(new_size - this->size()), value_init_iterator());
       }
    }
@@ -911,7 +858,7 @@ class list
    iterator insert(const_iterator position, size_type n, const T& x)
    {
       //range check is done by insert
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->insert(position, cvalue_iterator(x, n), cvalue_iterator());
    }
 
@@ -966,7 +913,7 @@ class list
       insertion_functor func(this->icont(), position.get());
       iterator before_p(position.get());
       --before_p;
-      this->allocate_many_and_construct(first, boost::container::iterator_distance(first, last), func);
+      this->allocate_many_and_construct(first, boost::container::iterator_udistance(first, last), func);
       return ++before_p;
    }
    #endif
@@ -1494,17 +1441,13 @@ class list
       return iterator(this->icont().insert(p.get(), *tmp));
    }
 
-   void priv_push_back (const T &x)
-   {  this->insert(this->cend(), x);    }
-
-   void priv_push_back (BOOST_RV_REF(T) x)
-   {  this->insert(this->cend(), boost::move(x));    }
-
-   void priv_push_front (const T &x)
-   {  this->insert(this->cbegin(), x);  }
+   template<class U>
+   void priv_push_back(BOOST_FWD_REF(U) x)
+   {  this->icont().push_back(*this->create_node(::boost::forward<U>(x))); }
 
-   void priv_push_front (BOOST_RV_REF(T) x)
-   {  this->insert(this->cbegin(), boost::move(x));  }
+   template<class U>
+   void priv_push_front(BOOST_FWD_REF(U) x)
+   {  this->icont().push_front(*this->create_node(::boost::forward<U>(x))); }
 
    class insertion_functor;
    friend class insertion_functor;