passenger 5.3.7 → 6.0.26

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

@@ -37,13 +37,12 @@
 #include <boost/intrusive/detail/simple_disposers.hpp>
 #include <boost/intrusive/detail/size_holder.hpp>
 #include <boost/intrusive/detail/algorithm.hpp>
+#include <boost/intrusive/detail/value_functors.hpp>
+#include <boost/intrusive/detail/node_cloner_disposer.hpp>
 
 #include <boost/move/utility_core.hpp>
-#include <boost/static_assert.hpp>
 
-#include <boost/intrusive/detail/minimal_less_equal_header.hpp>//std::less
 #include <cstddef>   //std::size_t
-#include <boost/intrusive/detail/minimal_pair_header.hpp>   //std::pair
 
 #if defined(BOOST_HAS_PRAGMA_ONCE)
 #  pragma once
@@ -166,62 +165,60 @@ class slist_impl
    static const bool safemode_or_autounlink = is_safe_autounlink<value_traits::link_mode>::value;
 
    //Constant-time size is incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(constant_time_size && ((int)value_traits::link_mode == (int)auto_unlink)));
    //Linear singly linked lists are incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(linear && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(linear && ((int)value_traits::link_mode == (int)auto_unlink)));
    //A list with cached last node is incompatible with auto-unlink hooks!
-   BOOST_STATIC_ASSERT(!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink)));
+   BOOST_INTRUSIVE_STATIC_ASSERT(!(cache_last && ((int)value_traits::link_mode == (int)auto_unlink)));
 
-   node_ptr get_end_node()
-   {  return node_ptr(linear ? node_ptr() : this->get_root_node());  }
+   inline node_ptr get_end_node()
+   {  return node_algorithms::end_node(this->get_root_node());  }
 
-   const_node_ptr get_end_node() const
-   {
-      return const_node_ptr
-         (linear ? const_node_ptr() : this->get_root_node());  }
+   inline const_node_ptr get_end_node() const
+   {  return node_algorithms::end_node(this->get_root_node());  }
 
-   node_ptr get_root_node()
+   inline node_ptr get_root_node()
    { return data_.root_plus_size_.header_holder_.get_node(); }
 
-   const_node_ptr get_root_node() const
+   inline const_node_ptr get_root_node() const
    { return data_.root_plus_size_.header_holder_.get_node(); }
 
-   node_ptr get_last_node()
+   inline node_ptr get_last_node()
    {  return this->get_last_node(detail::bool_<cache_last>());  }
 
-   const_node_ptr get_last_node() const
+   inline const_node_ptr get_last_node() const
    {  return this->get_last_node(detail::bool_<cache_last>());  }
 
-   void set_last_node(const node_ptr &n)
+   inline void set_last_node(node_ptr n)
    {  return this->set_last_node(n, detail::bool_<cache_last>());  }
 
-   static node_ptr get_last_node(detail::bool_<false>)
+   inline static node_ptr get_last_node(detail::bool_<false>)
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
       return node_ptr();
    }
 
-   static void set_last_node(const node_ptr &, detail::bool_<false>)
+   inline static void set_last_node(node_ptr , detail::bool_<false>)
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
    }
 
-   node_ptr get_last_node(detail::bool_<true>)
+   inline node_ptr get_last_node(detail::bool_<true>)
    {  return node_ptr(data_.root_plus_size_.last_);  }
 
-   const_node_ptr get_last_node(detail::bool_<true>) const
+   inline const_node_ptr get_last_node(detail::bool_<true>) const
    {  return const_node_ptr(data_.root_plus_size_.last_);  }
 
-   void set_last_node(const node_ptr & n, detail::bool_<true>)
+   inline void set_last_node(node_ptr n, detail::bool_<true>)
    {  data_.root_plus_size_.last_ = n;  }
 
    void set_default_constructed_state()
    {
       node_algorithms::init_header(this->get_root_node());
       this->priv_size_traits().set_size(size_type(0));
-      if(cache_last){
+      BOOST_IF_CONSTEXPR(cache_last){
          this->set_last_node(this->get_root_node());
       }
    }
@@ -233,7 +230,7 @@ class slist_impl
    {};
 
    struct data_t
-      :  public slist_impl::value_traits
+      :  public value_traits
    {
       typedef typename slist_impl::value_traits value_traits;
       explicit data_t(const value_traits &val_traits)
@@ -243,22 +240,22 @@ class slist_impl
       root_plus_size root_plus_size_;
    } data_;
 
-   size_traits &priv_size_traits()
+   inline size_traits &priv_size_traits()
    {  return data_.root_plus_size_;  }
 
-   const size_traits &priv_size_traits() const
+   inline const size_traits &priv_size_traits() const
    {  return data_.root_plus_size_;  }
 
-   const value_traits &priv_value_traits() const
+   inline const value_traits &priv_value_traits() const
    {  return data_;  }
 
-   value_traits &priv_value_traits()
+   inline value_traits &priv_value_traits()
    {  return data_;  }
 
    typedef typename boost::intrusive::value_traits_pointers
       <ValueTraits>::const_value_traits_ptr const_value_traits_ptr;
 
-   const_value_traits_ptr priv_value_traits_ptr() const
+   inline const_value_traits_ptr priv_value_traits_ptr() const
    {  return pointer_traits<const_value_traits_ptr>::pointer_to(this->priv_value_traits());  }
 
    /// @endcond
@@ -282,13 +279,13 @@ class slist_impl
    //!   list. Iterators of this list and all the references are not invalidated.
    //!
    //! <b>Warning</b>: Experimental function, don't use it!
-   slist_impl( const node_ptr & f, const node_ptr & before_l
+   slist_impl( node_ptr f, node_ptr before_l
              , size_type n, const value_traits &v_traits = value_traits())
       :  data_(v_traits)
    {
       if(n){
          this->priv_size_traits().set_size(n);
-         if(cache_last){
+         BOOST_IF_CONSTEXPR(cache_last){
             this->set_last_node(before_l);
          }
          node_traits::set_next(this->get_root_node(), f);
@@ -371,7 +368,7 @@ class slist_impl
    //!   it's a safe-mode or auto-unlink value. Otherwise constant.
    ~slist_impl()
    {
-      if(is_safe_autounlink<ValueTraits::link_mode>::value){
+      BOOST_IF_CONSTEXPR(is_safe_autounlink<ValueTraits::link_mode>::value){
          this->clear();
          node_algorithms::init(this->get_root_node());
       }
@@ -385,9 +382,9 @@ class slist_impl
    //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the erased elements.
-   void clear()
+   void clear() BOOST_NOEXCEPT
    {
-      if(safemode_or_autounlink){
+      BOOST_IF_CONSTEXPR(safemode_or_autounlink){
          this->clear_and_dispose(detail::null_disposer());
       }
       else{
@@ -406,16 +403,12 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators to the erased elements.
    template <class Disposer>
-   void clear_and_dispose(Disposer disposer)
+   void clear_and_dispose(Disposer disposer) BOOST_NOEXCEPT
    {
-      const_iterator it(this->begin()), itend(this->end());
-      while(it != itend){
-         node_ptr to_erase(it.pointed_node());
-         ++it;
-         if(safemode_or_autounlink)
-            node_algorithms::init(to_erase);
-         disposer(priv_value_traits().to_value_ptr(to_erase));
-      }
+      node_algorithms::detach_and_dispose
+         ( this->get_root_node()
+         , detail::node_disposer<Disposer, value_traits, CommonSListAlgorithms>
+               (disposer, &this->priv_value_traits()) );
       this->set_default_constructed_state();
    }
 
@@ -429,11 +422,11 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   void push_front(reference value)
+   void push_front(reference value) BOOST_NOEXCEPT
    {
       node_ptr to_insert = priv_value_traits().to_node_ptr(value);
       BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(to_insert));
-      if(cache_last){
+      BOOST_IF_CONSTEXPR(cache_last){
          if(this->empty()){
             this->set_last_node(to_insert);
          }
@@ -453,13 +446,13 @@ class slist_impl
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
    //!   This function is only available is cache_last<> is true.
-   void push_back(reference value)
+   void push_back(reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((cache_last));
+      BOOST_INTRUSIVE_STATIC_ASSERT((cache_last));
       node_ptr n = priv_value_traits().to_node_ptr(value);
       BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
       node_algorithms::link_after(this->get_last_node(), n);
-      if(cache_last){
+      BOOST_IF_CONSTEXPR(cache_last){
          this->set_last_node(n);
       }
       this->priv_size_traits().increment();
@@ -473,7 +466,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the erased element.
-   void pop_front()
+   void pop_front() BOOST_NOEXCEPT
    {  return this->pop_front_and_dispose(detail::null_disposer());   }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
@@ -487,15 +480,15 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators to the erased element.
    template<class Disposer>
-   void pop_front_and_dispose(Disposer disposer)
+   void pop_front_and_dispose(Disposer disposer) BOOST_NOEXCEPT
    {
       node_ptr to_erase = node_traits::get_next(this->get_root_node());
       node_algorithms::unlink_after(this->get_root_node());
       this->priv_size_traits().decrement();
-      if(safemode_or_autounlink)
+      BOOST_IF_CONSTEXPR(safemode_or_autounlink)
          node_algorithms::init(to_erase);
       disposer(priv_value_traits().to_value_ptr(to_erase));
-      if(cache_last){
+      BOOST_IF_CONSTEXPR(cache_last){
          if(this->empty()){
             this->set_last_node(this->get_root_node());
          }
@@ -507,7 +500,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   reference front()
+   inline reference front() BOOST_NOEXCEPT
    { return *this->priv_value_traits().to_value_ptr(node_traits::get_next(this->get_root_node())); }
 
    //! <b>Effects</b>: Returns a const_reference to the first element of the list.
@@ -515,7 +508,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_reference front() const
+   inline const_reference front() const BOOST_NOEXCEPT
    { return *this->priv_value_traits().to_value_ptr(detail::uncast(node_traits::get_next(this->get_root_node()))); }
 
    //! <b>Effects</b>: Returns a reference to the last element of the list.
@@ -526,9 +519,9 @@ class slist_impl
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
    //!   This function is only available is cache_last<> is true.
-   reference back()
+   reference back() BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((cache_last));
+      BOOST_INTRUSIVE_STATIC_ASSERT((cache_last));
       return *this->priv_value_traits().to_value_ptr(this->get_last_node());
    }
 
@@ -540,9 +533,9 @@ class slist_impl
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
    //!   This function is only available is cache_last<> is true.
-   const_reference back() const
+   inline const_reference back() const BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((cache_last));
+      BOOST_INTRUSIVE_STATIC_ASSERT((cache_last));
       return *this->priv_value_traits().to_value_ptr(this->get_last_node());
    }
 
@@ -551,7 +544,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   iterator begin()
+   inline iterator begin() BOOST_NOEXCEPT
    { return iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@@ -559,7 +552,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator begin() const
+   inline const_iterator begin() const BOOST_NOEXCEPT
    { return const_iterator (node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the first element contained in the list.
@@ -567,7 +560,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbegin() const
+   inline const_iterator cbegin() const BOOST_NOEXCEPT
    { return const_iterator(node_traits::get_next(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator to the end of the list.
@@ -575,7 +568,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   iterator end()
+   inline iterator end() BOOST_NOEXCEPT
    { return iterator(this->get_end_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@@ -583,7 +576,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator end() const
+   inline const_iterator end() const BOOST_NOEXCEPT
    { return const_iterator(detail::uncast(this->get_end_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns a const_iterator to the end of the list.
@@ -591,7 +584,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cend() const
+   inline const_iterator cend() const BOOST_NOEXCEPT
    { return this->end(); }
 
    //! <b>Effects</b>: Returns an iterator that points to a position
@@ -600,7 +593,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   iterator before_begin()
+   inline iterator before_begin() BOOST_NOEXCEPT
    { return iterator(this->get_root_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator that points to a position
@@ -609,7 +602,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator before_begin() const
+   inline const_iterator before_begin() const BOOST_NOEXCEPT
    { return const_iterator(detail::uncast(this->get_root_node()), this->priv_value_traits_ptr()); }
 
    //! <b>Effects</b>: Returns an iterator that points to a position
@@ -618,7 +611,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   const_iterator cbefore_begin() const
+   inline const_iterator cbefore_begin() const BOOST_NOEXCEPT
    { return this->before_begin(); }
 
    //! <b>Effects</b>: Returns an iterator to the last element contained in the list.
@@ -628,7 +621,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: This function is present only if cached_last<> option is true.
-   iterator last()
+   inline iterator last() BOOST_NOEXCEPT
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
@@ -642,7 +635,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: This function is present only if cached_last<> option is true.
-   const_iterator last() const
+   inline const_iterator last() const BOOST_NOEXCEPT
    {
       //This function shall not be used if cache_last is not true
       BOOST_INTRUSIVE_INVARIANT_ASSERT(cache_last);
@@ -656,7 +649,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: This function is present only if cached_last<> option is true.
-   const_iterator clast() const
+   inline const_iterator clast() const BOOST_NOEXCEPT
    { return const_iterator(this->get_last_node(), this->priv_value_traits_ptr()); }
 
    //! <b>Precondition</b>: end_iterator must be a valid end iterator
@@ -667,7 +660,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   static slist_impl &container_from_end_iterator(iterator end_iterator)
+   inline static slist_impl &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return slist_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Precondition</b>: end_iterator must be a valid end const_iterator
@@ -678,7 +671,7 @@ class slist_impl
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Constant.
-   static const slist_impl &container_from_end_iterator(const_iterator end_iterator)
+   inline static const slist_impl &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return slist_impl::priv_container_from_end_iterator(end_iterator);   }
 
    //! <b>Effects</b>: Returns the number of the elements contained in the list.
@@ -689,9 +682,9 @@ class slist_impl
    //!   if constant_time_size is false. Constant time otherwise.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   size_type size() const
+   inline size_type size() const BOOST_NOEXCEPT
    {
-      if(constant_time_size)
+      BOOST_IF_CONSTEXPR(constant_time_size)
          return this->priv_size_traits().get_size();
       else
          return node_algorithms::count(this->get_root_node()) - 1;
@@ -704,8 +697,8 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   bool empty() const
-   { return node_algorithms::unique(this->get_root_node()); }
+   inline bool empty() const BOOST_NOEXCEPT
+   {  return node_algorithms::is_empty(this->get_root_node()); }
 
    //! <b>Effects</b>: Swaps the elements of x and *this.
    //!
@@ -717,7 +710,7 @@ class slist_impl
    //! <b>Note</b>: Does not affect the validity of iterators and references.
    void swap(slist_impl& other)
    {
-      if(cache_last){
+      BOOST_IF_CONSTEXPR(cache_last){
          priv_swap_cache_last(this, &other);
       }
       else{
@@ -735,7 +728,7 @@ class slist_impl
    //! <b>Complexity</b>: Linear to the number of elements plus the number shifts.
    //!
    //! <b>Note</b>: Iterators Does not affect the validity of iterators and references.
-   void shift_backwards(size_type n = 1)
+   void shift_backwards(size_type n = 1) BOOST_NOEXCEPT
    {  this->priv_shift_backwards(n, detail::bool_<linear>());  }
 
    //! <b>Effects</b>: Moves forward all the elements, so that the second
@@ -747,7 +740,7 @@ class slist_impl
    //! <b>Complexity</b>: Linear to the number of elements plus the number shifts.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   void shift_forward(size_type n = 1)
+   void shift_forward(size_type n = 1) BOOST_NOEXCEPT
    {  this->priv_shift_forward(n, detail::bool_<linear>()); }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
@@ -819,7 +812,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   iterator insert_after(const_iterator prev_p, reference value)
+   iterator insert_after(const_iterator prev_p, reference value) BOOST_NOEXCEPT
    {
       node_ptr n = priv_value_traits().to_node_ptr(value);
       BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
@@ -845,7 +838,7 @@ class slist_impl
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
    template<class Iterator>
-   void insert_after(const_iterator prev_p, Iterator f, Iterator l)
+   void insert_after(const_iterator prev_p, Iterator f, Iterator l) BOOST_NOEXCEPT
    {
       //Insert first nodes avoiding cache and size checks
       size_type count = 0;
@@ -860,7 +853,7 @@ class slist_impl
       if(cache_last && (this->get_last_node() == prev_p.pointed_node())){
          this->set_last_node(prev_n);
       }
-      if(constant_time_size){
+      BOOST_IF_CONSTEXPR(constant_time_size){
          this->priv_size_traits().increase(count);
       }
    }
@@ -877,7 +870,7 @@ class slist_impl
    //!  Constant-time if cache_last<> is true and p == end().
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   iterator insert(const_iterator p, reference value)
+   iterator insert(const_iterator p, reference value) BOOST_NOEXCEPT
    {  return this->insert_after(this->previous(p), value);  }
 
    //! <b>Requires</b>: Dereferencing iterator must yield
@@ -895,7 +888,7 @@ class slist_impl
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
    template<class Iterator>
-   void insert(const_iterator p, Iterator b, Iterator e)
+   void insert(const_iterator p, Iterator b, Iterator e) BOOST_NOEXCEPT
    {  return this->insert_after(this->previous(p), b, e);  }
 
    //! <b>Effects</b>: Erases the element after the element pointed by prev of
@@ -910,7 +903,7 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased element.
-   iterator erase_after(const_iterator prev)
+   iterator erase_after(const_iterator prev) BOOST_NOEXCEPT
    {  return this->erase_after_and_dispose(prev, detail::null_disposer());  }
 
    //! <b>Effects</b>: Erases the range (before_f, l) from
@@ -926,15 +919,15 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased element.
-   iterator erase_after(const_iterator before_f, const_iterator l)
+   iterator erase_after(const_iterator before_f, const_iterator l) BOOST_NOEXCEPT
    {
-      if(safemode_or_autounlink || constant_time_size){
+      BOOST_IF_CONSTEXPR(safemode_or_autounlink || constant_time_size){
          return this->erase_after_and_dispose(before_f, l, detail::null_disposer());
       }
       else{
          const node_ptr bfp = before_f.pointed_node();
          const node_ptr lp = l.pointed_node();
-         if(cache_last){
+         BOOST_IF_CONSTEXPR(cache_last){
             if(lp == this->get_end_node()){
                this->set_last_node(bfp);
             }
@@ -958,22 +951,23 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased element.
-   iterator erase_after(const_iterator before_f, const_iterator l, size_type n)
+   iterator erase_after(const_iterator before_f, const_iterator l, size_type n) BOOST_NOEXCEPT
    {
       BOOST_INTRUSIVE_INVARIANT_ASSERT(node_algorithms::distance((++const_iterator(before_f)).pointed_node(), l.pointed_node()) == n);
-      if(safemode_or_autounlink){
+      (void)n;
+      BOOST_IF_CONSTEXPR(safemode_or_autounlink){
          return this->erase_after(before_f, l);
       }
       else{
          const node_ptr bfp = before_f.pointed_node();
          const node_ptr lp = l.pointed_node();
-         if(cache_last){
+         BOOST_IF_CONSTEXPR(cache_last){
             if((lp == this->get_end_node())){
                this->set_last_node(bfp);
             }
          }
          node_algorithms::unlink_after(bfp, lp);
-         if(constant_time_size){
+         BOOST_IF_CONSTEXPR(constant_time_size){
             this->priv_size_traits().decrease(n);
          }
          return l.unconst();
@@ -992,7 +986,7 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased element.
-   iterator erase(const_iterator i)
+   iterator erase(const_iterator i) BOOST_NOEXCEPT
    {  return this->erase_after(this->previous(i));  }
 
    //! <b>Requires</b>: f and l must be valid iterator to elements in *this.
@@ -1009,7 +1003,7 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased elements.
-   iterator erase(const_iterator f, const_iterator l)
+   iterator erase(const_iterator f, const_iterator l) BOOST_NOEXCEPT
    {  return this->erase_after(this->previous(f), l);  }
 
    //! <b>Effects</b>: Erases the range [f, l) from
@@ -1026,7 +1020,7 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased element.
-   iterator erase(const_iterator f, const_iterator l, size_type n)
+   iterator erase(const_iterator f, const_iterator l, size_type n) BOOST_NOEXCEPT
    {  return this->erase_after(this->previous(f), l, n);  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
@@ -1044,7 +1038,7 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators to the erased element.
    template<class Disposer>
-   iterator erase_after_and_dispose(const_iterator prev, Disposer disposer)
+   iterator erase_after_and_dispose(const_iterator prev, Disposer disposer) BOOST_NOEXCEPT
    {
       const_iterator it(prev);
       ++it;
@@ -1055,7 +1049,7 @@ class slist_impl
       if(cache_last && (to_erase == this->get_last_node())){
          this->set_last_node(prev_n);
       }
-      if(safemode_or_autounlink)
+      BOOST_IF_CONSTEXPR(safemode_or_autounlink)
          node_algorithms::init(to_erase);
       disposer(priv_value_traits().to_value_ptr(to_erase));
       this->priv_size_traits().decrement();
@@ -1064,9 +1058,9 @@ class slist_impl
 
    /// @cond
 
-   static iterator s_insert_after(const_iterator const prev_p, reference value)
+   static iterator s_insert_after(const_iterator const prev_p, reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
+      BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
       node_ptr const n = value_traits::to_node_ptr(value);
       BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(!safemode_or_autounlink || node_algorithms::inited(n));
       node_algorithms::link_after(prev_p.pointed_node(), n);
@@ -1074,39 +1068,39 @@ class slist_impl
    }
 
    template<class Disposer>
-   static iterator s_erase_after_and_dispose(const_iterator prev, Disposer disposer)
+   static iterator s_erase_after_and_dispose(const_iterator prev, Disposer disposer) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
+      BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
       const_iterator it(prev);
       ++it;
       node_ptr to_erase(it.pointed_node());
       ++it;
       node_ptr prev_n(prev.pointed_node());
       node_algorithms::unlink_after(prev_n);
-      if(safemode_or_autounlink)
+      BOOST_IF_CONSTEXPR(safemode_or_autounlink)
          node_algorithms::init(to_erase);
       disposer(value_traits::to_value_ptr(to_erase));
       return it.unconst();
    }
 
    template<class Disposer>
-   static iterator s_erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer)
+   static iterator s_erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
+      BOOST_INTRUSIVE_STATIC_ASSERT(((!cache_last)&&(!constant_time_size)&&(!stateful_value_traits)));
       node_ptr bfp(before_f.pointed_node()), lp(l.pointed_node());
       node_ptr fp(node_traits::get_next(bfp));
       node_algorithms::unlink_after(bfp, lp);
       while(fp != lp){
          node_ptr to_erase(fp);
          fp = node_traits::get_next(fp);
-         if(safemode_or_autounlink)
+         BOOST_IF_CONSTEXPR(safemode_or_autounlink)
             node_algorithms::init(to_erase);
          disposer(value_traits::to_value_ptr(to_erase));
       }
       return l.unconst();
    }
 
-   static iterator s_erase_after(const_iterator prev)
+   static iterator s_erase_after(const_iterator prev) BOOST_NOEXCEPT
    {  return s_erase_after_and_dispose(prev, detail::null_disposer());  }
 
    /// @endcond
@@ -1126,7 +1120,7 @@ class slist_impl
    //!
    //! <b>Note</b>: Invalidates the iterators to the erased element.
    template<class Disposer>
-   iterator erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer)
+   iterator erase_after_and_dispose(const_iterator before_f, const_iterator l, Disposer disposer) BOOST_NOEXCEPT
    {
       node_ptr bfp(before_f.pointed_node()), lp(l.pointed_node());
       node_ptr fp(node_traits::get_next(bfp));
@@ -1134,7 +1128,7 @@ class slist_impl
       while(fp != lp){
          node_ptr to_erase(fp);
          fp = node_traits::get_next(fp);
-         if(safemode_or_autounlink)
+         BOOST_IF_CONSTEXPR(safemode_or_autounlink)
             node_algorithms::init(to_erase);
          disposer(priv_value_traits().to_value_ptr(to_erase));
          this->priv_size_traits().decrement();
@@ -1161,12 +1155,12 @@ class slist_impl
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased element.
    template<class Disposer>
-   iterator erase_and_dispose(const_iterator i, Disposer disposer)
+   iterator erase_and_dispose(const_iterator i, Disposer disposer) BOOST_NOEXCEPT
    {  return this->erase_after_and_dispose(this->previous(i), disposer);  }
 
    #if !defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
    template<class Disposer>
-   iterator erase_and_dispose(iterator i, Disposer disposer)
+   iterator erase_and_dispose(iterator i, Disposer disposer) BOOST_NOEXCEPT
    {  return this->erase_and_dispose(const_iterator(i), disposer);   }
    #endif
 
@@ -1188,7 +1182,7 @@ class slist_impl
    //! <b>Note</b>: Invalidates the iterators (but not the references) to the
    //!   erased elements.
    template<class Disposer>
-   iterator erase_and_dispose(const_iterator f, const_iterator l, Disposer disposer)
+   iterator erase_and_dispose(const_iterator f, const_iterator l, Disposer disposer) BOOST_NOEXCEPT
    {  return this->erase_after_and_dispose(this->previous(f), l, disposer);  }
 
    //! <b>Requires</b>: Dereferencing iterator must yield
@@ -1257,7 +1251,7 @@ class slist_impl
    //!   assigned to the last spliced element or prev if x is empty.
    //!   This iterator can be used as new "prev" iterator for a new splice_after call.
    //!   that will splice new values after the previously spliced values.
-   void splice_after(const_iterator prev, slist_impl &x, const_iterator *l = 0)
+   void splice_after(const_iterator prev, slist_impl &x, const_iterator *l = 0) BOOST_NOEXCEPT
    {
       if(x.empty()){
          if(l) *l = prev;
@@ -1270,7 +1264,7 @@ class slist_impl
          const_iterator last_x(x.previous(x.end()));  //constant time if cache_last is active
          node_ptr prev_n(prev.pointed_node());
          node_ptr last_x_n(last_x.pointed_node());
-         if(cache_last){
+         BOOST_IF_CONSTEXPR(cache_last){
             x.set_last_node(x.get_root_node());
             if(node_traits::get_next(prev_n) == this->get_end_node()){
                this->set_last_node(last_x_n);
@@ -1296,7 +1290,7 @@ class slist_impl
    //!
    //! <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_pos, slist_impl &x, const_iterator prev_ele)
+   void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator prev_ele) BOOST_NOEXCEPT
    {
       const_iterator elem = prev_ele;
       this->splice_after(prev_pos, x, prev_ele, ++elem, 1);
@@ -1317,9 +1311,9 @@ class slist_impl
    //!
    //! <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_pos, slist_impl &x, const_iterator before_f, const_iterator before_l)
+   void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_f, const_iterator before_l) BOOST_NOEXCEPT
    {
-      if(constant_time_size)
+      BOOST_IF_CONSTEXPR(constant_time_size)
          this->splice_after(prev_pos, x, before_f, before_l, node_algorithms::distance(before_f.pointed_node(), before_l.pointed_node()));
       else
          this->priv_splice_after
@@ -1340,12 +1334,13 @@ class slist_impl
    //!
    //! <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_pos, slist_impl &x, const_iterator before_f, const_iterator before_l, size_type n)
+   void splice_after(const_iterator prev_pos, slist_impl &x, const_iterator before_f, const_iterator before_l, size_type n) BOOST_NOEXCEPT
    {
       BOOST_INTRUSIVE_INVARIANT_ASSERT(node_algorithms::distance(before_f.pointed_node(), before_l.pointed_node()) == n);
+      (void)n;
       this->priv_splice_after
          (prev_pos.pointed_node(), x, before_f.pointed_node(), before_l.pointed_node());
-      if(constant_time_size){
+      BOOST_IF_CONSTEXPR(constant_time_size){
          this->priv_size_traits().increase(n);
          x.priv_size_traits().decrease(n);
       }
@@ -1372,7 +1367,7 @@ class slist_impl
    //!   assigned to the last spliced element or prev if x is empty.
    //!   This iterator can be used as new "prev" iterator for a new splice_after call.
    //!   that will splice new values after the previously spliced values.
-   void splice(const_iterator it, slist_impl &x, const_iterator *l = 0)
+   void splice(const_iterator it, slist_impl &x, const_iterator *l = 0) BOOST_NOEXCEPT
    {  this->splice_after(this->previous(it), x, l);   }
 
    //! <b>Requires</b>: it p must be a valid iterator of *this.
@@ -1389,7 +1384,7 @@ class slist_impl
    //!
    //! <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 pos, slist_impl &x, const_iterator elem)
+   void splice(const_iterator pos, slist_impl &x, const_iterator elem) BOOST_NOEXCEPT
    {  return this->splice_after(this->previous(pos), x, x.previous(elem));  }
 
    //! <b>Requires</b>: pos must be a dereferenceable iterator in *this
@@ -1409,7 +1404,7 @@ class slist_impl
    //!
    //! <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 pos, slist_impl &x, const_iterator f, const_iterator l)
+   void splice(const_iterator pos, slist_impl &x, const_iterator f, const_iterator l) BOOST_NOEXCEPT
    {  return this->splice_after(this->previous(pos), x, x.previous(f), x.previous(l));  }
 
    //! <b>Requires</b>: pos must be a dereferenceable iterator in *this
@@ -1428,10 +1423,10 @@ class slist_impl
    //!
    //! <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 pos, slist_impl &x, const_iterator f, const_iterator l, size_type n)
+   void splice(const_iterator pos, slist_impl &x, const_iterator f, const_iterator l, size_type n) BOOST_NOEXCEPT
    {  return this->splice_after(this->previous(pos), x, x.previous(f), x.previous(l), n);  }
 
-   //! <b>Effects</b>: This function sorts the list *this according to std::less<value_type>.
+   //! <b>Effects</b>: This function sorts the list *this according to operator<.
    //!   The sort is stable, that is, the relative order of equivalent elements is preserved.
    //!
    //! <b>Throws</b>: If value_traits::node_traits::node
@@ -1463,7 +1458,7 @@ class slist_impl
             BOOST_INTRUSIVE_INVARIANT_ASSERT(counter[i].empty());
             const_iterator last_element(carry.previous(last_inserted, carry.end()));
 
-            if(constant_time_size){
+            BOOST_IF_CONSTEXPR(constant_time_size){
                counter[i].splice_after( counter[i].cbefore_begin(), carry
                                     , carry.cbefore_begin(), last_element
                                     , carry.size());
@@ -1480,7 +1475,7 @@ class slist_impl
             counter[i].merge(counter[i-1], p, &last_inserted);
          --fill;
          const_iterator last_element(counter[fill].previous(last_inserted, counter[fill].end()));
-         if(constant_time_size){
+         BOOST_IF_CONSTEXPR(constant_time_size){
             this->splice_after( cbefore_begin(), counter[fill], counter[fill].cbefore_begin()
                               , last_element, counter[fill].size());
          }
@@ -1501,14 +1496,14 @@ class slist_impl
    //!
    //! <b>Throws</b>: If value_traits::node_traits::node
    //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
-   //!   or std::less<value_type> throws. Basic guarantee.
+   //!   or operator< throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: This function is linear time: it performs at most
    //!   size() + x.size() - 1 comparisons.
    //!
    //! <b>Note</b>: Iterators and references are not invalidated.
    void sort()
-   { this->sort(std::less<value_type>()); }
+   { this->sort(value_less<value_type>()); }
 
    //! <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
@@ -1557,18 +1552,18 @@ class slist_impl
    }
 
    //! <b>Effects</b>: This function removes all of x's elements and inserts them
-   //!   in order into *this according to std::less<value_type>. The merge is stable;
+   //!   in order into *this according to operator<. The merge is stable;
    //!   that is, if an element from *this is equivalent to one from x, then the element
    //!   from *this will precede the one from x.
    //!
-   //! <b>Throws</b>: if std::less<value_type> throws. Basic guarantee.
+   //! <b>Throws</b>: if operator< throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: This function is linear time: it performs at most
    //!   size() + x.size() - 1 comparisons.
    //!
    //! <b>Note</b>: Iterators and references are not invalidated
    void merge(slist_impl& x)
-   {  this->merge(x, std::less<value_type>());  }
+   {  this->merge(x, value_less<value_type>());  }
 
    //! <b>Effects</b>: Reverses the order of elements in the list.
    //!
@@ -1577,7 +1572,7 @@ class slist_impl
    //! <b>Complexity</b>: This function is linear to the contained elements.
    //!
    //! <b>Note</b>: Iterators and references are not invalidated
-   void reverse()
+   void reverse() BOOST_NOEXCEPT
    {
       if(cache_last && !this->empty()){
          this->set_last_node(node_traits::get_next(this->get_root_node()));
@@ -1588,14 +1583,14 @@ class slist_impl
    //! <b>Effects</b>: Removes all the elements that compare equal to value.
    //!   No destructors are called.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee.
+   //! <b>Throws</b>: If operator== throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality.
    //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid. This function is
    //!   linear time: it performs exactly size() comparisons for equality.
-   void remove(const_reference value)
+   void remove(const_reference value) BOOST_NOEXCEPT
    {  this->remove_if(detail::equal_to_value<const_reference>(value));  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
@@ -1603,14 +1598,14 @@ class slist_impl
    //! <b>Effects</b>: Removes all the elements that compare equal to value.
    //!   Disposer::operator()(pointer) is called for every removed element.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee.
+   //! <b>Throws</b>: If operator== throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time. It performs exactly size() comparisons for equality.
    //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
-   void remove_and_dispose(const_reference value, Disposer disposer)
+   void remove_and_dispose(const_reference value, Disposer disposer) BOOST_NOEXCEPT
    {  this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer);  }
 
    //! <b>Effects</b>: Removes all the elements for which a specified
@@ -1630,7 +1625,7 @@ class slist_impl
       node_algorithms::stable_partition
          (bbeg, this->get_end_node(), detail::key_nodeptr_comp<Pred, value_traits>(pred, &this->priv_value_traits()), info);
       //After cache last is set, slist invariants are preserved...
-      if(cache_last){
+      BOOST_IF_CONSTEXPR(cache_last){
          this->set_last_node(info.new_last_node);
       }
       //...so erase can be safely called
@@ -1659,7 +1654,7 @@ class slist_impl
       node_algorithms::stable_partition
          (bbeg, this->get_end_node(), detail::key_nodeptr_comp<Pred, value_traits>(pred, &this->priv_value_traits()), info);
       //After cache last is set, slist invariants are preserved...
-      if(cache_last){
+      BOOST_IF_CONSTEXPR(cache_last){
          this->set_last_node(info.new_last_node);
       }
       //...so erase can be safely called
@@ -1671,14 +1666,14 @@ class slist_impl
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that are equal from the list. No destructors are called.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee.
+   //! <b>Throws</b>: If operator== throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1) comparisons calls to pred()).
    //!
    //! <b>Note</b>: The relative order of elements that are not removed is unchanged,
    //!   and iterators to elements that are not removed remain valid.
    void unique()
-   {  this->unique_and_dispose(std::equal_to<value_type>(), detail::null_disposer());  }
+   {  this->unique_and_dispose(value_equal<value_type>(), detail::null_disposer());  }
 
    //! <b>Effects</b>: Removes adjacent duplicate elements or adjacent
    //!   elements that satisfy some binary predicate from the list.
@@ -1700,7 +1695,7 @@ class slist_impl
    //!   elements that satisfy some binary predicate from the list.
    //!   Disposer::operator()(pointer) is called for every removed element.
    //!
-   //! <b>Throws</b>: If std::equal_to<value_type> throws. Basic guarantee.
+   //! <b>Throws</b>: If operator== throws. Basic guarantee.
    //!
    //! <b>Complexity</b>: Linear time (size()-1) comparisons equality comparisons.
    //!
@@ -1708,7 +1703,7 @@ class slist_impl
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
    void unique_and_dispose(Disposer disposer)
-   {  this->unique(std::equal_to<value_type>(), disposer);  }
+   {  this->unique(value_equal<value_type>(), disposer);  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1739,7 +1734,7 @@ class slist_impl
                ++cur;
             }
          }
-         if(cache_last){
+         BOOST_IF_CONSTEXPR(cache_last){
             this->set_last_node(bcur.pointed_node());
          }
       }
@@ -1756,9 +1751,9 @@ class slist_impl
    //! <b>Note</b>: Iterators and references are not invalidated.
    //!   This static function is available only if the <i>value traits</i>
    //!   is stateless.
-   static iterator s_iterator_to(reference value)
+   static iterator s_iterator_to(reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       return iterator (value_traits::to_node_ptr(value), const_value_traits_ptr());
    }
 
@@ -1773,9 +1768,9 @@ class slist_impl
    //! <b>Note</b>: Iterators and references are not invalidated.
    //!   This static function is available only if the <i>value traits</i>
    //!   is stateless.
-   static const_iterator s_iterator_to(const_reference value)
+   static const_iterator s_iterator_to(const_reference value) BOOST_NOEXCEPT
    {
-      BOOST_STATIC_ASSERT((!stateful_value_traits));
+      BOOST_INTRUSIVE_STATIC_ASSERT((!stateful_value_traits));
       reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value));
       return const_iterator(value_traits::to_node_ptr(r), const_value_traits_ptr());
    }
@@ -1789,7 +1784,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Note</b>: Iterators and references are not invalidated.
-   iterator iterator_to(reference value)
+   iterator iterator_to(reference value) BOOST_NOEXCEPT
    {
       BOOST_INTRUSIVE_INVARIANT_ASSERT(linear || !node_algorithms::inited(this->priv_value_traits().to_node_ptr(value)));
       return iterator (this->priv_value_traits().to_node_ptr(value), this->priv_value_traits_ptr());
@@ -1804,7 +1799,7 @@ class slist_impl
    //! <b>Complexity</b>: Constant time.
    //!
    //! <b>Note</b>: Iterators and references are not invalidated.
-   const_iterator iterator_to(const_reference value) const
+   const_iterator iterator_to(const_reference value) const BOOST_NOEXCEPT
    {
       reference r =*detail::uncast(pointer_traits<const_pointer>::pointer_to(value));
       BOOST_INTRUSIVE_INVARIANT_ASSERT (linear || !node_algorithms::inited(this->priv_value_traits().to_node_ptr(r)));
@@ -1819,7 +1814,7 @@ class slist_impl
    //!
    //! <b>Complexity</b>: Linear to the number of elements before i.
    //!   Constant if cache_last<> is true and i == end().
-   iterator previous(iterator i)
+   iterator previous(iterator i) BOOST_NOEXCEPT
    {  return this->previous(this->cbefore_begin(), i); }
 
    //! <b>Returns</b>: The const_iterator to the element before i in the list.
@@ -1830,7 +1825,7 @@ class slist_impl
    //!
    //! <b>Complexity</b>: Linear to the number of elements before i.
    //!   Constant if cache_last<> is true and i == end().
-   const_iterator previous(const_iterator i) const
+   const_iterator previous(const_iterator i) const BOOST_NOEXCEPT
    {  return this->previous(this->cbefore_begin(), i); }
 
    //! <b>Returns</b>: The iterator to the element before i in the list,
@@ -1842,7 +1837,7 @@ class slist_impl
    //!
    //! <b>Complexity</b>: Linear to the number of elements before i.
    //!   Constant if cache_last<> is true and i == end().
-   iterator previous(const_iterator prev_from, iterator i)
+   iterator previous(const_iterator prev_from, iterator i) BOOST_NOEXCEPT
    {  return this->previous(prev_from, const_iterator(i)).unconst(); }
 
    //! <b>Returns</b>: The const_iterator to the element before i in the list,
@@ -1854,7 +1849,7 @@ class slist_impl
    //!
    //! <b>Complexity</b>: Linear to the number of elements before i.
    //!   Constant if cache_last<> is true and i == end().
-   const_iterator previous(const_iterator prev_from, const_iterator i) const
+   const_iterator previous(const_iterator prev_from, const_iterator i) const BOOST_NOEXCEPT
    {
       if(cache_last && (i.pointed_node() == this->get_end_node())){
          return const_iterator(detail::uncast(this->get_last_node()), this->priv_value_traits_ptr());
@@ -1882,9 +1877,9 @@ class slist_impl
    //!   point to elements of this list. Iterators of this list and all the references are not invalidated.
    //!
    //! <b>Warning</b>: Experimental function, don't use it!
-   void incorporate_after(const_iterator prev_pos, const node_ptr & f, const node_ptr & before_l)
+   void incorporate_after(const_iterator prev_pos, node_ptr f, node_ptr before_l) BOOST_NOEXCEPT
    {
-      if(constant_time_size)
+      BOOST_IF_CONSTEXPR(constant_time_size)
          this->incorporate_after(prev_pos, f, before_l, node_algorithms::distance(f.pointed_node(), before_l.pointed_node())+1);
       else
          this->priv_incorporate_after(prev_pos.pointed_node(), f, before_l);
@@ -1906,7 +1901,7 @@ class slist_impl
    //!   point to elements of this list. Iterators of this list and all the references are not invalidated.
    //!
    //! <b>Warning</b>: Experimental function, don't use it!
-   void incorporate_after(const_iterator prev_pos, const node_ptr & f, const node_ptr & before_l, size_type n)
+   void incorporate_after(const_iterator prev_pos, node_ptr f, node_ptr before_l, size_type n) BOOST_NOEXCEPT
    {
       if(n){
          BOOST_INTRUSIVE_INVARIANT_ASSERT(n > 0);
@@ -1916,7 +1911,7 @@ class slist_impl
                , iterator(before_l, this->priv_value_traits_ptr())))
             +1 == n);
          this->priv_incorporate_after(prev_pos.pointed_node(), f, before_l);
-         if(constant_time_size){
+         BOOST_IF_CONSTEXPR(constant_time_size){
             this->priv_size_traits().increase(n);
          }
       }
@@ -1937,16 +1932,15 @@ class slist_impl
       BOOST_INTRUSIVE_INVARIANT_ASSERT(node_traits::get_next(header_ptr));
       if (node_traits::get_next(header_ptr) == header_ptr)
       {
-         if (constant_time_size)
-            BOOST_INTRUSIVE_INVARIANT_ASSERT(this->priv_size_traits().get_size() == 0);
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(!constant_time_size || this->priv_size_traits().get_size() == 0);
          return;
       }
-      size_t node_count = 0;
+      size_t node_count = 0; (void)node_count;
       const_node_ptr p = header_ptr;
       while (true)
       {
          const_node_ptr next_p = node_traits::get_next(p);
-         if (!linear)
+         BOOST_IF_CONSTEXPR(!linear)
          {
             BOOST_INTRUSIVE_INVARIANT_ASSERT(next_p);
          }
@@ -1956,15 +1950,13 @@ class slist_impl
          }
          if ((!linear && next_p == header_ptr) || (linear && !next_p))
          {
-            if (cache_last)
-               BOOST_INTRUSIVE_INVARIANT_ASSERT(get_last_node() == p);
+            BOOST_INTRUSIVE_INVARIANT_ASSERT(!cache_last || get_last_node() == p);
             break;
          }
          p = next_p;
          ++node_count;
       }
-      if (constant_time_size)
-         BOOST_INTRUSIVE_INVARIANT_ASSERT(this->priv_size_traits().get_size() == node_count);
+      BOOST_INTRUSIVE_INVARIANT_ASSERT(!constant_time_size || this->priv_size_traits().get_size() == node_count);
    }
 
 
@@ -1995,7 +1987,7 @@ class slist_impl
    {  x.swap(y);  }
 
    private:
-   void priv_splice_after(const node_ptr & prev_pos_n, slist_impl &x, const node_ptr & before_f_n, const node_ptr & before_l_n)
+   void priv_splice_after(node_ptr prev_pos_n, slist_impl &x, node_ptr before_f_n, node_ptr before_l_n)
    {
       if (cache_last && (before_f_n != before_l_n)){
          if(prev_pos_n == this->get_last_node()){
@@ -2008,9 +2000,9 @@ class slist_impl
       node_algorithms::transfer_after(prev_pos_n, before_f_n, before_l_n);
    }
 
-   void priv_incorporate_after(const node_ptr & prev_pos_n, const node_ptr & first_n, const node_ptr & before_l_n)
+   void priv_incorporate_after(node_ptr prev_pos_n, node_ptr first_n, node_ptr before_l_n)
    {
-      if(cache_last){
+      BOOST_IF_CONSTEXPR(cache_last){
          if(prev_pos_n == this->get_last_node()){
             this->set_last_node(before_l_n);
          }
@@ -2038,12 +2030,12 @@ class slist_impl
 
    void priv_shift_backwards(size_type n, detail::bool_<true>)
    {
-      std::pair<node_ptr, node_ptr> ret(
+      typename node_algorithms::node_pair ret(
          node_algorithms::move_first_n_forward
             (node_traits::get_next(this->get_root_node()), (std::size_t)n));
       if(ret.first){
          node_traits::set_next(this->get_root_node(), ret.first);
-         if(cache_last){
+         BOOST_IF_CONSTEXPR(cache_last){
             this->set_last_node(ret.second);
          }
       }
@@ -2059,12 +2051,12 @@ class slist_impl
 
    void priv_shift_forward(size_type n, detail::bool_<true>)
    {
-      std::pair<node_ptr, node_ptr> ret(
+      typename node_algorithms::node_pair ret(
          node_algorithms::move_first_n_backwards
          (node_traits::get_next(this->get_root_node()), (std::size_t)n));
       if(ret.first){
          node_traits::set_next(this->get_root_node(), ret.first);
-         if(cache_last){
+         BOOST_IF_CONSTEXPR(cache_last){
             this->set_last_node(ret.second);
          }
       }
@@ -2108,19 +2100,19 @@ class slist_impl
    }
 
    //circular version
-   static void priv_swap_lists(const node_ptr & this_node, const node_ptr & other_node, detail::bool_<false>)
+   static void priv_swap_lists(node_ptr this_node, node_ptr other_node, detail::bool_<false>)
    {  node_algorithms::swap_nodes(this_node, other_node); }
 
    //linear version
-   static void priv_swap_lists(const node_ptr & this_node, const node_ptr & other_node, detail::bool_<true>)
+   static void priv_swap_lists(node_ptr this_node, node_ptr other_node, detail::bool_<true>)
    {  node_algorithms::swap_trailing_nodes(this_node, other_node); }
 
    static slist_impl &priv_container_from_end_iterator(const const_iterator &end_iterator)
    {
       //Obtaining the container from the end iterator is not possible with linear
       //singly linked lists (because "end" is represented by the null pointer)
-      BOOST_STATIC_ASSERT(!linear);
-      BOOST_STATIC_ASSERT((has_container_from_iterator));
+      BOOST_INTRUSIVE_STATIC_ASSERT(!linear);
+      BOOST_INTRUSIVE_STATIC_ASSERT((has_container_from_iterator));
       node_ptr p = end_iterator.pointed_node();
       header_holder_type* h = header_holder_type::get_holder(p);
       header_holder_plus_last_t* hpl = detail::parent_from_member< header_holder_plus_last_t, header_holder_type>
@@ -2192,7 +2184,7 @@ class slist
       #endif
       >::type   Base;
    //Assert if passed value traits are compatible with the type
-   BOOST_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
+   BOOST_INTRUSIVE_STATIC_ASSERT((detail::is_same<typename Base::value_traits::value_type, T>::value));
    BOOST_MOVABLE_BUT_NOT_COPYABLE(slist)
 
    public:
@@ -2202,45 +2194,45 @@ class slist
    typedef typename Base::size_type          size_type;
    typedef typename Base::node_ptr           node_ptr;
 
-   slist()
+   inline slist()
       :  Base()
    {}
 
-   explicit slist(const value_traits &v_traits)
+   inline explicit slist(const value_traits &v_traits)
       :  Base(v_traits)
    {}
 
    struct incorporate_t{};
 
-   slist( const node_ptr & f, const node_ptr & before_l
+   inline slist( node_ptr f, node_ptr before_l
              , size_type n, const value_traits &v_traits = value_traits())
       :  Base(f, before_l, n, v_traits)
    {}
 
    template<class Iterator>
-   slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
+   inline slist(Iterator b, Iterator e, const value_traits &v_traits = value_traits())
       :  Base(b, e, v_traits)
    {}
 
-   slist(BOOST_RV_REF(slist) x)
+   inline slist(BOOST_RV_REF(slist) x)
       :  Base(BOOST_MOVE_BASE(Base, x))
    {}
 
-   slist& operator=(BOOST_RV_REF(slist) x)
+   inline slist& operator=(BOOST_RV_REF(slist) x)
    {  return static_cast<slist &>(this->Base::operator=(BOOST_MOVE_BASE(Base, x)));  }
 
    template <class Cloner, class Disposer>
-   void clone_from(const slist &src, Cloner cloner, Disposer disposer)
+   inline void clone_from(const slist &src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(src, cloner, disposer);  }
 
    template <class Cloner, class Disposer>
-   void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
+   inline void clone_from(BOOST_RV_REF(slist) src, Cloner cloner, Disposer disposer)
    {  Base::clone_from(BOOST_MOVE_BASE(Base, src), cloner, disposer);  }
 
-   static slist &container_from_end_iterator(iterator end_iterator)
+   inline static slist &container_from_end_iterator(iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<slist &>(Base::container_from_end_iterator(end_iterator));   }
 
-   static const slist &container_from_end_iterator(const_iterator end_iterator)
+   inline static const slist &container_from_end_iterator(const_iterator end_iterator) BOOST_NOEXCEPT
    {  return static_cast<const slist &>(Base::container_from_end_iterator(end_iterator));   }
 };