passenger 6.0.14 → 6.0.15

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

@@ -570,6 +570,7 @@ template
    , class O8  = void
    , class O9  = void
    , class O10 = void
+   , class O11 = void
    >
 #else
 template<class T, class ...Options>
@@ -589,6 +590,7 @@ template
    , class O8  = void
    , class O9  = void
    , class O10 = void
+   , class O11 = void
    >
 #else
 template<class T, class ...Options>

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

@@ -78,7 +78,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void init(const node_ptr & this_node) BOOST_NOEXCEPT;
+   static void init(node_ptr this_node) BOOST_NOEXCEPT;
 
    //! <b>Requires</b>: this_node must be in a circular list or be an empty circular list.
    //!
@@ -106,7 +106,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void unlink_after(const node_ptr & prev_node) BOOST_NOEXCEPT;
+   static void unlink_after(node_ptr prev_node) BOOST_NOEXCEPT;
 
    //! <b>Requires</b>: prev_node and last_node must be in a circular list
    //!  or be an empty circular list.
@@ -116,7 +116,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void unlink_after(const node_ptr & prev_node, const node_ptr & last_node) BOOST_NOEXCEPT;
+   static void unlink_after(node_ptr prev_node, node_ptr last_node) BOOST_NOEXCEPT;
 
    //! <b>Requires</b>: prev_node must be a node of a linear list.
    //!
@@ -125,7 +125,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void link_after(const node_ptr & prev_node, const node_ptr & this_node) BOOST_NOEXCEPT;
+   static void link_after(node_ptr prev_node, node_ptr this_node) BOOST_NOEXCEPT;
 
    //! <b>Requires</b>: b and e must be nodes of the same linear list or an empty range.
    //!   and p must be a node of a different linear list.
@@ -136,7 +136,11 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void transfer_after(const node_ptr & p, const node_ptr & b, const node_ptr & e) BOOST_NOEXCEPT;
+   static void transfer_after(node_ptr p, node_ptr b, node_ptr e) BOOST_NOEXCEPT;
+
+   #else
+
+   using base_t::transfer_after;
 
    #endif   //#if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
 
@@ -147,9 +151,44 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(const node_ptr & this_node) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr this_node) BOOST_NOEXCEPT
    {  NodeTraits::set_next(this_node, node_ptr ());  }
 
+   //! <b>Requires</b>: 'p' is the first node of a list.
+   //!
+   //! <b>Effects</b>: Returns a pointer to a node that represents the "end" (one past end) node
+   //!
+   //! <b>Complexity</b>: Constant time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr end_node(const_node_ptr) BOOST_NOEXCEPT
+   {  return node_ptr();   }
+
+   //! <b>Effects</b>: Returns true if this_node_points to an empty list.
+   //! 
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing.
+   BOOST_INTRUSIVE_FORCEINLINE static bool is_empty(const_node_ptr this_node) BOOST_NOEXCEPT
+   {  return !NodeTraits::get_next(this_node);  }
+
+   //! <b>Effects</b>: Returns true if this_node points to a sentinel node.
+   //! 
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing.
+   BOOST_INTRUSIVE_FORCEINLINE static bool is_sentinel(const_node_ptr this_node) BOOST_NOEXCEPT
+   {  return NodeTraits::get_next(this_node) == this_node;  }
+
+   //! <b>Effects</b>: Marks this node as a "sentinel" node, a special state that is different from "empty",
+   //!                 that can be used to mark a special state of the list
+   //!
+   //! <b>Complexity</b>: Constant
+   //!
+   //! <b>Throws</b>: Nothing.
+   BOOST_INTRUSIVE_FORCEINLINE static void set_sentinel(node_ptr this_node) BOOST_NOEXCEPT
+   {  NodeTraits::set_next(this_node, this_node);   }
+
    //! <b>Requires</b>: this_node and prev_init_node must be in the same linear list.
    //!
    //! <b>Effects</b>: Returns the previous node of this_node in the linear list starting.
@@ -160,7 +199,7 @@ class linear_slist_algorithms
    //!
    //! <b>Throws</b>: Nothing.
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr
-      get_previous_node(const node_ptr & prev_init_node, const node_ptr & this_node) BOOST_NOEXCEPT
+      get_previous_node(node_ptr prev_init_node, node_ptr this_node) BOOST_NOEXCEPT
    {  return base_t::get_previous_node(prev_init_node, this_node);   }
 
    //! <b>Requires</b>: this_node must be in a linear list or be an empty linear list.
@@ -171,7 +210,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Linear
    //!
    //! <b>Throws</b>: Nothing.
-   static std::size_t count(const const_node_ptr & this_node) BOOST_NOEXCEPT
+   static std::size_t count(const_node_ptr this_node) BOOST_NOEXCEPT
    {
       std::size_t result = 0;
       const_node_ptr p = this_node;
@@ -329,6 +368,40 @@ class linear_slist_algorithms
       ret.second  = new_last;
       return ret;
    }
+
+   //! <b>Requires</b>: other must be a list and p must be a node of a different linear list.
+   //!
+   //! <b>Effects</b>: Transfers all nodes from other after p in p's linear list.
+   //!
+   //! <b>Complexity</b>: Linear
+   //!
+   //! <b>Throws</b>: Nothing.
+   static void transfer_after(node_ptr p, node_ptr other) BOOST_NOEXCEPT
+   {
+      if ((is_empty)(p)) {
+         (swap_trailing_nodes)(p, other);
+      }
+      else {
+         node_ptr other_last((get_previous_node)(other, node_ptr()));
+         base_t::transfer_after(p, other, other_last);
+      }
+   }
+
+   //! <b>Requires</b>: "disposer" must be an object function
+   //!   taking a node_ptr parameter and shouldn't throw.
+   //!
+   //! <b>Effects</b>: Unlinks all nodes reachable from p (but not p) and calls
+   //!   <tt>void disposer::operator()(node_ptr)</tt> for every node of the list
+   //!    where p is linked.
+   //!
+   //! <b>Returns</b>: The number of disposed nodes
+   //!
+   //! <b>Complexity</b>: Linear to the number of element of the list.
+   //!
+   //! <b>Throws</b>: Nothing.
+   template<class Disposer>
+   BOOST_INTRUSIVE_FORCEINLINE static std::size_t detach_and_dispose(node_ptr p, Disposer disposer) BOOST_NOEXCEPT
+   {  return base_t::unlink_after_and_dispose(p, node_ptr(), disposer);   }
 };
 
 /// @cond

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

@@ -127,10 +127,10 @@ class list_impl
                         ((int)value_traits::link_mode == (int)auto_unlink)
                       ));
 
-   node_ptr get_root_node()
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr get_root_node()
    { return data_.root_plus_size_.m_header.get_node(); }
 
-   const_node_ptr get_root_node() const
+   BOOST_INTRUSIVE_FORCEINLINE const_node_ptr get_root_node() const
    { return data_.root_plus_size_.m_header.get_node(); }
 
    struct root_plus_size : public size_traits
@@ -141,7 +141,7 @@ class list_impl
    struct data_t : public value_traits
    {
       typedef typename list_impl::value_traits value_traits;
-      explicit data_t(const value_traits &val_traits)
+      BOOST_INTRUSIVE_FORCEINLINE explicit data_t(const value_traits &val_traits)
          :  value_traits(val_traits)
       {}
 
@@ -548,7 +548,7 @@ class list_impl
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Note</b>: Does not affect the validity of iterators and references.
-   BOOST_INTRUSIVE_FORCEINLINE void swap(list_impl& other) BOOST_NOEXCEPT
+   void swap(list_impl& other) BOOST_NOEXCEPT
    {
       node_algorithms::swap_nodes(this->get_root_node(), other.get_root_node());
       this->priv_size_traits().swap(other.priv_size_traits());
@@ -638,7 +638,8 @@ class list_impl
    iterator erase(const_iterator b, const_iterator e, size_type n) BOOST_NOEXCEPT
    {
       BOOST_INTRUSIVE_INVARIANT_ASSERT(node_algorithms::distance(b.pointed_node(), e.pointed_node()) == n);
-      BOOST_IF_CONSTEXPR(safemode_or_autounlink || constant_time_size){
+      (void)n;
+      BOOST_IF_CONSTEXPR(safemode_or_autounlink){
          return this->erase_and_dispose(b, e, detail::null_disposer());
       }
       else{
@@ -1117,7 +1118,7 @@ class list_impl
    //! <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 remove(const_reference value) BOOST_NOEXCEPT
-   {  this->remove_if(value_equal<const_reference>(value));  }
+   {  this->remove_if(detail::equal_to_value<const_reference>(value));  }
 
    //! <b>Requires</b>: Disposer::operator()(pointer) shouldn't throw.
    //!
@@ -1132,7 +1133,7 @@ class list_impl
    //!   and iterators to elements that are not removed remain valid.
    template<class Disposer>
    void remove_and_dispose(const_reference value, Disposer disposer) BOOST_NOEXCEPT
-   {  this->remove_and_dispose_if(value_equal<const_reference>(value), disposer);  }
+   {  this->remove_and_dispose_if(detail::equal_to_value<const_reference>(value), disposer);  }
 
    //! <b>Effects</b>: Removes all the elements for which a specified
    //!   predicate is satisfied. No destructors are called.
@@ -1362,7 +1363,7 @@ class list_impl
          BOOST_INTRUSIVE_INVARIANT_ASSERT(this->priv_size_traits().get_size() == node_count);
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE friend bool operator==(const list_impl &x, const list_impl &y)
+   friend bool operator==(const list_impl &x, const list_impl &y)
    {
       if(constant_time_size && x.size() != y.size()){
          return false;

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

@@ -63,13 +63,13 @@ struct member_value_traits
    BOOST_INTRUSIVE_FORCEINLINE static const_node_ptr to_node_ptr(const_reference value) BOOST_NOEXCEPT
    {  return pointer_traits<const_node_ptr>::pointer_to(value.*PtrToMember);   }
 
-   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(const node_ptr &n) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static pointer to_value_ptr(node_ptr n) BOOST_NOEXCEPT
    {
       return pointer_traits<pointer>::pointer_to(*detail::parent_from_member<value_type, node>
          (boost::movelib::to_raw_pointer(n), PtrToMember));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const const_node_ptr &n) BOOST_NOEXCEPT
+   BOOST_INTRUSIVE_FORCEINLINE static const_pointer to_value_ptr(const_node_ptr n) BOOST_NOEXCEPT
    {
       return pointer_traits<const_pointer>::pointer_to(*detail::parent_from_member<value_type, node>
          (boost::movelib::to_raw_pointer(n), PtrToMember));

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

@@ -212,13 +212,22 @@ BOOST_INTRUSIVE_OPTION_CONSTANT(store_hash, bool, Enabled, store_hash)
 //!with the same key.
 BOOST_INTRUSIVE_OPTION_CONSTANT(optimize_multikey, bool, Enabled, optimize_multikey)
 
-//!This option setter specifies if the bucket array will be always power of two.
+//!This option setter specifies if the length of the bucket array provided by
+//!the user will always be power of two.
 //!This allows using masks instead of the default modulo operation to determine
 //!the bucket number from the hash value, leading to better performance.
-//!In debug mode, if power of two buckets mode is activated, the bucket length
-//!will be checked with assertions.
+//!In debug mode, the provided bucket array length will be checked with assertions.
 BOOST_INTRUSIVE_OPTION_CONSTANT(power_2_buckets, bool, Enabled, power_2_buckets)
 
+//!WARNING: this option is EXPERIMENTAL, don't use it in production code
+//!This option setter specifies if the length of the bucket array provided by
+//!the user will always be a value specified by the
+//!suggested_upper|lower_bucket_count call. This allows the use of some
+//!precomputed values and speeds hash to bucket index operations, leading
+//!to better performance.
+//!In debug mode, the provided bucket array length will be checked with assertions.
+BOOST_INTRUSIVE_OPTION_CONSTANT(fastmod_buckets, bool, Enabled, fastmod_buckets)
+
 //!This option setter specifies if the container will cache a pointer to the first
 //!non-empty bucket so that begin() is always constant-time.
 //!This is specially helpful when we can have containers with a few elements
@@ -241,6 +250,11 @@ BOOST_INTRUSIVE_OPTION_CONSTANT(compare_hash, bool, Enabled, compare_hash)
 //!(rehashing the whole bucket array) is not admisible.
 BOOST_INTRUSIVE_OPTION_CONSTANT(incremental, bool, Enabled, incremental)
 
+//!This option setter specifies if the buckets (which form a singly linked lists of nodes)
+//!are linear (true) or circular (false, default value). Linear buckets can improve performance
+//!in some cases, but the container loses some features like obtaining an iterator from a value.
+BOOST_INTRUSIVE_OPTION_CONSTANT(linear_buckets, bool, Enabled, linear_buckets)
+
 /// @cond
 
 struct hook_defaults

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

@@ -19,6 +19,8 @@
 #  pragma once
 #endif
 
+#include <cstddef>
+
 namespace boost {
 namespace intrusive {
 
@@ -97,19 +99,19 @@ struct pack_options
 #else
 
 //index_tuple
-template<int... Indexes>
+template<std::size_t... Indexes>
 struct index_tuple{};
 
 //build_number_seq
 template<std::size_t Num, typename Tuple = index_tuple<> >
 struct build_number_seq;
 
-template<std::size_t Num, int... Indexes>
+template<std::size_t Num, std::size_t... Indexes>
 struct build_number_seq<Num, index_tuple<Indexes...> >
    : build_number_seq<Num - 1, index_tuple<Indexes..., sizeof...(Indexes)> >
 {};
 
-template<int... Indexes>
+template<std::size_t... Indexes>
 struct build_number_seq<0, index_tuple<Indexes...> >
 {  typedef index_tuple<Indexes...> type;  };
 
@@ -121,10 +123,10 @@ struct typelist
 template<class T>
 struct invert_typelist;
 
-template<int I, typename Tuple>
+template<std::size_t I, typename Tuple>
 struct typelist_element;
 
-template<int I, typename Head, typename... Tail>
+template<std::size_t I, typename Head, typename... Tail>
 struct typelist_element<I, typelist<Head, Tail...> >
 {
    typedef typename typelist_element<I-1, typelist<Tail...> >::type type;
@@ -136,7 +138,7 @@ struct typelist_element<0, typelist<Head, Tail...> >
    typedef Head type;
 };
 
-template<int ...Ints, class ...Types>
+template<std::size_t ...Ints, class ...Types>
 typelist<typename typelist_element<(sizeof...(Types) - 1) - Ints, typelist<Types...> >::type...>
    inverted_typelist(index_tuple<Ints...>, typelist<Types...>)
 {
@@ -158,7 +160,7 @@ template<class Typelist, class Indexes>
 struct invert_typelist_impl;
 
 
-template<class Typelist, int ...Ints>
+template<class Typelist, std::size_t ...Ints>
 struct invert_typelist_impl< Typelist, index_tuple<Ints...> >
 {
    static const std::size_t last_idx = sizeof_typelist<Typelist>::value - 1;
@@ -166,7 +168,7 @@ struct invert_typelist_impl< Typelist, index_tuple<Ints...> >
       <typename typelist_element<last_idx - Ints, Typelist>::type...> type;
 };
 
-template<class Typelist, int Int>
+template<class Typelist, std::size_t Int>
 struct invert_typelist_impl< Typelist, index_tuple<Int> >
 {
    typedef Typelist type;

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

@@ -46,6 +46,7 @@ BOOST_INTRUSIVE_HAS_MEMBER_FUNC_CALLED_IGNORE_SIGNATURE(has_member_function_call
 
 BOOST_INTRUSIVE_INSTANTIATE_EVAL_DEFAULT_TYPE_TMPLT(element_type)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(difference_type)
+BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(size_type)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(reference)
 BOOST_INTRUSIVE_INSTANTIATE_DEFAULT_TYPE_TMPLT(value_traits_ptr)
 
@@ -103,7 +104,13 @@ struct pointer_traits
          (boost::intrusive::detail::, Ptr, difference_type, std::ptrdiff_t)   difference_type;
 
       typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
-         (boost::intrusive::detail::, Ptr, reference, typename boost::intrusive::detail::unvoid_ref<element_type>::type)   reference;
+         ( boost::intrusive::detail::, Ptr, size_type
+         , typename boost::move_detail::
+               make_unsigned<difference_type>::type)                          size_type;
+
+      typedef BOOST_INTRUSIVE_OBTAIN_TYPE_WITH_DEFAULT
+         ( boost::intrusive::detail::, Ptr, reference
+         , typename boost::intrusive::detail::unvoid_ref<element_type>::type) reference;
       //
       template <class U> struct rebind_pointer
       {
@@ -265,9 +272,10 @@ struct pointer_traits<Ptr&> : pointer_traits<Ptr> { };
 template <typename T>
 struct pointer_traits<T*>
 {
-   typedef T            element_type;
-   typedef T*           pointer;
-   typedef std::ptrdiff_t difference_type;
+   typedef T               element_type;
+   typedef T*              pointer;
+   typedef std::ptrdiff_t  difference_type;
+   typedef std::size_t     size_type;
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
       typedef T &          reference;

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

@@ -28,8 +28,13 @@ namespace intrusive {
 
 /// @cond
 
-template<class U>
-void priority_order();
+namespace adldft {
+
+template<class T, class U>
+BOOST_INTRUSIVE_FORCEINLINE bool priority_order(const T &t, const U &u)
+{  return t < u;  }
+
+}  //namespace adldft {
 
 /// @endcond
 
@@ -43,6 +48,7 @@ struct priority_compare
 
    BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T &val, const T &val2) const
    {
+      using adldft::priority_order;
       return priority_order(val, val2);
    }
 };
@@ -53,6 +59,7 @@ struct priority_compare<void>
    template<class T, class U>
    BOOST_INTRUSIVE_FORCEINLINE bool operator()(const T &t, const U &u) const
    {
+      using adldft::priority_order;
       return priority_order(t, u);
    }
 };

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

@@ -54,7 +54,7 @@ struct rbtree_node_cloner
       :  base_t(f)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(node_ptr p)
+   node_ptr operator()(node_ptr p)
    {
       node_ptr n = base_t::get()(p);
       NodeTraits::set_color(n, NodeTraits::get_color(p));
@@ -85,7 +85,7 @@ struct rbtree_node_checker
       : base_checker_t(comp, extra_checker)
    {}
 
-   void operator () (const const_node_ptr& p,
+   void operator () (const_node_ptr p,
                      const return_type& check_return_left, const return_type& check_return_right,
                      return_type& check_return)
    {
@@ -190,14 +190,14 @@ class rbtree_algorithms
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::get_header(const const_node_ptr&)
-   static node_ptr get_header(const const_node_ptr & n) BOOST_NOEXCEPT;
+   //! @copydoc ::boost::intrusive::bstree_algorithms::get_header(const_node_ptr)
+   static node_ptr get_header(const_node_ptr n) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::begin_node
-   static node_ptr begin_node(const const_node_ptr & header) BOOST_NOEXCEPT;
+   static node_ptr begin_node(const_node_ptr header) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::end_node
-   static node_ptr end_node(const const_node_ptr & header) BOOST_NOEXCEPT;
+   static node_ptr end_node(const_node_ptr header) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::swap_tree
    static void swap_tree(node_ptr header1, node_ptr header2) BOOST_NOEXCEPT;
@@ -242,7 +242,7 @@ class rbtree_algorithms
    }
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::unlink(node_ptr)
-   static void unlink(const node_ptr& node) BOOST_NOEXCEPT
+   static void unlink(node_ptr node) BOOST_NOEXCEPT
    {
       node_ptr x = NodeTraits::get_parent(node);
       if(x){
@@ -254,26 +254,26 @@ class rbtree_algorithms
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
    //! @copydoc ::boost::intrusive::bstree_algorithms::unlink_leftmost_without_rebalance
-   static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header) BOOST_NOEXCEPT;
+   static node_ptr unlink_leftmost_without_rebalance(node_ptr header) BOOST_NOEXCEPT;
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::unique(const const_node_ptr&)
-   static bool unique(const const_node_ptr & node) BOOST_NOEXCEPT;
+   //! @copydoc ::boost::intrusive::bstree_algorithms::unique(const_node_ptr)
+   static bool unique(const_node_ptr node) BOOST_NOEXCEPT;
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::size(const const_node_ptr&)
-   static std::size_t size(const const_node_ptr & header) BOOST_NOEXCEPT;
+   //! @copydoc ::boost::intrusive::bstree_algorithms::size(const_node_ptr)
+   static std::size_t size(const_node_ptr header) BOOST_NOEXCEPT;
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::next_node(const node_ptr&)
-   static node_ptr next_node(const node_ptr & node) BOOST_NOEXCEPT;
+   //! @copydoc ::boost::intrusive::bstree_algorithms::next_node(const_node_ptr)
+   static node_ptr next_node(node_ptr node) BOOST_NOEXCEPT;
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::prev_node(const node_ptr&)
-   static node_ptr prev_node(const node_ptr & node) BOOST_NOEXCEPT;
+   //! @copydoc ::boost::intrusive::bstree_algorithms::prev_node(const_node_ptr)
+   static node_ptr prev_node(node_ptr node) BOOST_NOEXCEPT;
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::init(node_ptr)
-   static void init(const node_ptr & node) BOOST_NOEXCEPT;
+   static void init(node_ptr node) BOOST_NOEXCEPT;
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::init_header(node_ptr)
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr header) BOOST_NOEXCEPT
+   static void init_header(node_ptr header) BOOST_NOEXCEPT
    {
       bstree_algo::init_header(header);
       NodeTraits::set_color(header, NodeTraits::red());
@@ -313,7 +313,7 @@ class rbtree_algorithms
       rebalance_after_insertion(header1, z);
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::clone(const const_node_ptr&,node_ptr,Cloner,Disposer)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::clone(const_node_ptr,node_ptr,Cloner,Disposer)
    template <class Cloner, class Disposer>
    static void clone
       (const_node_ptr source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
@@ -323,39 +323,39 @@ class rbtree_algorithms
    }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
-   //! @copydoc ::boost::intrusive::bstree_algorithms::clear_and_dispose(const node_ptr&,Disposer)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::clear_and_dispose(const_node_ptr,Disposer)
    template<class Disposer>
-   static void clear_and_dispose(const node_ptr & header, Disposer disposer) BOOST_NOEXCEPT;
+   static void clear_and_dispose(node_ptr header, Disposer disposer) BOOST_NOEXCEPT;
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::lower_bound(const const_node_ptr&,const KeyType&,KeyNodePtrCompare)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::lower_bound(const_node_ptr,const KeyType&,KeyNodePtrCompare)
    template<class KeyType, class KeyNodePtrCompare>
    static node_ptr lower_bound
-      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp);
+      (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp);
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::upper_bound(const const_node_ptr&,const KeyType&,KeyNodePtrCompare)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::upper_bound(const_node_ptr,const KeyType&,KeyNodePtrCompare)
    template<class KeyType, class KeyNodePtrCompare>
    static node_ptr upper_bound
-      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp);
+      (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp);
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::find(const const_node_ptr&, const KeyType&,KeyNodePtrCompare)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::find(const_node_ptr, const KeyType&,KeyNodePtrCompare)
    template<class KeyType, class KeyNodePtrCompare>
    static node_ptr find
-      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp);
+      (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp);
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::equal_range(const const_node_ptr&,const KeyType&,KeyNodePtrCompare)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::equal_range(const_node_ptr,const KeyType&,KeyNodePtrCompare)
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, node_ptr> equal_range
-      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp);
+      (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp);
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::bounded_range(const const_node_ptr&,const KeyType&,const KeyType&,KeyNodePtrCompare,bool,bool)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::bounded_range(const_node_ptr,const KeyType&,const KeyType&,KeyNodePtrCompare,bool,bool)
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, node_ptr> bounded_range
-      (const const_node_ptr & header, const KeyType &lower_key, const KeyType &upper_key, KeyNodePtrCompare comp
+      (const_node_ptr eader, const KeyType &lower_key, const KeyType &upper_key, KeyNodePtrCompare comp
       , bool left_closed, bool right_closed);
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::count(const const_node_ptr&,const KeyType&,KeyNodePtrCompare)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::count(const_node_ptr,const KeyType&,KeyNodePtrCompare)
    template<class KeyType, class KeyNodePtrCompare>
-   static std::size_t count(const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp);
+   static std::size_t count(const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp);
 
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
@@ -413,13 +413,13 @@ class rbtree_algorithms
    }
 
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
-   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_check(const const_node_ptr&,const KeyType&,KeyNodePtrCompare,insert_commit_data&)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_check(const_node_ptr,const KeyType&,KeyNodePtrCompare,insert_commit_data&)
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, bool> insert_unique_check
       (const_node_ptr header,  const KeyType &key
       ,KeyNodePtrCompare comp, insert_commit_data &commit_data);
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_check(const const_node_ptr&,const node_ptr&,const KeyType&,KeyNodePtrCompare,insert_commit_data&)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_check(const_node_ptr,const_node_ptr,const KeyType&,KeyNodePtrCompare,insert_commit_data&)
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, bool> insert_unique_check
       (const_node_ptr header, node_ptr hint, const KeyType &key
@@ -435,7 +435,7 @@ class rbtree_algorithms
    }
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::is_header
-   static bool is_header(const const_node_ptr & p) BOOST_NOEXCEPT
+   static bool is_header(const_node_ptr p) BOOST_NOEXCEPT
    {
       return NodeTraits::get_color(p) == NodeTraits::red() &&
             bstree_algo::is_header(p);