passenger 6.0.0 → 6.0.5

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/node_cloner_disposer.hpp

@@ -59,7 +59,7 @@ struct node_cloner
    {}
 
    // tree-based containers use this method, which is proxy-reference friendly
-   node_ptr operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(const node_ptr & p)
    {
       reference_type v = *traits_->to_value_ptr(p);
       node_ptr n = traits_->to_node_ptr(*base_t::get()(v));
@@ -89,7 +89,7 @@ struct node_disposer
       :  base_t(f), traits_(cont)
    {}
 
-   void operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE void operator()(const node_ptr & p)
    {
       if(safemode_or_autounlink)
          node_algorithms::init(p);

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/rbtree_node.hpp

@@ -80,7 +80,7 @@ struct default_rbtree_node_traits_impl
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const node_ptr & n)
    {  return n->parent_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(const node_ptr & n, const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(node_ptr n, node_ptr p)
    {  n->parent_ = p;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const const_node_ptr & n)
@@ -89,7 +89,7 @@ struct default_rbtree_node_traits_impl
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const node_ptr & n)
    {  return n->left_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_left(const node_ptr & n, const node_ptr & l)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_left(node_ptr n, node_ptr l)
    {  n->left_ = l;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const const_node_ptr & n)
@@ -98,7 +98,7 @@ struct default_rbtree_node_traits_impl
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const node_ptr & n)
    {  return n->right_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_right(const node_ptr & n, const node_ptr & r)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_right(node_ptr n, node_ptr r)
    {  n->right_ = r;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static color get_color(const const_node_ptr & n)
@@ -136,7 +136,7 @@ struct compact_rbtree_node_traits_impl
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const node_ptr & n)
    {  return ptr_bit::get_pointer(n->parent_);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(const node_ptr & n, const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(node_ptr n, node_ptr p)
    {  ptr_bit::set_pointer(n->parent_, p);  }
 
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const const_node_ptr & n)
@@ -145,7 +145,7 @@ struct compact_rbtree_node_traits_impl
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const node_ptr & n)
    {  return n->left_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_left(const node_ptr & n, const node_ptr & l)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_left(node_ptr n, node_ptr l)
    {  n->left_ = l;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const const_node_ptr & n)
@@ -154,7 +154,7 @@ struct compact_rbtree_node_traits_impl
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const node_ptr & n)
    {  return n->right_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_right(const node_ptr & n, const node_ptr & r)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_right(node_ptr n, node_ptr r)
    {  n->right_ = r;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static color get_color(const const_node_ptr & n)

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/simple_disposers.hpp

@@ -39,7 +39,7 @@ class init_disposer
    typedef typename NodeAlgorithms::node_ptr node_ptr;
 
    public:
-   void operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE void operator()(const node_ptr & p)
    {  NodeAlgorithms::init(p);   }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/slist_iterator.hpp

@@ -68,7 +68,7 @@ class slist_iterator
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE const node_ptr &pointed_node() const
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const
    { return members_.nodeptr_; }
 
    BOOST_INTRUSIVE_FORCEINLINE slist_iterator &operator=(const node_ptr &node)

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/slist_node.hpp

@@ -52,7 +52,7 @@ struct slist_node_traits
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_next(const node_ptr & n)
    {  return n->next_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_next(const node_ptr & n, const node_ptr & next)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_next(node_ptr n, node_ptr next)
    {  n->next_ = next;  }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/tree_iterator.hpp

@@ -74,7 +74,7 @@ class tree_iterator
       :  members_(other.pointed_node(), other.get_value_traits())
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE const node_ptr &pointed_node() const
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr pointed_node() const
    { return members_.nodeptr_; }
 
    BOOST_INTRUSIVE_FORCEINLINE tree_iterator &operator=(const node_ptr &nodeptr)

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/tree_node.hpp

@@ -50,7 +50,7 @@ struct tree_node_traits
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_parent(const node_ptr & n)
    {  return n->parent_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(const node_ptr & n, const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_parent(node_ptr n, node_ptr p)
    {  n->parent_ = p;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const const_node_ptr & n)
@@ -59,7 +59,7 @@ struct tree_node_traits
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_left(const node_ptr & n)
    {  return n->left_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_left(const node_ptr & n, const node_ptr & l)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_left(node_ptr n, node_ptr l)
    {  n->left_ = l;  }
 
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const const_node_ptr & n)
@@ -68,7 +68,7 @@ struct tree_node_traits
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_right(const node_ptr & n)
    {  return n->right_;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void set_right(const node_ptr & n, const node_ptr & r)
+   BOOST_INTRUSIVE_FORCEINLINE static void set_right(node_ptr n, node_ptr r)
    {  n->right_ = r;  }
 };
 

data/src/cxx_supportlib/vendor-modified/boost/intrusive/detail/tree_value_compare.hpp

@@ -45,7 +45,7 @@ struct disable_if_smartref_to
 
 //This function object takes a KeyCompare function object
 //and compares values that contains keys using KeyOfValue
-template< class ValuePtr, class KeyCompare, class KeyOfValue
+template< class ValuePtr, class KeyCompare, class KeyOfValue, class Ret = bool
         , bool = boost::intrusive::detail::is_same
    <typename boost::movelib::pointer_element<ValuePtr>::type, typename KeyOfValue::type>::value >
 struct tree_value_compare
@@ -80,41 +80,52 @@ struct tree_value_compare
    BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
    {  return static_cast<const key_compare &>(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const
+   {  return this->key_comp()(key);   }
+
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value) const
+   {  return this->key_comp()(KeyOfValue()(value));  }
+
+   template<class U>
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey
+                                             , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
+   {  return this->key_comp()(nonkey);  }
+
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const key_type &key2) const
    {  return this->key_comp()(key1, key2);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const value_type &value1, const value_type &value2) const
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value1, const value_type &value2) const
    {  return this->key_comp()(KeyOfValue()(value1), KeyOfValue()(value2));  }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const key_type &key1, const value_type &value2) const
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const value_type &value2) const
    {  return this->key_comp()(key1, KeyOfValue()(value2));  }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const value_type &value1, const key_type &key2) const
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const value_type &value1, const key_type &key2) const
    {  return this->key_comp()(KeyOfValue()(value1), key2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const key_type &key1, const U &nonkey2
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(key1, nonkey2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const U &nonkey1, const key_type &key2
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey1, const key_type &key2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey1, key2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const value_type &value1, const U &nonvalue2
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const value_type &value1, const U &nonvalue2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(KeyOfValue()(value1), nonvalue2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const U &nonvalue1, const value_type &value2
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonvalue1, const value_type &value2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonvalue1, KeyOfValue()(value2));  }
 };
 
-template<class ValuePtr, class KeyCompare, class KeyOfValue>
-struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, true>
+template<class ValuePtr, class KeyCompare, class KeyOfValue, class Ret>
+struct tree_value_compare<ValuePtr, KeyCompare, KeyOfValue, Ret, true>
    :  public boost::intrusive::detail::ebo_functor_holder<KeyCompare>
 {
    typedef typename
@@ -147,16 +158,24 @@ struct tree_value_compare
    BOOST_INTRUSIVE_FORCEINLINE const key_compare &key_comp() const
    {  return static_cast<const key_compare &>(*this);  }
 
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const key_type &key1, const key_type &key2) const
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key) const
+   {  return this->key_comp()(key);   }
+
+   template<class U>
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const U &nonkey
+                                             , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
+   {  return this->key_comp()(nonkey);  }
+
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const key_type &key1, const key_type &key2) const
    {  return this->key_comp()(key1, key2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()( const key_type &key1, const U &nonkey2
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()( const key_type &key1, const U &nonkey2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(key1, nonkey2);  }
 
    template<class U>
-   BOOST_INTRUSIVE_FORCEINLINE bool operator()(const U &nonkey1, const key_type &key2
+   BOOST_INTRUSIVE_FORCEINLINE Ret operator()(const U &nonkey1, const key_type &key2
                                               , typename disable_if_smartref_to<U, ValuePtr>::type* = 0) const
    {  return this->key_comp()(nonkey1, key2);  }
 };

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

@@ -375,7 +375,7 @@ struct group_functions
    typedef circular_slist_algorithms<node_traits>                 node_algorithms;
 
    static slist_node_ptr get_bucket_before_begin
-      (const slist_node_ptr &bucket_beg, const slist_node_ptr &bucket_end, const node_ptr &p)
+      (slist_node_ptr bucket_beg, slist_node_ptr bucket_end, node_ptr p)
    {
       //First find the last node of p's group.
       //This requires checking the first node of the next group or
@@ -406,7 +406,7 @@ struct group_functions
       return possible_end;
    }
 
-   static node_ptr get_prev_to_first_in_group(const slist_node_ptr &bucket_node, const node_ptr &first_in_group)
+   static node_ptr get_prev_to_first_in_group(slist_node_ptr bucket_node, node_ptr first_in_group)
    {
       node_ptr nb = detail::dcast_bucket_ptr<node>(bucket_node);
       node_ptr n;
@@ -416,7 +416,7 @@ struct group_functions
       return nb;
    }
 
-   static void erase_from_group(const slist_node_ptr &end_ptr, const node_ptr &to_erase_ptr, detail::true_)
+   static void erase_from_group(slist_node_ptr end_ptr, node_ptr to_erase_ptr, detail::true_)
    {
       node_ptr const nxt_ptr(node_traits::get_next(to_erase_ptr));
       //Check if the next node is in the group (not end node) and reverse linked to
@@ -429,7 +429,7 @@ struct group_functions
    BOOST_INTRUSIVE_FORCEINLINE static void erase_from_group(const slist_node_ptr&, const node_ptr&, detail::false_)
    {}
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_in_group(const node_ptr &first_in_group, detail::true_)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_in_group(node_ptr first_in_group, detail::true_)
    {  return group_traits::get_next(first_in_group);  }
 
    BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_last_in_group(node_ptr n, detail::false_)
@@ -449,10 +449,10 @@ struct group_functions
       return node_traits::get_next(group_traits::get_next(ptr));
    }
 
-   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_first_in_group(const node_ptr &n, detail::false_)
+   BOOST_INTRUSIVE_FORCEINLINE static node_ptr get_first_in_group(node_ptr n, detail::false_)
    {  return n;  }
 
-   BOOST_INTRUSIVE_FORCEINLINE static void insert_in_group(const node_ptr &first_in_group, const node_ptr &n, true_)
+   BOOST_INTRUSIVE_FORCEINLINE static void insert_in_group(node_ptr first_in_group, node_ptr n, true_)
    {  group_algorithms::link_after(first_in_group, n);  }
 
    static void insert_in_group(const node_ptr&, const node_ptr&, false_)
@@ -672,8 +672,8 @@ struct bucket_plus_vtraits
    typedef detail::bucket_impl<slist_impl>               bucket_type;
    typedef detail::group_functions<node_traits>          group_functions_t;
    typedef typename slist_impl::node_algorithms          node_algorithms;
-   typedef typename slist_impl::node_ptr                 slist_node_ptr;
-   typedef typename node_traits::node_ptr                node_ptr;
+   typedef typename slist_impl::node_ptr                slist_node_ptr;
+   typedef typename node_traits::node_ptr               node_ptr;
    typedef typename node_traits::node                    node;
    typedef typename value_traits::value_type             value_type;
    typedef typename value_traits::pointer                pointer;
@@ -1383,15 +1383,15 @@ struct hashdata_internal
       <const_pointer>::reference                            const_reference;
    typedef typename value_traits::node_traits               node_traits;
    typedef typename node_traits::node                       node;
-   typedef typename node_traits::node_ptr                   node_ptr;
-   typedef typename node_traits::const_node_ptr             const_node_ptr;
+   typedef typename node_traits::node_ptr                  node_ptr;
+   typedef typename node_traits::const_node_ptr          const_node_ptr;
    typedef detail::node_functions<node_traits>              node_functions_t;
    typedef typename detail::get_slist_impl
       <typename detail::reduced_slist_node_traits
          <typename value_traits::node_traits>::type
       >::type                                               slist_impl;
    typedef typename slist_impl::node_algorithms             node_algorithms;
-   typedef typename slist_impl::node_ptr                    slist_node_ptr;
+   typedef typename slist_impl::node_ptr                   slist_node_ptr;
 
    typedef hash_key_types_base
       < typename ValueTraits::value_type
@@ -1740,7 +1740,7 @@ class hashtable_impl
    //See documentation for more explanations
    BOOST_STATIC_ASSERT((!compare_hash || store_hash));
 
-   typedef typename slist_impl::node_ptr                             slist_node_ptr;
+   typedef typename slist_impl::node_ptr                            slist_node_ptr;
    typedef typename pointer_traits
       <slist_node_ptr>::template rebind_pointer
          < void >::type                                              void_pointer;

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

@@ -184,7 +184,7 @@ class linear_slist_algorithms
    //! <b>Complexity</b>: Constant
    //!
    //! <b>Throws</b>: Nothing.
-   static void swap_trailing_nodes(const node_ptr & this_node, const node_ptr & other_node)
+   static void swap_trailing_nodes(node_ptr this_node, node_ptr other_node)
    {
       node_ptr this_nxt    = NodeTraits::get_next(this_node);
       node_ptr other_nxt   = NodeTraits::get_next(other_node);
@@ -199,7 +199,7 @@ class linear_slist_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: This function is linear to the contained elements.
-   static node_ptr reverse(const node_ptr & p)
+   static node_ptr reverse(node_ptr p)
    {
       if(!p) return node_ptr();
       node_ptr i = NodeTraits::get_next(p);
@@ -222,7 +222,7 @@ class linear_slist_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions.
-   static std::pair<node_ptr, node_ptr> move_first_n_backwards(const node_ptr & p, std::size_t n)
+   static std::pair<node_ptr, node_ptr> move_first_n_backwards(node_ptr p, std::size_t n)
    {
       std::pair<node_ptr, node_ptr> ret;
       //Null shift, or count() == 0 or 1, nothing to do
@@ -277,7 +277,7 @@ class linear_slist_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear to the number of elements plus the number moved positions.
-   static std::pair<node_ptr, node_ptr> move_first_n_forward(const node_ptr & p, std::size_t n)
+   static std::pair<node_ptr, node_ptr> move_first_n_forward(node_ptr p, std::size_t n)
    {
       std::pair<node_ptr, node_ptr> ret;
       //Null shift, or count() == 0 or 1, nothing to do

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

@@ -30,6 +30,9 @@
 #  if (BOOST_GCC >= 40600)
 #     pragma GCC diagnostic push
 #     pragma GCC diagnostic ignored "-Wuninitialized"
+#     if (BOOST_GCC >= 40700)
+#        pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
+#     endif
 #  endif
 #endif
 

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

@@ -54,7 +54,7 @@ struct rbtree_node_cloner
       :  base_t(f)
    {}
 
-   node_ptr operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(node_ptr p)
    {
       node_ptr n = base_t::get()(p);
       NodeTraits::set_color(n, NodeTraits::get_color(p));
@@ -200,12 +200,12 @@ class rbtree_algorithms
    static node_ptr end_node(const const_node_ptr & header);
 
    //! @copydoc ::boost::intrusive::bstree_algorithms::swap_tree
-   static void swap_tree(const node_ptr & header1, const node_ptr & header2);
+   static void swap_tree(node_ptr header1, node_ptr header2);
 
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::swap_nodes(const node_ptr&,const node_ptr&)
-   static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::swap_nodes(node_ptr,node_ptr)
+   static void swap_nodes(node_ptr node1, node_ptr node2)
    {
       if(node1 == node2)
          return;
@@ -214,8 +214,8 @@ class rbtree_algorithms
       swap_nodes(node1, header1, node2, header2);
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::swap_nodes(const node_ptr&,const node_ptr&,const node_ptr&,const node_ptr&)
-   static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::swap_nodes(node_ptr,node_ptr,node_ptr,node_ptr)
+   static void swap_nodes(node_ptr node1, node_ptr header1, node_ptr node2, node_ptr header2)
    {
       if(node1 == node2)   return;
 
@@ -226,22 +226,22 @@ class rbtree_algorithms
       NodeTraits::set_color(node2, c);
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::replace_node(const node_ptr&,const node_ptr&)
-   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::replace_node(node_ptr,node_ptr)
+   static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node)
    {
       if(node_to_be_replaced == new_node)
          return;
       replace_node(node_to_be_replaced, bstree_algo::get_header(node_to_be_replaced), new_node);
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::replace_node(const node_ptr&,const node_ptr&,const node_ptr&)
-   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::replace_node(node_ptr,node_ptr,node_ptr)
+   static void replace_node(node_ptr node_to_be_replaced, node_ptr header, node_ptr new_node)
    {
       bstree_algo::replace_node(node_to_be_replaced, header, new_node);
       NodeTraits::set_color(new_node, NodeTraits::get_color(node_to_be_replaced));
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::unlink(const node_ptr&)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::unlink(node_ptr)
    static void unlink(const node_ptr& node)
    {
       node_ptr x = NodeTraits::get_parent(node);
@@ -268,19 +268,19 @@ class rbtree_algorithms
    //! @copydoc ::boost::intrusive::bstree_algorithms::prev_node(const node_ptr&)
    static node_ptr prev_node(const node_ptr & node);
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::init(const node_ptr&)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::init(node_ptr)
    static void init(const node_ptr & node);
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::init_header(const node_ptr&)
-   static void init_header(const node_ptr & header)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::init_header(node_ptr)
+   static void init_header(node_ptr header)
    {
       bstree_algo::init_header(header);
       NodeTraits::set_color(header, NodeTraits::red());
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::erase(const node_ptr&,const node_ptr&)
-   static node_ptr erase(const node_ptr & header, const node_ptr & z)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::erase(node_ptr,node_ptr)
+   static node_ptr erase(node_ptr header, node_ptr z)
    {
       typename bstree_algo::data_for_rebalance info;
       bstree_algo::erase(header, z, info);
@@ -291,7 +291,7 @@ class rbtree_algorithms
    //! @copydoc ::boost::intrusive::bstree_algorithms::transfer_unique
    template<class NodePtrCompare>
    static bool transfer_unique
-      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
+      (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z)
    {
       typename bstree_algo::data_for_rebalance info;
       bool const transferred = bstree_algo::transfer_unique(header1, comp, header2, z, info);
@@ -305,7 +305,7 @@ class rbtree_algorithms
    //! @copydoc ::boost::intrusive::bstree_algorithms::transfer_equal
    template<class NodePtrCompare>
    static void transfer_equal
-      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z)
+      (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z)
    {
       typename bstree_algo::data_for_rebalance info;
       bstree_algo::transfer_equal(header1, comp, header2, z, info);
@@ -313,10 +313,10 @@ class rbtree_algorithms
       rebalance_after_insertion(header1, z);
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::clone(const const_node_ptr&,const node_ptr&,Cloner,Disposer)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::clone(const const_node_ptr&,node_ptr,Cloner,Disposer)
    template <class Cloner, class Disposer>
    static void clone
-      (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
+      (const_node_ptr source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
    {
       rbtree_node_cloner<NodeTraits, Cloner> new_cloner(cloner);
       bstree_algo::clone(source_header, target_header, new_cloner, disposer);
@@ -359,54 +359,54 @@ class rbtree_algorithms
 
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_equal_upper_bound(const node_ptr&,const node_ptr&,NodePtrCompare)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_equal_upper_bound(node_ptr,node_ptr,NodePtrCompare)
    template<class NodePtrCompare>
    static node_ptr insert_equal_upper_bound
-      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
+      (node_ptr h, node_ptr new_node, NodePtrCompare comp)
    {
       bstree_algo::insert_equal_upper_bound(h, new_node, comp);
       rebalance_after_insertion(h, new_node);
       return new_node;
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_equal_lower_bound(const node_ptr&,const node_ptr&,NodePtrCompare)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_equal_lower_bound(node_ptr,node_ptr,NodePtrCompare)
    template<class NodePtrCompare>
    static node_ptr insert_equal_lower_bound
-      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp)
+      (node_ptr h, node_ptr new_node, NodePtrCompare comp)
    {
       bstree_algo::insert_equal_lower_bound(h, new_node, comp);
       rebalance_after_insertion(h, new_node);
       return new_node;
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_equal(const node_ptr&,const node_ptr&,const node_ptr&,NodePtrCompare)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_equal(node_ptr,node_ptr,node_ptr,NodePtrCompare)
    template<class NodePtrCompare>
    static node_ptr insert_equal
-      (const node_ptr & header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp)
+      (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp)
    {
       bstree_algo::insert_equal(header, hint, new_node, comp);
       rebalance_after_insertion(header, new_node);
       return new_node;
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_before(const node_ptr&,const node_ptr&,const node_ptr&)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_before(node_ptr,node_ptr,node_ptr)
    static node_ptr insert_before
-      (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node)
+      (node_ptr header, node_ptr pos, node_ptr new_node)
    {
       bstree_algo::insert_before(header, pos, new_node);
       rebalance_after_insertion(header, new_node);
       return new_node;
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::push_back(const node_ptr&,const node_ptr&)
-   static void push_back(const node_ptr & header, const node_ptr & new_node)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::push_back(node_ptr,node_ptr)
+   static void push_back(node_ptr header, node_ptr new_node)
    {
       bstree_algo::push_back(header, new_node);
       rebalance_after_insertion(header, new_node);
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::push_front(const node_ptr&,const node_ptr&)
-   static void push_front(const node_ptr & header, const node_ptr & new_node)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::push_front(node_ptr,node_ptr)
+   static void push_front(node_ptr header, node_ptr new_node)
    {
       bstree_algo::push_front(header, new_node);
       rebalance_after_insertion(header, new_node);
@@ -416,19 +416,19 @@ class rbtree_algorithms
    //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_check(const const_node_ptr&,const KeyType&,KeyNodePtrCompare,insert_commit_data&)
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, bool> insert_unique_check
-      (const const_node_ptr & header,  const KeyType &key
+      (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&)
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, bool> insert_unique_check
-      (const const_node_ptr & header, const node_ptr &hint, const KeyType &key
+      (const_node_ptr header, node_ptr hint, const KeyType &key
       ,KeyNodePtrCompare comp, insert_commit_data &commit_data);
    #endif   //#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_commit(const node_ptr&,const node_ptr&,const insert_commit_data&)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::insert_unique_commit(node_ptr,node_ptr,const insert_commit_data&)
    static void insert_unique_commit
-      (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
+      (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data)
    {
       bstree_algo::insert_unique_commit(header, new_value, commit_data);
       rebalance_after_insertion(header, new_value);
@@ -445,7 +445,7 @@ class rbtree_algorithms
    private:
 
    static void rebalance_after_erasure
-      ( const node_ptr & header, const node_ptr &z, const typename bstree_algo::data_for_rebalance &info)
+      ( node_ptr header, node_ptr z, const typename bstree_algo::data_for_rebalance &info)
    {
       color new_z_color;
       if(info.y != z){
@@ -461,7 +461,7 @@ class rbtree_algorithms
       }
    }
 
-   static void rebalance_after_erasure_restore_invariants(const node_ptr & header, node_ptr x, node_ptr x_parent)
+   static void rebalance_after_erasure_restore_invariants(node_ptr header, node_ptr x, node_ptr x_parent)
    {
       while(1){
          if(x_parent == header || (x && NodeTraits::get_color(x) != NodeTraits::black())){
@@ -545,7 +545,7 @@ class rbtree_algorithms
          NodeTraits::set_color(x, NodeTraits::black());
    }
 
-   static void rebalance_after_insertion(const node_ptr & header, node_ptr p)
+   static void rebalance_after_insertion(node_ptr header, node_ptr p)
    {
       NodeTraits::set_color(p, NodeTraits::red());
       while(1){