passenger 6.0.1 → 6.0.6

data/src/cxx_supportlib/vendor-modified/boost/integer/common_factor_rt.hpp

@@ -223,7 +223,7 @@ namespace boost {
       template <> struct gcd_traits<unsigned char> : public gcd_traits_defaults<unsigned char> 
       { BOOST_FORCEINLINE static unsigned make_odd(unsigned char& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
       template <> struct gcd_traits<signed char> : public gcd_traits_defaults<signed char> 
-      { BOOST_FORCEINLINE static signed make_odd(signed char& val)BOOST_NOEXCEPT{ signed result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
+      { BOOST_FORCEINLINE static unsigned make_odd(signed char& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
       template <> struct gcd_traits<char> : public gcd_traits_defaults<char> 
       { BOOST_FORCEINLINE static unsigned make_odd(char& val)BOOST_NOEXCEPT{ unsigned result = gcd_traits<unsigned long>::find_lsb(val); val >>= result; return result; } };
 #ifndef BOOST_NO_INTRINSIC_WCHAR_T
@@ -310,7 +310,7 @@ namespace boost {
       };
       template <> struct gcd_traits<signed char> : public gcd_traits_defaults<signed char>
       {
-         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR signed make_odd(signed char& val)BOOST_NOEXCEPT { signed result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
+         BOOST_FORCEINLINE static BOOST_CXX14_CONSTEXPR unsigned make_odd(signed char& val)BOOST_NOEXCEPT { unsigned result = gcd_traits<unsigned>::find_lsb(val); val >>= result; return result; }
       };
       template <> struct gcd_traits<char> : public gcd_traits_defaults<char>
       {
@@ -373,8 +373,8 @@ namespace boost {
         if (n == SteinDomain(0))
             return m;
         // m > 0 && n > 0
-        int d_m = gcd_traits<SteinDomain>::make_odd(m);
-        int d_n = gcd_traits<SteinDomain>::make_odd(n);
+        unsigned d_m = gcd_traits<SteinDomain>::make_odd(m);
+        unsigned d_n = gcd_traits<SteinDomain>::make_odd(n);
         // odd(m) && odd(n)
         while (m != n)
         {

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

@@ -42,18 +42,18 @@ struct avltree_node_cloner
    typedef typename NodeTraits::node_ptr  node_ptr;
    typedef detail::ebo_functor_holder<F>  base_t;
 
-   avltree_node_cloner(F f)
+   BOOST_INTRUSIVE_FORCEINLINE avltree_node_cloner(F f)
       :  base_t(f)
    {}
 
-   node_ptr operator()(const node_ptr & p)
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(const node_ptr & p)
    {
       node_ptr n = base_t::get()(p);
       NodeTraits::set_balance(n, NodeTraits::get_balance(p));
       return n;
    }
 
-   node_ptr operator()(const node_ptr & p) const
+   BOOST_INTRUSIVE_FORCEINLINE node_ptr operator()(const node_ptr & p) const
    {
       node_ptr n = base_t::get()(p);
       NodeTraits::set_balance(n, NodeTraits::get_balance(p));
@@ -176,12 +176,12 @@ class avltree_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;
@@ -190,8 +190,8 @@ class avltree_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;
 
@@ -202,23 +202,23 @@ class avltree_algorithms
       NodeTraits::set_balance(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_balance(new_node, NodeTraits::get_balance(node_to_be_replaced));
    }
 
-   //! @copydoc ::boost::intrusive::bstree_algorithms::unlink(const node_ptr&)
-   static void unlink(const node_ptr & node)
+   //! @copydoc ::boost::intrusive::bstree_algorithms::unlink(node_ptr)
+   static void unlink(node_ptr node)
    {
       node_ptr x = NodeTraits::get_parent(node);
       if(x){
@@ -244,7 +244,7 @@ class avltree_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
 
@@ -258,14 +258,14 @@ class avltree_algorithms
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
-   static void init_header(const node_ptr & header)
+   static void init_header(node_ptr header)
    {
       bstree_algo::init_header(header);
       NodeTraits::set_balance(header, NodeTraits::zero());
    }
 
-   //! @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);
@@ -276,7 +276,7 @@ class avltree_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);
@@ -290,7 +290,7 @@ class avltree_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);
@@ -298,10 +298,10 @@ class avltree_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 const_node_ptr & source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
    {
       avltree_node_cloner<NodeTraits, Cloner> new_cloner(cloner);
       bstree_algo::clone(source_header, target_header, new_cloner, disposer);
@@ -344,54 +344,54 @@ class avltree_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);
@@ -411,9 +411,9 @@ class avltree_algorithms
       ,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);
@@ -483,7 +483,7 @@ class avltree_algorithms
    }
 
    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)
    {
       if(info.y != z){
          NodeTraits::set_balance(info.y, NodeTraits::get_balance(z));
@@ -492,7 +492,7 @@ class avltree_algorithms
       rebalance_after_erasure_restore_invariants(header, info.x, info.x_parent);
    }
 
-   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)
    {
       for ( node_ptr root = NodeTraits::get_parent(header)
           ; x != root
@@ -560,7 +560,7 @@ class avltree_algorithms
       }
    }
 
-   static void rebalance_after_insertion(const node_ptr & header, node_ptr x)
+   static void rebalance_after_insertion(node_ptr header, node_ptr x)
    {
       NodeTraits::set_balance(x, NodeTraits::zero());
       // Rebalance.
@@ -605,7 +605,7 @@ class avltree_algorithms
       }
    }
 
-   static void left_right_balancing(const node_ptr & a, const node_ptr & b, const node_ptr & c)
+   static void left_right_balancing(node_ptr a, node_ptr b, node_ptr c)
    {
       // balancing...
       const balance c_balance = NodeTraits::get_balance(c);
@@ -630,7 +630,7 @@ class avltree_algorithms
       }
    }
 
-   static node_ptr avl_rotate_left_right(const node_ptr a, const node_ptr a_oldleft, const node_ptr & hdr)
+   static node_ptr avl_rotate_left_right(const node_ptr a, const node_ptr a_oldleft, node_ptr hdr)
    {  // [note: 'a_oldleft' is 'b']
       //             |                               |         //
       //             a(-2)                           c         //
@@ -650,7 +650,7 @@ class avltree_algorithms
       return c;
    }
 
-   static node_ptr avl_rotate_right_left(const node_ptr a, const node_ptr a_oldright, const node_ptr & hdr)
+   static node_ptr avl_rotate_right_left(const node_ptr a, const node_ptr a_oldright, node_ptr hdr)
    {  // [note: 'a_oldright' is 'b']
       //              |                               |           //
       //              a(pos)                          c           //
@@ -670,7 +670,7 @@ class avltree_algorithms
       return c;
    }
 
-   static void avl_rotate_left(const node_ptr &x, const node_ptr &x_oldright, const node_ptr & hdr)
+   static void avl_rotate_left(node_ptr x, node_ptr x_oldright, node_ptr hdr)
    {
       bstree_algo::rotate_left(x, x_oldright, NodeTraits::get_parent(x), hdr);
 
@@ -685,7 +685,7 @@ class avltree_algorithms
       }
    }
 
-   static void avl_rotate_right(const node_ptr &x, const node_ptr &x_oldleft, const node_ptr & hdr)
+   static void avl_rotate_right(node_ptr x, node_ptr x_oldleft, node_ptr hdr)
    {
       bstree_algo::rotate_right(x, x_oldleft, NodeTraits::get_parent(x), hdr);
 

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

@@ -277,7 +277,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //!   node1 and node2 are not equivalent according to the ordering rules.
    //!
    //!Experimental function
-   static void swap_nodes(const node_ptr & node1, const node_ptr & node2)
+   static void swap_nodes(node_ptr node1, node_ptr node2)
    {
       if(node1 == node2)
          return;
@@ -301,7 +301,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //!   node1 and node2 are not equivalent according to the ordering rules.
    //!
    //!Experimental function
-   static void swap_nodes(const node_ptr & node1, const node_ptr & header1, const node_ptr & node2, const node_ptr & header2)
+   static void swap_nodes(node_ptr node1, node_ptr header1, node_ptr node2, node_ptr header2)
    {
       if(node1 == node2)
          return;
@@ -448,7 +448,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //!   new_node is not equivalent to node_to_be_replaced according to the
    //!   ordering rules. This function is faster than erasing and inserting
    //!   the node, since no rebalancing and comparison is needed. Experimental function
-   BOOST_INTRUSIVE_FORCEINLINE static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
+   BOOST_INTRUSIVE_FORCEINLINE static void replace_node(node_ptr node_to_be_replaced, node_ptr new_node)
    {
       if(node_to_be_replaced == new_node)
          return;
@@ -469,7 +469,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //!   new_node is not equivalent to node_to_be_replaced according to the
    //!   ordering rules. This function is faster than erasing and inserting
    //!   the node, since no rebalancing or comparison is needed. Experimental function
-   static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
+   static void replace_node(node_ptr node_to_be_replaced, node_ptr header, node_ptr new_node)
    {
       if(node_to_be_replaced == new_node)
          return;
@@ -559,7 +559,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
-   BOOST_INTRUSIVE_FORCEINLINE static void init(const node_ptr & node)
+   BOOST_INTRUSIVE_FORCEINLINE static void init(node_ptr node)
    {
       NodeTraits::set_parent(node, node_ptr());
       NodeTraits::set_left(node, node_ptr());
@@ -588,7 +588,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
-   BOOST_INTRUSIVE_FORCEINLINE static void init_header(const node_ptr & header)
+   BOOST_INTRUSIVE_FORCEINLINE static void init_header(node_ptr header)
    {
       NodeTraits::set_parent(header, node_ptr());
       NodeTraits::set_left(header, header);
@@ -629,7 +629,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //!   only be used for more unlink_leftmost_without_rebalance calls.
    //!   This function is normally used to achieve a step by step
    //!   controlled destruction of the tree.
-   static node_ptr unlink_leftmost_without_rebalance(const node_ptr & header)
+   static node_ptr unlink_leftmost_without_rebalance(node_ptr header)
    {
       node_ptr leftmost = NodeTraits::get_left(header);
       if (leftmost == header)
@@ -684,7 +684,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Complexity</b>: Constant.
    //!
    //! <b>Throws</b>: Nothing.
-   static void swap_tree(const node_ptr & header1, const node_ptr & header2)
+   static void swap_tree(node_ptr header1, node_ptr header2)
    {
       if(header1 == header2)
          return;
@@ -956,7 +956,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //!   previously executed to fill "commit_data". No value should be inserted or
    //!   erased between the "insert_check" and "insert_commit" calls.
    BOOST_INTRUSIVE_FORCEINLINE 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)
    {  return insert_commit(header, new_value, commit_data); }
 
    //! <b>Requires</b>: "header" must be the header node of a tree.
@@ -1112,7 +1112,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: If "comp" throws.
    template<class NodePtrCompare>
    static node_ptr insert_equal
-      (const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp
+      (node_ptr h, node_ptr hint, node_ptr new_node, NodePtrCompare comp
          #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
          , std::size_t *pdepth = 0
          #endif
@@ -1138,7 +1138,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: If "comp" throws.
    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
          #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
          , std::size_t *pdepth = 0
          #endif
@@ -1164,7 +1164,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: If "comp" throws.
    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
          #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
          , std::size_t *pdepth = 0
          #endif
@@ -1191,7 +1191,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Note</b>: If "pos" is not the successor of the newly inserted "new_node"
    //! tree invariants might be broken.
    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
          #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
          , std::size_t *pdepth = 0
          #endif
@@ -1217,7 +1217,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! tree invariants are broken. This function is slightly faster than
    //! using "insert_before".
    static void push_back
-      (const node_ptr & header, const node_ptr & new_node
+      (node_ptr header, node_ptr new_node
          #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
          , std::size_t *pdepth = 0
          #endif
@@ -1242,7 +1242,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! tree invariants are broken. This function is slightly faster than
    //! using "insert_before".
    static void push_front
-      (const node_ptr & header, const node_ptr & new_node
+      (node_ptr header, node_ptr new_node
          #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
          , std::size_t *pdepth = 0
          #endif
@@ -1292,7 +1292,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: If cloner functor throws. If this happens target nodes are disposed.
    template <class Cloner, class Disposer>
    static void clone
-      (const const_node_ptr & source_header, const node_ptr & target_header, Cloner cloner, Disposer disposer)
+      (const const_node_ptr & source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
    {
       if(!unique(target_header)){
          clear_and_dispose(target_header, disposer);
@@ -1316,7 +1316,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Complexity</b>: Amortized constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   BOOST_INTRUSIVE_FORCEINLINE static void erase(const node_ptr & header, const node_ptr & z)
+   BOOST_INTRUSIVE_FORCEINLINE static void erase(node_ptr header, node_ptr z)
    {
       data_for_rebalance ignored;
       erase(header, z, ignored);
@@ -1336,7 +1336,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: If the comparison throws.
    template<class NodePtrCompare>
    BOOST_INTRUSIVE_FORCEINLINE 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)
    {
       data_for_rebalance ignored;
       return transfer_unique(header1, comp, header2, z, ignored);
@@ -1353,7 +1353,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: If the comparison throws.
    template<class NodePtrCompare>
    BOOST_INTRUSIVE_FORCEINLINE 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)
    {
       data_for_rebalance ignored;
       transfer_equal(header1, comp, header2, z, ignored);
@@ -1366,7 +1366,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Complexity</b>: Average complexity is constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static void unlink(const node_ptr & node)
+   static void unlink(node_ptr node)
    {
       node_ptr x = NodeTraits::get_parent(node);
       if(x){
@@ -1383,7 +1383,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear.
-   static void rebalance(const node_ptr & header)
+   static void rebalance(node_ptr header)
    {
       node_ptr root = NodeTraits::get_parent(header);
       if(root){
@@ -1400,7 +1400,7 @@ class bstree_algorithms : public bstree_algorithms_base
    //! <b>Throws</b>: Nothing.
    //!
    //! <b>Complexity</b>: Linear.
-   static node_ptr rebalance_subtree(const node_ptr & old_root)
+   static node_ptr rebalance_subtree(node_ptr old_root)
    {
       //Taken from:
       //"Tree rebalancing in optimal time and space"
@@ -1476,7 +1476,7 @@ class bstree_algorithms : public bstree_algorithms_base
 
    template<class NodePtrCompare>
    static bool transfer_unique
-      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z, data_for_rebalance &info)
+      (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z, data_for_rebalance &info)
    {
       insert_commit_data commit_data;
       bool const transferable = insert_unique_check(header1, z, comp, commit_data).second;
@@ -1489,7 +1489,7 @@ class bstree_algorithms : public bstree_algorithms_base
 
    template<class NodePtrCompare>
    static void transfer_equal
-      (const node_ptr & header1, NodePtrCompare comp, const node_ptr &header2, const node_ptr & z, data_for_rebalance &info)
+      (node_ptr header1, NodePtrCompare comp, node_ptr header2, node_ptr z, data_for_rebalance &info)
    {
       insert_commit_data commit_data;
       insert_equal_upper_bound_check(header1, z, comp, commit_data);
@@ -1497,7 +1497,7 @@ class bstree_algorithms : public bstree_algorithms_base
       insert_commit(header1, z, commit_data);
    }
 
-   static void erase(const node_ptr & header, const node_ptr & z, data_for_rebalance &info)
+   static void erase(node_ptr header, node_ptr z, data_for_rebalance &info)
    {
       node_ptr y(z);
       node_ptr x;
@@ -1643,7 +1643,7 @@ class bstree_algorithms : public bstree_algorithms_base
    {  return NodeTraits::get_right(NodeTraits::get_parent(p)) == p;  }
 
    static void insert_before_check
-      (const node_ptr &header, const node_ptr & pos
+      (node_ptr header, node_ptr pos
       , insert_commit_data &commit_data
          #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
          , std::size_t *pdepth = 0
@@ -1662,7 +1662,7 @@ class bstree_algorithms : public bstree_algorithms_base
    }
 
    static void push_back_check
-      (const node_ptr & header, insert_commit_data &commit_data
+      (node_ptr header, insert_commit_data &commit_data
          #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
          , std::size_t *pdepth = 0
          #endif
@@ -1677,7 +1677,7 @@ class bstree_algorithms : public bstree_algorithms_base
    }
 
    static void push_front_check
-      (const node_ptr & header, insert_commit_data &commit_data
+      (node_ptr header, insert_commit_data &commit_data
          #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
          , std::size_t *pdepth = 0
          #endif
@@ -1693,7 +1693,7 @@ class bstree_algorithms : public bstree_algorithms_base
 
    template<class NodePtrCompare>
    static void insert_equal_check
-      (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
       , insert_commit_data &commit_data
       /// @cond
       , std::size_t *pdepth = 0
@@ -1722,7 +1722,7 @@ class bstree_algorithms : public bstree_algorithms_base
 
    template<class NodePtrCompare>
    static void insert_equal_upper_bound_check
-      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
+      (node_ptr h, node_ptr new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
    {
       std::size_t depth = 0;
       node_ptr y(h);
@@ -1741,7 +1741,7 @@ class bstree_algorithms : public bstree_algorithms_base
 
    template<class NodePtrCompare>
    static void insert_equal_lower_bound_check
-      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
+      (node_ptr h, node_ptr new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
    {
       std::size_t depth = 0;
       node_ptr y(h);
@@ -1759,7 +1759,7 @@ class bstree_algorithms : public bstree_algorithms_base
    }
 
    static void insert_commit
-      (const node_ptr & header, const node_ptr & new_node, const insert_commit_data &commit_data)
+      (node_ptr header, node_ptr new_node, const insert_commit_data &commit_data)
    {
       //Check if commit_data has not been initialized by a insert_unique_check call.
       BOOST_INTRUSIVE_INVARIANT_ASSERT(commit_data.node != node_ptr());
@@ -1785,7 +1785,7 @@ class bstree_algorithms : public bstree_algorithms_base
    }
 
    //Fix header and own's parent data when replacing x with own, providing own's old data with parent
-   static void set_child(const node_ptr & header, const node_ptr & new_child, const node_ptr & new_parent, const bool link_left)
+   static void set_child(node_ptr header, node_ptr new_child, node_ptr new_parent, const bool link_left)
    {
       if(new_parent == header)
          NodeTraits::set_parent(header, new_child);
@@ -1796,7 +1796,7 @@ class bstree_algorithms : public bstree_algorithms_base
    }
 
    // rotate p to left (no header and p's parent fixup)
-   static void rotate_left_no_parent_fix(const node_ptr & p, const node_ptr &p_right)
+   static void rotate_left_no_parent_fix(node_ptr p, node_ptr p_right)
    {
       node_ptr p_right_left(NodeTraits::get_left(p_right));
       NodeTraits::set_right(p, p_right_left);
@@ -1808,7 +1808,7 @@ class bstree_algorithms : public bstree_algorithms_base
    }
 
    // rotate p to left (with header and p's parent fixup)
-   static void rotate_left(const node_ptr & p, const node_ptr & p_right, const node_ptr & p_parent, const node_ptr & header)
+   static void rotate_left(node_ptr p, node_ptr p_right, node_ptr p_parent, node_ptr header)
    {
       const bool p_was_left(NodeTraits::get_left(p_parent) == p);
       rotate_left_no_parent_fix(p, p_right);
@@ -1817,7 +1817,7 @@ class bstree_algorithms : public bstree_algorithms_base
    }
 
    // rotate p to right (no header and p's parent fixup)
-   static void rotate_right_no_parent_fix(const node_ptr & p, const node_ptr &p_left)
+   static void rotate_right_no_parent_fix(node_ptr p, node_ptr p_left)
    {
       node_ptr p_left_right(NodeTraits::get_right(p_left));
       NodeTraits::set_left(p, p_left_right);
@@ -1829,7 +1829,7 @@ class bstree_algorithms : public bstree_algorithms_base
    }
 
    // rotate p to right (with header and p's parent fixup)
-   static void rotate_right(const node_ptr & p, const node_ptr & p_left, const node_ptr & p_parent, const node_ptr & header)
+   static void rotate_right(node_ptr p, node_ptr p_left, node_ptr p_parent, node_ptr header)
    {
       const bool p_was_left(NodeTraits::get_left(p_parent) == p);
       rotate_right_no_parent_fix(p, p_left);
@@ -1883,7 +1883,7 @@ class bstree_algorithms : public bstree_algorithms_base
       }
    }
 
-   static void vine_to_subtree(const node_ptr & super_root, std::size_t count)
+   static void vine_to_subtree(node_ptr super_root, std::size_t count)
    {
       const std::size_t one_szt = 1u;
       std::size_t leaf_nodes = count + one_szt - std::size_t(one_szt << detail::floor_log2(count + one_szt));
@@ -1927,7 +1927,7 @@ class bstree_algorithms : public bstree_algorithms_base
 
    template <class Cloner, class Disposer>
    static node_ptr clone_subtree
-      (const const_node_ptr &source_parent, const node_ptr &target_parent
+      (const const_node_ptr &source_parent, node_ptr target_parent
       , Cloner cloner, Disposer disposer
       , node_ptr &leftmost_out, node_ptr &rightmost_out
       )