passenger 6.0.14 → 6.0.15

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

@@ -964,6 +964,14 @@ class map
 
    #endif   // !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
 
+   //! <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>: log(size()) + count(k)
+   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
+      { return this->base_t::erase_unique(x); }
+
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Erases the element pointed to by p.
@@ -975,13 +983,6 @@ class map
    //! <b>Complexity</b>: Amortized constant time
    iterator erase(const_iterator p) BOOST_NOEXCEPT_OR_NOTHROW;
 
-   //! <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>: log(size()) + count(k)
-   size_type erase(const key_type& x) BOOST_NOEXCEPT_OR_NOTHROW;
-
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
    //!
    //! <b>Returns</b>: Returns last.
@@ -989,7 +990,9 @@ class map
    //! <b>Complexity</b>: log(size())+N where N is the distance from first to last.
    iterator erase(const_iterator first, const_iterator last) BOOST_NOEXCEPT_OR_NOTHROW;
 
-   #endif
+   #else
+   using base_t::erase;
+   #endif   //   #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Removes the first element in the container with key equivalent to k.
    //!

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

@@ -162,8 +162,15 @@ class new_allocator
 
    //!Deallocates previously allocated memory.
    //!Never throws
-   void deallocate(pointer ptr, size_type) BOOST_NOEXCEPT_OR_NOTHROW
-     { ::operator delete((void*)ptr); }
+   void deallocate(pointer ptr, size_type n) BOOST_NOEXCEPT_OR_NOTHROW
+   {
+      (void)n;
+      # if __cpp_sized_deallocation
+      ::operator delete((void*)ptr, n * sizeof(T));
+      #else
+      ::operator delete((void*)ptr);
+      # endif
+   }
 
    //!Returns the maximum number of elements that could be allocated.
    //!Never throws

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

@@ -81,7 +81,7 @@ class node_allocator
    typedef std::ptrdiff_t                       difference_type;
 
    typedef boost::container::dtl::
-      version_type<self_t, Version>             version;
+      version_type<self_t, (unsigned int) Version>             version;
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    typedef boost::container::dtl::

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

@@ -123,7 +123,7 @@ class node_handle
 
    void destroy_deallocate_node()
    {
-      nator_traits::destroy(this->node_alloc(), boost::movelib::to_raw_pointer(m_ptr));
+      boost::movelib::to_raw_pointer(m_ptr)->destructor(this->node_alloc());
       nator_traits::deallocate(this->node_alloc(), m_ptr, 1u);
    }
 
@@ -418,8 +418,8 @@ struct insert_return_type_base
    {}
 
    template<class RelatedIt, class RelatedNode>
-   insert_return_type_base(bool insert, RelatedIt it, BOOST_RV_REF(RelatedNode) node)
-      : inserted(insert), position(it), node(boost::move(node))
+   insert_return_type_base(bool insert, RelatedIt it, BOOST_RV_REF(RelatedNode) n)
+      : inserted(insert), position(it), node(boost::move(n))
    {}
 
    insert_return_type_base & operator=(BOOST_RV_REF(insert_return_type_base) other)

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

@@ -113,20 +113,33 @@ using tree_assoc_options_t = typename boost::container::tree_assoc_options<Optio
 
 #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-template<bool StoreHash>
+template<bool StoreHash, bool CacheBegin, bool LinearBuckets, bool FastmodBuckets>
 struct hash_opt
 {
-   static const bool store_hash = StoreHash;
+   static const bool store_hash  = StoreHash;
+   static const bool cache_begin = CacheBegin;
+   static const bool linear_buckets = LinearBuckets;
+   static const bool fastmod_buckets = FastmodBuckets;
 };
 
-typedef hash_opt<false> hash_assoc_defaults;
+typedef hash_opt<false, false, false, false> hash_assoc_defaults;
 
 #endif   //!defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
-//!This option setter specifies if node size is optimized
-//!storing rebalancing data masked into pointers for ordered associative containers
+//!This option setter specifies if nodes also store the hash value
+//!so that search and rehashing for hash-expensive types is improved.
+//!This option might degrade performance for easy to hash types (like integers)
 BOOST_INTRUSIVE_OPTION_CONSTANT(store_hash, bool, Enabled, store_hash)
 
+//!This option setter specifies if the container will cache the first
+//!non-empty bucket so that begin() is O(1) instead of searching for the
+//!first non-empty bucket (which can be O(bucket_size()))
+BOOST_INTRUSIVE_OPTION_CONSTANT(cache_begin, bool, Enabled, cache_begin)
+
+BOOST_INTRUSIVE_OPTION_CONSTANT(linear_buckets, bool, Enabled, linear_buckets)
+
+BOOST_INTRUSIVE_OPTION_CONSTANT(fastmod_buckets, bool, Enabled, fastmod_buckets)
+
 //! Helper metafunction to combine options into a single type to be used
 //! by \c boost::container::hash_set, \c boost::container::hash_multiset
 //! \c boost::container::hash_map and \c boost::container::hash_multimap.
@@ -147,7 +160,11 @@ struct hash_assoc_options
       Options...
       #endif
       >::type packed_options;
-   typedef hash_opt<packed_options::store_hash> implementation_defined;
+   typedef hash_opt<packed_options::store_hash
+                   ,packed_options::cache_begin
+                   ,packed_options::linear_buckets
+                   ,packed_options::fastmod_buckets
+                   > implementation_defined;
    /// @endcond
    typedef implementation_defined type;
 };

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/memory_resource.hpp

@@ -19,6 +19,7 @@
 #include <boost/container/detail/workaround.hpp>
 #include <boost/container/container_fwd.hpp>
 #include <boost/move/detail/type_traits.hpp>
+#include <boost/container/detail/placement_new.hpp>
 #include <cstddef>
 
 namespace boost {
@@ -41,7 +42,11 @@ class memory_resource
    //! <b>Effects</b>: Equivalent to
    //! `return do_allocate(bytes, alignment);`
    void* allocate(std::size_t bytes, std::size_t alignment = max_align)
-   {  return this->do_allocate(bytes, alignment);  }
+   {  
+      //Obtain a pointer to enough storage and initialize the lifetime 
+      //of an array object of the given size in the address
+      return ::operator new(bytes, this->do_allocate(bytes, alignment), boost_container_new_t());
+   }
 
    //! <b>Effects</b>: Equivalent to
    //! `return do_deallocate(bytes, alignment);`

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/monotonic_buffer_resource.hpp

@@ -160,18 +160,18 @@ class BOOST_CONTAINER_DECL monotonic_buffer_resource
    //!   then allocate the return block from the newly-allocated internal `current_buffer`.
    //!
    //! <b>Throws</b>: Nothing unless `upstream_resource()->allocate()` throws.
-   void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
+   virtual void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! <b>Effects</b>: None
    //!
    //! <b>Throws</b>: Nothing
    //!
    //! <b>Remarks</b>: Memory used by this resource increases monotonically until its destruction.
-   void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_NOEXCEPT BOOST_OVERRIDE;
+   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_NOEXCEPT BOOST_OVERRIDE;
 
    //! <b>Returns</b>:
    //!   `this == dynamic_cast<const monotonic_buffer_resource*>(&other)`.
-   bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE;
+   virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 };
 
 }  //namespace pmr {

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/resource_adaptor.hpp

@@ -144,7 +144,7 @@ class resource_adaptor_imp
    protected:
    //! <b>Returns</b>: Allocated memory obtained by calling m_alloc.allocate. The size and alignment
    //!   of the allocated memory shall meet the requirements for a class derived from memory_resource.
-   virtual void* do_allocate(std::size_t bytes, std::size_t alignment)
+   virtual void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE
    {
       if (alignment <= priv_guaranteed_allocator_alignment())
          return this->ebo_alloc_t::get().allocate(bytes);
@@ -156,7 +156,7 @@ class resource_adaptor_imp
    //!   subsequently deallocated. 
    //!
    //! <b>Effects</b>: Returns memory to the allocator using m_alloc.deallocate().
-   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment)
+   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE
    {
       if (alignment <= priv_guaranteed_allocator_alignment())
          this->ebo_alloc_t::get().deallocate((char*)p, bytes);
@@ -167,7 +167,7 @@ class resource_adaptor_imp
    //! Let p be dynamic_cast<const resource_adaptor_imp*>(&other).
    //!
    //! <b>Returns</b>: false if p is null, otherwise the value of m_alloc == p->m_alloc.
-   virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT
+   virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE
    {
       const resource_adaptor_imp* p = dynamic_cast<const resource_adaptor_imp*>(&other);
       return p && p->ebo_alloc_t::get() == this->ebo_alloc_t::get();

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/synchronized_pool_resource.hpp

@@ -103,13 +103,13 @@ class BOOST_CONTAINER_DECL synchronized_pool_resource
    protected:
 
    //! @copydoc ::boost::container::pmr::unsynchronized_pool_resource::do_allocate()
-   void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
+   virtual void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! @copydoc ::boost::container::pmr::unsynchronized_pool_resource::do_deallocate(void*,std::size_t,std::size_t)
-   void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
+   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! @copydoc ::boost::container::pmr::unsynchronized_pool_resource::do_is_equal(const memory_resource&)const
-   bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE;
+   virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 
    //Non-standard observers
    public:

data/src/cxx_supportlib/vendor-modified/boost/container/pmr/unsynchronized_pool_resource.hpp

@@ -134,18 +134,18 @@ class BOOST_CONTAINER_DECL unsynchronized_pool_resource
    //!   using `upstream_resource()->allocate()`.
    //!
    //! <b>Throws</b>: Nothing unless `upstream_resource()->allocate()` throws.
-   void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
+   virtual void* do_allocate(std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! <b>Effects</b>: Return the memory at p to the pool. It is unspecified if or under
    //!   what circumstances this operation will result in a call to
    //!   `upstream_resource()->deallocate()`.
    //!
    //! <b>Throws</b>: Nothing.
-   void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
+   virtual void do_deallocate(void* p, std::size_t bytes, std::size_t alignment) BOOST_OVERRIDE;
 
    //! <b>Returns</b>:
    //!   `this == dynamic_cast<const unsynchronized_pool_resource*>(&other)`.
-   bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE;
+   virtual bool do_is_equal(const memory_resource& other) const BOOST_NOEXCEPT BOOST_OVERRIDE;
 
    //Non-standard observers
    public:

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

@@ -680,6 +680,14 @@ class set
    BOOST_CONTAINER_FORCEINLINE void merge(BOOST_RV_REF_BEG multiset<Key, C2, Allocator, Options> BOOST_RV_REF_END source)
    {  return this->merge(static_cast<multiset<Key, C2, Allocator, Options>&>(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>: log(size()) + count(k)
+   BOOST_CONTAINER_FORCEINLINE size_type erase(const key_type& x)
+   {  return this->base_t::erase_unique(x);   }
+
    #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Effects</b>: Erases the element pointed to by p.
@@ -691,13 +699,6 @@ class set
    //! <b>Complexity</b>: Amortized constant time
    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>: log(size()) + count(k)
-   size_type erase(const key_type& x);
-
    //! <b>Effects</b>: Erases all the elements in the range [first, last).
    //!
    //! <b>Returns</b>: Returns last.
@@ -771,7 +772,9 @@ class set
    template<typename K>
    const_iterator find(const K& x) const;
 
-   #endif   //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
+   #else
+   using base_t::erase;
+   #endif   //   #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
 
    //! <b>Returns</b>: The number of elements with key equivalent to x.
    //!

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

@@ -47,6 +47,7 @@
 #include <boost/move/detail/fwd_macros.hpp>
 #endif
 #include <boost/move/detail/move_helpers.hpp>
+#include <boost/move/detail/force_ptr.hpp>
 // other
 #include <boost/core/no_exceptions_support.hpp>
 // std
@@ -71,64 +72,9 @@ struct slist_hook
       <dtl::bi::void_pointer<VoidPointer>, dtl::bi::link_mode<dtl::bi::normal_link> >::type type;
 };
 
-
 template <class T, class VoidPointer>
-struct slist_node
-   :  public slist_hook<VoidPointer>::type
+struct iiterator_node_value_type< base_node<T, slist_hook<VoidPointer> > >
 {
-   public:
-   typedef T value_type;
-   typedef T internal_type;
-   typedef typename slist_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 ~slist_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< slist_node<T,VoidPointer> > {
   typedef T type;
 };
 
@@ -141,8 +87,7 @@ struct intrusive_slist_type
       <typename allocator_traits_type::pointer>::template
          rebind_pointer<void>::type
             void_pointer;
-   typedef typename dtl::slist_node
-         <value_type, void_pointer>             node_type;
+   typedef base_node<value_type, slist_hook<void_pointer> > node_type;
 
    typedef typename dtl::bi::make_slist
       <node_type
@@ -213,7 +158,7 @@ class slist
    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;
@@ -248,7 +193,7 @@ class slist
 
    //////////////////////////////////////////////
    //
-   //          construct/copy/destroy
+   //          constructFr/copy/destroy
    //
    //////////////////////////////////////////////
 
@@ -368,11 +313,12 @@ class slist
    slist(BOOST_RV_REF(slist) x, const allocator_type &a)
       : AllocHolder(a)
    {
-      if(this->node_alloc() == x.node_alloc()){
-         this->icont().swap(x.icont());
+      slist & sr = x;
+      if(this->node_alloc() == sr.node_alloc()){
+         this->icont().swap(sr.icont());
       }
       else{
-         this->insert_after(this->cbefore_begin(), boost::make_move_iterator(x.begin()), boost::make_move_iterator(x.end()));
+         this->insert_after(this->cbefore_begin(), boost::make_move_iterator(sr.begin()), boost::make_move_iterator(sr.end()));
       }
    }
 
@@ -424,9 +370,10 @@ class slist
       BOOST_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value
                                   || allocator_traits_type::is_always_equal::value)
    {
-      if (BOOST_LIKELY(this != &x)) {
+      slist & sr = x;
+      if (BOOST_LIKELY(this != &sr)) {
          NodeAlloc &this_alloc = this->node_alloc();
-         NodeAlloc &x_alloc    = x.node_alloc();
+         NodeAlloc &x_alloc    = sr.node_alloc();
          const bool propagate_alloc = allocator_traits_type::
                propagate_on_container_move_assignment::value;
          const bool allocators_equal = this_alloc == x_alloc; (void)allocators_equal;
@@ -436,14 +383,14 @@ class slist
             //Destroy
             this->clear();
             //Move allocator if needed
-            this->AllocHolder::move_assign_alloc(x);
+            this->AllocHolder::move_assign_alloc(sr);
             //Obtain resources
-            this->icont() = boost::move(x.icont());
+            this->icont() = boost::move(sr.icont());
          }
          //Else do a one by one move
          else{
-            this->assign( boost::make_move_iterator(x.begin())
-                        , boost::make_move_iterator(x.end()));
+            this->assign( boost::make_move_iterator(sr.begin())
+                        , boost::make_move_iterator(sr.end()));
          }
       }
       return *this;
@@ -471,7 +418,7 @@ class slist
    //! <b>Complexity</b>: Linear to n.
    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());
    }
 
@@ -709,7 +656,7 @@ class slist
    {
       const_iterator last_pos;
       if(!priv_try_shrink(new_size, last_pos)){
-         typedef value_init_construct_iterator<value_type, difference_type> value_init_iterator;
+         typedef value_init_construct_iterator<value_type> value_init_iterator;
          this->insert_after(last_pos, value_init_iterator(new_size - this->size()), value_init_iterator());
       }
    }
@@ -887,7 +834,7 @@ class slist
    //!   previous values.
    iterator insert_after(const_iterator prev_p, size_type n, const value_type& x)
    {
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->insert_after(prev_p, cvalue_iterator(x, n), cvalue_iterator());
    }
 
@@ -955,7 +902,7 @@ class slist
    {
       //Optimized allocation and construction
       insertion_functor func(this->icont(), prev.get());
-      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 iterator(func.inserted_first());
    }
    #endif
@@ -1066,7 +1013,7 @@ class slist
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of
    //!    this list. Iterators of this list and all the references are not invalidated.
    void splice_after(const_iterator prev_p, BOOST_RV_REF(slist) x) BOOST_NOEXCEPT_OR_NOTHROW
-   {  this->splice_after(prev_p, static_cast<slist&>(x));  }
+   {  this->splice_after(prev_p, BOOST_MOVE_TO_LV(x));  }
 
    //! <b>Requires</b>: prev_p must be a valid iterator of this.
    //!   i must point to an element contained in list x.
@@ -1103,7 +1050,7 @@ class slist
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this
    //!   list. Iterators of this list and all the references are not invalidated.
    void splice_after(const_iterator prev_p, BOOST_RV_REF(slist) x, const_iterator prev) BOOST_NOEXCEPT_OR_NOTHROW
-   {  this->splice_after(prev_p, static_cast<slist&>(x), prev);  }
+   {  this->splice_after(prev_p, BOOST_MOVE_TO_LV(x), prev);  }
 
    //! <b>Requires</b>: prev_p must be a valid iterator of this.
    //!   before_first and before_last must be valid iterators of x.
@@ -1143,7 +1090,7 @@ class slist
    //!   list. Iterators of this list and all the references are not invalidated.
    void splice_after(const_iterator prev_p,      BOOST_RV_REF(slist) x,
       const_iterator before_first,  const_iterator before_last) BOOST_NOEXCEPT_OR_NOTHROW
-   {  this->splice_after(prev_p, static_cast<slist&>(x), before_first, before_last);  }
+   {  this->splice_after(prev_p, BOOST_MOVE_TO_LV(x), before_first, before_last);  }
 
    //! <b>Requires</b>: prev_p must be a valid iterator of this.
    //!   before_first and before_last must be valid iterators of x.
@@ -1187,7 +1134,7 @@ class slist
    void splice_after(const_iterator prev_p,      BOOST_RV_REF(slist) x,
                      const_iterator before_first,  const_iterator before_last,
                      size_type n) BOOST_NOEXCEPT_OR_NOTHROW
-   {  this->splice_after(prev_p, static_cast<slist&>(x), before_first, before_last, n);  }
+   {  this->splice_after(prev_p, BOOST_MOVE_TO_LV(x), before_first, before_last, n);  }
 
    //! <b>Effects</b>: Removes all the elements that compare equal to value.
    //!
@@ -1270,7 +1217,7 @@ class slist
    //! <b>Complexity</b>: This function is linear time: it performs at most
    //!   size() + x.size() - 1 comparisons.
    void merge(BOOST_RV_REF(slist) x)
-   {  this->merge(static_cast<slist&>(x)); }
+   {  this->merge(BOOST_MOVE_TO_LV(x)); }
 
    //! <b>Requires</b>: p must be a comparison function that induces a strict weak
    //!   ordering and both *this and x must be sorted according to that ordering
@@ -1310,7 +1257,7 @@ class slist
    //! <b>Note</b>: Iterators and references to *this are not invalidated.
    template <class StrictWeakOrdering>
    void merge(BOOST_RV_REF(slist) x, StrictWeakOrdering comp)
-   {  this->merge(static_cast<slist&>(x), comp); }
+   {  this->merge(BOOST_MOVE_TO_LV(x), comp); }
 
    //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>.
    //!   The sort is stable, that is, the relative order of equivalent elements is preserved.
@@ -1514,7 +1461,7 @@ class slist
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of
    //!    this list. Iterators of this list and all the references are not invalidated.
    void splice(const_iterator p, BOOST_RV_REF(slist) x) BOOST_NOEXCEPT_OR_NOTHROW
-   {  this->splice(p, static_cast<slist&>(x));  }
+   {  this->splice(p, BOOST_MOVE_TO_LV(x));  }
 
    //! <b>Requires</b>: p must point to an element contained
    //!   by this list. i must point to an element contained in list x.
@@ -1548,7 +1495,7 @@ class slist
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this
    //!   list. Iterators of this list and all the references are not invalidated.
    void splice(const_iterator p, BOOST_RV_REF(slist) x, const_iterator i) BOOST_NOEXCEPT_OR_NOTHROW
-   {  this->splice(p, static_cast<slist&>(x), i);  }
+   {  this->splice(p, BOOST_MOVE_TO_LV(x), i);  }
 
    //! <b>Requires</b>: p must point to an element contained
    //!   by this list. first and last must point to elements contained in list x.
@@ -1582,7 +1529,7 @@ class slist
    //! <b>Note</b>: Iterators of values obtained from list x now point to elements of this
    //!   list. Iterators of this list and all the references are not invalidated.
    void splice(const_iterator p, BOOST_RV_REF(slist) x, const_iterator first, const_iterator last) BOOST_NOEXCEPT_OR_NOTHROW
-   {  this->splice(p, static_cast<slist&>(x), first, last);  }
+   {  this->splice(p, BOOST_MOVE_TO_LV(x), first, last);  }
 
    //! <b>Effects</b>: Returns true if x and y are equal
    //!
@@ -1635,11 +1582,9 @@ class slist
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
 
-   void priv_push_front (const T &x)
-   {  this->insert_after(this->cbefore_begin(), x);  }
-
-   void priv_push_front (BOOST_RV_REF(T) x)
-   {  this->insert_after(this->cbefore_begin(), ::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))); }
 
    bool priv_try_shrink(size_type new_size, const_iterator &last_pos)
    {