passenger 5.0.24 → 5.0.25

data/src/cxx_supportlib/vendor-modified/boost/intrusive/{detail/tree_algorithms.hpp → bstree_algorithms.hpp}

@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 //
-// (C) Copyright Ion Gaztanaga  2007-2012
+// (C) Copyright Ion Gaztanaga  2007-2014
 //
 // Distributed under the Boost Software License, Version 1.0.
 //    (See accompanying file LICENSE_1_0.txt or copy at
@@ -10,20 +10,93 @@
 //
 /////////////////////////////////////////////////////////////////////////////
 
-#ifndef BOOST_INTRUSIVE_TREE_ALGORITHMS_HPP
-#define BOOST_INTRUSIVE_TREE_ALGORITHMS_HPP
+#ifndef BOOST_INTRUSIVE_BSTREE_ALGORITHMS_HPP
+#define BOOST_INTRUSIVE_BSTREE_ALGORITHMS_HPP
 
+#include <cstddef>
 #include <boost/intrusive/detail/config_begin.hpp>
-#include <boost/intrusive/detail/assert.hpp>
 #include <boost/intrusive/intrusive_fwd.hpp>
-#include <cstddef>
-#include <boost/intrusive/detail/utilities.hpp>
-#include <boost/intrusive/pointer_traits.hpp>
+#include <boost/intrusive/detail/bstree_algorithms_base.hpp>
+#include <boost/intrusive/detail/assert.hpp>
+#include <boost/intrusive/detail/uncast.hpp>
+#include <boost/intrusive/detail/math.hpp>
+#include <boost/intrusive/detail/algo_type.hpp>
+
+#include <boost/intrusive/detail/minimal_pair_header.hpp>
+
+#if defined(BOOST_HAS_PRAGMA_ONCE)
+#  pragma once
+#endif
 
 namespace boost {
 namespace intrusive {
+
+/// @cond
+
+//! This type is the information that will be filled by insert_unique_check
+template <class NodePtr>
+struct insert_commit_data_t
+{
+   bool     link_left;
+   NodePtr  node;
+};
+
+template <class NodePtr>
+struct data_for_rebalance_t
+{
+   NodePtr  x;
+   NodePtr  x_parent;
+   NodePtr  y;
+};
+
 namespace detail {
 
+template<class ValueTraits, class NodePtrCompare, class ExtraChecker>
+struct bstree_node_checker
+   : public ExtraChecker
+{
+   typedef ExtraChecker                            base_checker_t;
+   typedef ValueTraits                             value_traits;
+   typedef typename value_traits::node_traits      node_traits;
+   typedef typename node_traits::const_node_ptr    const_node_ptr;
+
+   struct return_type
+      : public base_checker_t::return_type
+   {
+      return_type() : min_key_node_ptr(const_node_ptr()), max_key_node_ptr(const_node_ptr()), node_count(0) {}
+
+      const_node_ptr min_key_node_ptr;
+      const_node_ptr max_key_node_ptr;
+      size_t   node_count;
+   };
+
+   bstree_node_checker(const NodePtrCompare& comp, ExtraChecker extra_checker)
+      : base_checker_t(extra_checker), comp_(comp)
+   {}
+
+   void operator () (const const_node_ptr& p,
+                     const return_type& check_return_left, const return_type& check_return_right,
+                     return_type& check_return)
+   {
+      if (check_return_left.max_key_node_ptr)
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(!comp_(p, check_return_left.max_key_node_ptr));
+      if (check_return_right.min_key_node_ptr)
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(!comp_(check_return_right.min_key_node_ptr, p));
+      check_return.min_key_node_ptr = node_traits::get_left(p)? check_return_left.min_key_node_ptr : p;
+      check_return.max_key_node_ptr = node_traits::get_right(p)? check_return_right.max_key_node_ptr : p;
+      check_return.node_count = check_return_left.node_count + check_return_right.node_count + 1;
+      base_checker_t::operator()(p, check_return_left, check_return_right, check_return);
+   }
+
+   const NodePtrCompare comp_;
+};
+
+} // namespace detail
+
+/// @endcond
+
+
+
 //!   This is an implementation of a binary search tree.
 //!   A node in the search tree has references to its children and its parent. This
 //!   is to allow traversal of the whole tree from a given node making the
@@ -66,14 +139,13 @@ namespace detail {
 //!                       |         |   |         |   |         |   |         |
 //!                       +---------+   +---------+   +---------+   +---------+
 //!
-
-//! tree_algorithms is configured with a NodeTraits class, which encapsulates the
+//! bstree_algorithms is configured with a NodeTraits class, which encapsulates the
 //! information about the node to be manipulated. NodeTraits must support the
 //! following interface:
 //!
 //! <b>Typedefs</b>:
 //!
-//! <tt>node</tt>: The type of the node that forms the circular list
+//! <tt>node</tt>: The type of the node that forms the binary search tree
 //!
 //! <tt>node_ptr</tt>: A pointer to a node
 //!
@@ -93,31 +165,19 @@ namespace detail {
 //!
 //! <tt>static void set_right(node_ptr n, node_ptr right);</tt>
 template<class NodeTraits>
-class tree_algorithms
+class bstree_algorithms : public bstree_algorithms_base<NodeTraits>
 {
    public:
    typedef typename NodeTraits::node            node;
    typedef NodeTraits                           node_traits;
    typedef typename NodeTraits::node_ptr        node_ptr;
    typedef typename NodeTraits::const_node_ptr  const_node_ptr;
-
-   //! This type is the information that will be filled by insert_unique_check
-   struct insert_commit_data
-   {
-      insert_commit_data()
-         :  link_left(false)
-         ,  node()
-      {}
-      bool     link_left;
-      node_ptr node;
-   };
-
-   struct nop_erase_fixup
-   {
-      void operator()(const node_ptr&, const node_ptr&){}
-   };
+   typedef insert_commit_data_t<node_ptr>       insert_commit_data;
+   typedef data_for_rebalance_t<node_ptr>       data_for_rebalance;
 
    /// @cond
+   typedef bstree_algorithms<NodeTraits>        this_type;
+   typedef bstree_algorithms_base<NodeTraits>   base_type;
    private:
    template<class Disposer>
    struct dispose_subtree_disposer
@@ -136,22 +196,46 @@ class tree_algorithms
          }
       }
       Disposer *disposer_;
-      node_ptr subtree_;
+      const node_ptr subtree_;
    };
 
-   static node_ptr uncast(const const_node_ptr & ptr)
-   {  return pointer_traits<node_ptr>::const_cast_from(ptr);  }
-
    /// @endcond
 
    public:
+   //! <b>Requires</b>: 'header' is the header node of a tree.
+   //!
+   //! <b>Effects</b>: Returns the first node of the tree, the header if the tree is empty.
+   //!
+   //! <b>Complexity</b>: Constant time.
+   //!
+   //! <b>Throws</b>: Nothing.
    static node_ptr begin_node(const const_node_ptr & header)
    {  return node_traits::get_left(header);   }
 
+   //! <b>Requires</b>: 'header' is the header node of a tree.
+   //!
+   //! <b>Effects</b>: Returns the header of the tree.
+   //!
+   //! <b>Complexity</b>: Constant time.
+   //!
+   //! <b>Throws</b>: Nothing.
    static node_ptr end_node(const const_node_ptr & header)
-   {  return uncast(header);   }
+   {  return detail::uncast(header);   }
+
+   //! <b>Requires</b>: 'header' is the header node of a tree.
+   //!
+   //! <b>Effects</b>: Returns the root of the tree if any, header otherwise
+   //!
+   //! <b>Complexity</b>: Constant time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   static node_ptr root_node(const const_node_ptr & header)
+   {
+      node_ptr p = node_traits::get_parent(header);
+      return p ? p : detail::uncast(header);
+   }
 
-   //! <b>Requires</b>: 'node' is a node of the tree or an node initialized
+   //! <b>Requires</b>: 'node' is a node of the tree or a node initialized
    //!   by init(...) or init_node.
    //!
    //! <b>Effects</b>: Returns true if the node is initialized by init() or init_node().
@@ -162,16 +246,16 @@ class tree_algorithms
    static bool unique(const const_node_ptr & node)
    { return !NodeTraits::get_parent(node); }
 
-   static node_ptr get_header(const const_node_ptr & node)
-   {
-      node_ptr h = uncast(node);
-      if(NodeTraits::get_parent(node)){
-         h = NodeTraits::get_parent(node);
-         while(!is_header(h))
-            h = NodeTraits::get_parent(h);
-      }
-      return h;
-   }
+   #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
+   //! <b>Requires</b>: 'node' is a node of the tree or a header node.
+   //!
+   //! <b>Effects</b>: Returns the header of the tree.
+   //!
+   //! <b>Complexity</b>: Logarithmic.
+   //!
+   //! <b>Throws</b>: Nothing.
+   static node_ptr get_header(const const_node_ptr & node);
+   #endif
 
    //! <b>Requires</b>: node1 and node2 can't be header nodes
    //!  of two trees.
@@ -193,7 +277,7 @@ class tree_algorithms
       if(node1 == node2)
          return;
 
-      node_ptr header1(get_header(node1)), header2(get_header(node2));
+      node_ptr header1(base_type::get_header(node1)), header2(base_type::get_header(node2));
       swap_nodes(node1, header1, node2, header2);
    }
 
@@ -358,14 +442,12 @@ class tree_algorithms
    //! <b>Note</b>: This function will break container ordering invariants if
    //!   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
+   //!   the node, since no rebalancing and comparison is needed. Experimental function
    static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & new_node)
    {
       if(node_to_be_replaced == new_node)
          return;
-      replace_node(node_to_be_replaced, get_header(node_to_be_replaced), new_node);
+      replace_node(node_to_be_replaced, base_type::get_header(node_to_be_replaced), new_node);
    }
 
    //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree
@@ -381,9 +463,7 @@ class tree_algorithms
    //! <b>Note</b>: This function will break container ordering invariants if
    //!   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
+   //!   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)
    {
       if(node_to_be_replaced == new_node)
@@ -427,6 +507,7 @@ class tree_algorithms
       }
    }
 
+   #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
    //! <b>Requires</b>: 'node' is a node from the tree except the header.
    //!
    //! <b>Effects</b>: Returns the next node of the tree.
@@ -434,22 +515,7 @@ class tree_algorithms
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr next_node(const node_ptr & node)
-   {
-      node_ptr p_right(NodeTraits::get_right(node));
-      if(p_right){
-         return minimum(p_right);
-      }
-      else {
-         node_ptr p(node);
-         node_ptr x = NodeTraits::get_parent(p);
-         while(p == NodeTraits::get_right(x)){
-            p = x;
-            x = NodeTraits::get_parent(x);
-         }
-         return NodeTraits::get_right(p) != x ? x : uncast(p);
-      }
-   }
+   static node_ptr next_node(const node_ptr & node);
 
    //! <b>Requires</b>: 'node' is a node from the tree except the leftmost node.
    //!
@@ -458,25 +524,7 @@ class tree_algorithms
    //! <b>Complexity</b>: Average constant time.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr prev_node(const node_ptr & node)
-   {
-      if(is_header(node)){
-         return NodeTraits::get_right(node);
-         //return maximum(NodeTraits::get_parent(node));
-      }
-      else if(NodeTraits::get_left(node)){
-         return maximum(NodeTraits::get_left(node));
-      }
-      else {
-         node_ptr p(node);
-         node_ptr x = NodeTraits::get_parent(p);
-         while(p == NodeTraits::get_left(x)){
-            p = x;
-            x = NodeTraits::get_parent(x);
-         }
-         return x;
-      }
-   }
+   static node_ptr prev_node(const node_ptr & node);
 
    //! <b>Requires</b>: 'node' is a node of a tree but not the header.
    //!
@@ -485,15 +533,7 @@ class tree_algorithms
    //! <b>Complexity</b>: Logarithmic to the size of the subtree.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr minimum (node_ptr node)
-   {
-      for(node_ptr p_left = NodeTraits::get_left(node)
-         ;p_left
-         ;p_left = NodeTraits::get_left(node)){
-         node = p_left;
-      }
-      return node;
-   }
+   static node_ptr minimum(node_ptr node);
 
    //! <b>Requires</b>: 'node' is a node of a tree but not the header.
    //!
@@ -502,15 +542,8 @@ class tree_algorithms
    //! <b>Complexity</b>: Logarithmic to the size of the subtree.
    //!
    //! <b>Throws</b>: Nothing.
-   static node_ptr maximum(node_ptr node)
-   {
-      for(node_ptr p_right = NodeTraits::get_right(node)
-         ;p_right
-         ;p_right = NodeTraits::get_right(node)){
-         node = p_right;
-      }
-      return node;
-   }
+   static node_ptr maximum(node_ptr node);
+   #endif
 
    //! <b>Requires</b>: 'node' must not be part of any tree.
    //!
@@ -602,7 +635,7 @@ class tree_algorithms
 
       if (leftmost_right){
          NodeTraits::set_parent(leftmost_right, leftmost_parent);
-         NodeTraits::set_left(header, tree_algorithms::minimum(leftmost_right));
+         NodeTraits::set_left(header, base_type::minimum(leftmost_right));
 
          if (is_root)
             NodeTraits::set_parent(header, leftmost_right);
@@ -621,42 +654,6 @@ class tree_algorithms
       return leftmost;
    }
 
-   //! <b>Requires</b>: node is a node of the tree but it's not the header.
-   //!
-   //! <b>Effects</b>: Returns the number of nodes of the subtree.
-   //!
-   //! <b>Complexity</b>: Linear time.
-   //!
-   //! <b>Throws</b>: Nothing.
-   static std::size_t count(const const_node_ptr & subtree)
-   {
-      if(!subtree) return 0;
-      std::size_t count = 0;
-      node_ptr p = minimum(uncast(subtree));
-      bool continue_looping = true;
-      while(continue_looping){
-         ++count;
-         node_ptr p_right(NodeTraits::get_right(p));
-         if(p_right){
-            p = minimum(p_right);
-         }
-         else {
-            for(;;){
-               node_ptr q;
-               if (p == subtree){
-                  continue_looping = false;
-                  break;
-               }
-               q = p;
-               p = NodeTraits::get_parent(p);
-               if (NodeTraits::get_left(p) == q)
-                  break;
-            }
-         }
-      }
-      return count;
-   }
-
    //! <b>Requires</b>: node is a node of the tree but it's not the header.
    //!
    //! <b>Effects</b>: Returns the number of nodes of the subtree.
@@ -669,7 +666,7 @@ class tree_algorithms
       node_ptr beg(begin_node(header));
       node_ptr end(end_node(header));
       std::size_t i = 0;
-      for(;beg != end; beg = next_node(beg)) ++i;
+      for(;beg != end; beg = base_type::next_node(beg)) ++i;
       return i;
    }
 
@@ -722,29 +719,23 @@ class tree_algorithms
       }
    }
 
-   static bool is_header(const const_node_ptr & p)
-   {
-      node_ptr p_left (NodeTraits::get_left(p));
-      node_ptr p_right(NodeTraits::get_right(p));
-      if(!NodeTraits::get_parent(p) || //Header condition when empty tree
-         (p_left && p_right &&         //Header always has leftmost and rightmost
-            (p_left == p_right ||      //Header condition when only node
-               (NodeTraits::get_parent(p_left)  != p ||
-                NodeTraits::get_parent(p_right) != p ))
-               //When tree size > 1 headers can't be leftmost's
-               //and rightmost's parent
-          )){
-         return true;
-      }
-      return false;
-   }
+   #if defined(BOOST_INTRUSIVE_DOXYGEN_INVOKED)
+   //! <b>Requires</b>: p is a node of a tree.
+   //!
+   //! <b>Effects</b>: Returns true if p is the header of the tree.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Throws</b>: Nothing.
+   static bool is_header(const const_node_ptr & p);
+   #endif
 
    //! <b>Requires</b>: "header" must be the header node of a tree.
    //!   KeyNodePtrCompare is a function object that induces a strict weak
    //!   ordering compatible with the strict weak ordering used to create the
    //!   the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs.
    //!
-   //! <b>Effects</b>: Returns an node_ptr to the element that is equivalent to
+   //! <b>Effects</b>: Returns a node_ptr to the first element that is equivalent to
    //!   "key" according to "comp" or "header" if that element does not exist.
    //!
    //! <b>Complexity</b>: Logarithmic.
@@ -754,7 +745,7 @@ class tree_algorithms
    static node_ptr find
       (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
    {
-      node_ptr end = uncast(header);
+      node_ptr end = detail::uncast(header);
       node_ptr y = lower_bound(header, key, comp);
       return (y == end || comp(key, y)) ? end : y;
    }
@@ -764,7 +755,7 @@ class tree_algorithms
    //!   ordering compatible with the strict weak ordering used to create the
    //!   the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs.
    //!   'lower_key' must not be greater than 'upper_key' according to 'comp'. If
-   //!   'lower_key' == 'upper_key', ('left_closed' || 'right_closed') must be false.
+   //!   'lower_key' == 'upper_key', ('left_closed' || 'right_closed') must be true.
    //!
    //! <b>Effects</b>: Returns an a pair with the following criteria:
    //!
@@ -778,6 +769,8 @@ class tree_algorithms
    //!
    //! <b>Note</b>: This function can be more efficient than calling upper_bound
    //!   and lower_bound for lower_key and upper_key.
+   //!
+   //! <b>Note</b>: Experimental function, the interface might change.
    template< class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, node_ptr> bounded_range
       ( const const_node_ptr & header
@@ -787,7 +780,7 @@ class tree_algorithms
       , bool left_closed
       , bool right_closed)
    {
-      node_ptr y = uncast(header);
+      node_ptr y = detail::uncast(header);
       node_ptr x = NodeTraits::get_parent(header);
 
       while(x){
@@ -801,12 +794,11 @@ class tree_algorithms
          //If the upper_key is less than x, the target
          //range is on the left part
          else if(comp(upper_key, x)){
-            //y > upper_key
             y = x;
             x = NodeTraits::get_left(x);
          }
          else{
-            //x is inside the bounded range( x >= lower_key && x <= upper_key),
+            //x is inside the bounded range(lower_key <= x <= upper_key),
             //so we must split lower and upper searches
             //
             //Sanity check: if lower_key and upper_key are equal, then both left_closed and right_closed can't be false
@@ -835,6 +827,30 @@ class tree_algorithms
       return std::pair<node_ptr,node_ptr> (y, y);
    }
 
+   //! <b>Requires</b>: "header" must be the header node of a tree.
+   //!   KeyNodePtrCompare is a function object that induces a strict weak
+   //!   ordering compatible with the strict weak ordering used to create the
+   //!   the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs.
+   //!
+   //! <b>Effects</b>: Returns the number of elements with a key equivalent to "key"
+   //!   according to "comp".
+   //!
+   //! <b>Complexity</b>: Logarithmic.
+   //!
+   //! <b>Throws</b>: If "comp" throws.
+   template<class KeyType, class KeyNodePtrCompare>
+   static std::size_t count
+      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
+   {
+      std::pair<node_ptr, node_ptr> ret = equal_range(header, key, comp);
+      std::size_t n = 0;
+      while(ret.first != ret.second){
+         ++n;
+         ret.first = base_type::next_node(ret.first);
+      }
+      return n;
+   }
+
    //! <b>Requires</b>: "header" must be the header node of a tree.
    //!   KeyNodePtrCompare is a function object that induces a strict weak
    //!   ordering compatible with the strict weak ordering used to create the
@@ -860,7 +876,32 @@ class tree_algorithms
    //!   ordering compatible with the strict weak ordering used to create the
    //!   the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs.
    //!
-   //! <b>Effects</b>: Returns an node_ptr to the first element that is
+   //! <b>Effects</b>: Returns an a pair of node_ptr delimiting a range containing
+   //!   the first element that is equivalent to "key" according to "comp" or an
+   //!   empty range that indicates the position where that element would be
+   //!   if there are no equivalent elements.
+   //!
+   //! <b>Complexity</b>: Logarithmic.
+   //!
+   //! <b>Throws</b>: If "comp" throws.
+   template<class KeyType, class KeyNodePtrCompare>
+   static std::pair<node_ptr, node_ptr> lower_bound_range
+      (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
+   {
+      node_ptr const lb(lower_bound(header, key, comp));
+      std::pair<node_ptr, node_ptr> ret_ii(lb, lb);
+      if(lb != header && !comp(key, lb)){
+         ret_ii.second = base_type::next_node(ret_ii.second);
+      }
+      return ret_ii;
+   }
+
+   //! <b>Requires</b>: "header" must be the header node of a tree.
+   //!   KeyNodePtrCompare is a function object that induces a strict weak
+   //!   ordering compatible with the strict weak ordering used to create the
+   //!   the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs.
+   //!
+   //! <b>Effects</b>: Returns a node_ptr to the first element that is
    //!   not less than "key" according to "comp" or "header" if that element does
    //!   not exist.
    //!
@@ -871,7 +912,7 @@ class tree_algorithms
    static node_ptr lower_bound
       (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
    {
-      return lower_bound_loop(NodeTraits::get_parent(header), uncast(header), key, comp);
+      return lower_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp);
    }
 
    //! <b>Requires</b>: "header" must be the header node of a tree.
@@ -879,7 +920,7 @@ class tree_algorithms
    //!   ordering compatible with the strict weak ordering used to create the
    //!   the tree. KeyNodePtrCompare can compare KeyType with tree's node_ptrs.
    //!
-   //! <b>Effects</b>: Returns an node_ptr to the first element that is greater
+   //! <b>Effects</b>: Returns a node_ptr to the first element that is greater
    //!   than "key" according to "comp" or "header" if that element does not exist.
    //!
    //! <b>Complexity</b>: Logarithmic.
@@ -889,7 +930,7 @@ class tree_algorithms
    static node_ptr upper_bound
       (const const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
    {
-      return upper_bound_loop(NodeTraits::get_parent(header), uncast(header), key, comp);
+      return upper_bound_loop(NodeTraits::get_parent(header), detail::uncast(header), key, comp);
    }
 
    //! <b>Requires</b>: "header" must be the header node of a tree.
@@ -913,32 +954,6 @@ class tree_algorithms
       (const node_ptr & header, const node_ptr & new_value, const insert_commit_data &commit_data)
    {  return insert_commit(header, new_value, commit_data); }
 
-   static void insert_commit
-      (const node_ptr & header, const 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());
-      node_ptr parent_node(commit_data.node);
-      if(parent_node == header){
-         NodeTraits::set_parent(header, new_node);
-         NodeTraits::set_right(header, new_node);
-         NodeTraits::set_left(header, new_node);
-      }
-      else if(commit_data.link_left){
-         NodeTraits::set_left(parent_node, new_node);
-         if(parent_node == NodeTraits::get_left(header))
-             NodeTraits::set_left(header, new_node);
-      }
-      else{
-         NodeTraits::set_right(parent_node, new_node);
-         if(parent_node == NodeTraits::get_right(header))
-             NodeTraits::set_right(header, new_node);
-      }
-      NodeTraits::set_parent(new_node, parent_node);
-      NodeTraits::set_right(new_node, node_ptr());
-      NodeTraits::set_left(new_node, node_ptr());
-   }
-
    //! <b>Requires</b>: "header" must be the header node of a tree.
    //!   KeyNodePtrCompare is a function object that induces a strict weak
    //!   ordering compatible with the strict weak ordering used to create the
@@ -975,11 +990,15 @@ class tree_algorithms
    //!   if no more objects are inserted or erased from the set.
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, bool> insert_unique_check
-      (const const_node_ptr & header,  const KeyType &key
-      ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0)
+      (const const_node_ptr & header, const KeyType &key
+      ,KeyNodePtrCompare comp, insert_commit_data &commit_data
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
    {
       std::size_t depth = 0;
-      node_ptr h(uncast(header));
+      node_ptr h(detail::uncast(header));
       node_ptr y(h);
       node_ptr x(NodeTraits::get_parent(y));
       node_ptr prev = node_ptr();
@@ -999,28 +1018,67 @@ class tree_algorithms
       //Since we've found the upper bound there is no other value with the same key if:
       //    - There is no previous node
       //    - The previous node is less than the key
-      if(!prev || comp(prev, key)){
+      const bool not_present = !prev || comp(prev, key);
+      if(not_present){
          commit_data.link_left = left_child;
          commit_data.node      = y;
-         return std::pair<node_ptr, bool>(node_ptr(), true);
-      }
-      //If the previous value was not less than key, it means that it's equal
-      //(because we've checked the upper bound)
-      else{
-         return std::pair<node_ptr, bool>(prev, false);
       }
+      return std::pair<node_ptr, bool>(prev, not_present);
    }
 
+   //! <b>Requires</b>: "header" must be the header node of a tree.
+   //!   KeyNodePtrCompare is a function object that induces a strict weak
+   //!   ordering compatible with the strict weak ordering used to create the
+   //!   the tree. NodePtrCompare compares KeyType with a node_ptr.
+   //!   "hint" is node from the "header"'s tree.
+   //!
+   //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the
+   //!   tree according to "comp" using "hint" as a hint to where it should be
+   //!   inserted and obtains the needed information to realize
+   //!   a constant-time node insertion if there is no equivalent node.
+   //!   If "hint" is the upper_bound the function has constant time
+   //!   complexity (two comparisons in the worst case).
+   //!
+   //! <b>Returns</b>: If there is an equivalent value
+   //!   returns a pair containing a node_ptr to the already present node
+   //!   and false. If there is not equivalent key can be inserted returns true
+   //!   in the returned pair's boolean and fills "commit_data" that is meant to
+   //!   be used with the "insert_commit" function to achieve a constant-time
+   //!   insertion function.
+   //!
+   //! <b>Complexity</b>: Average complexity is at most logarithmic, but it is
+   //!   amortized constant time if new_node should be inserted immediately before "hint".
+   //!
+   //! <b>Throws</b>: If "comp" throws.
+   //!
+   //! <b>Notes</b>: This function is used to improve performance when constructing
+   //!   a node is expensive and the user does not want to have two equivalent nodes
+   //!   in the tree: if there is an equivalent value
+   //!   the constructed object must be discarded. Many times, the part of the
+   //!   node that is used to impose the order is much cheaper to construct
+   //!   than the node and this function offers the possibility to use that part
+   //!   to check if the insertion will be successful.
+   //!
+   //!   If the check is successful, the user can construct the node and use
+   //!   "insert_commit" to insert the node in constant-time. This gives a total
+   //!   logarithmic complexity to the insertion: check(O(log(N)) + commit(O(1)).
+   //!
+   //!   "commit_data" remains valid for a subsequent "insert_unique_commit" only
+   //!   if no more objects are inserted or erased from the set.
    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
-      ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0)
+      ,KeyNodePtrCompare comp, insert_commit_data &commit_data
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
    {
       //hint must be bigger than the key
       if(hint == header || comp(key, hint)){
          node_ptr prev(hint);
          //Previous value should be less than the key
-         if(hint == begin_node(header) || comp((prev = prev_node(hint)), key)){
+         if(hint == begin_node(header) || comp((prev = base_type::prev_node(hint)), key)){
             commit_data.link_left = unique(header) || !NodeTraits::get_left(hint);
             commit_data.node      = commit_data.link_left ? hint : prev;
             if(pdepth){
@@ -1033,44 +1091,27 @@ class tree_algorithms
       return insert_unique_check(header, key, comp, commit_data, pdepth);
    }
 
-   template<class NodePtrCompare>
-   static void insert_equal_check
-      (const node_ptr &header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp
-      , insert_commit_data &commit_data, std::size_t *pdepth = 0)
-   {
-      if(hint == header || !comp(hint, new_node)){
-         node_ptr prev(hint);
-         if(hint == NodeTraits::get_left(header) ||
-            !comp(new_node, (prev = prev_node(hint)))){
-            bool link_left = unique(header) || !NodeTraits::get_left(hint);
-            commit_data.link_left = link_left;
-            commit_data.node = link_left ? hint : prev;
-            if(pdepth){
-               *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
-            }
-         }
-         else{
-            insert_equal_upper_bound_check(header, new_node, comp, commit_data, pdepth);
-         }
-      }
-      else{
-         insert_equal_lower_bound_check(header, new_node, comp, commit_data, pdepth);
-      }
-   }
-
-   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)
-   {  insert_equal_check_impl(true, h, new_node, comp, commit_data, pdepth);  }
-
-   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)
-   {  insert_equal_check_impl(false, h, new_node, comp, commit_data, pdepth);  }
-
+   //! <b>Requires</b>: "header" must be the header node of a tree.
+   //!   NodePtrCompare is a function object that induces a strict weak
+   //!   ordering compatible with the strict weak ordering used to create the
+   //!   the tree. NodePtrCompare compares two node_ptrs. "hint" is node from
+   //!   the "header"'s tree.
+   //!
+   //! <b>Effects</b>: Inserts new_node into the tree, using "hint" as a hint to
+   //!   where it will be inserted. If "hint" is the upper_bound
+   //!   the insertion takes constant time (two comparisons in the worst case).
+   //!
+   //! <b>Complexity</b>: Logarithmic in general, but it is amortized
+   //!   constant time if new_node is inserted immediately before "hint".
+   //!
+   //! <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, std::size_t *pdepth = 0)
+      (const node_ptr & h, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
    {
       insert_commit_data commit_data;
       insert_equal_check(h, hint, new_node, comp, commit_data, pdepth);
@@ -1078,9 +1119,25 @@ class tree_algorithms
       return new_node;
    }
 
+   //! <b>Requires</b>: "h" must be the header node of a tree.
+   //!   NodePtrCompare is a function object that induces a strict weak
+   //!   ordering compatible with the strict weak ordering used to create the
+   //!   the tree. NodePtrCompare compares two node_ptrs.
+   //!
+   //! <b>Effects</b>: Inserts new_node into the tree before the upper bound
+   //!   according to "comp".
+   //!
+   //! <b>Complexity</b>: Average complexity for insert element is at
+   //!   most logarithmic.
+   //!
+   //! <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, std::size_t *pdepth = 0)
+      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
    {
       insert_commit_data commit_data;
       insert_equal_upper_bound_check(h, new_node, comp, commit_data, pdepth);
@@ -1088,9 +1145,25 @@ class tree_algorithms
       return new_node;
    }
 
+   //! <b>Requires</b>: "h" must be the header node of a tree.
+   //!   NodePtrCompare is a function object that induces a strict weak
+   //!   ordering compatible with the strict weak ordering used to create the
+   //!   the tree. NodePtrCompare compares two node_ptrs.
+   //!
+   //! <b>Effects</b>: Inserts new_node into the tree before the lower bound
+   //!   according to "comp".
+   //!
+   //! <b>Complexity</b>: Average complexity for insert element is at
+   //!   most logarithmic.
+   //!
+   //! <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, std::size_t *pdepth = 0)
+      (const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
    {
       insert_commit_data commit_data;
       insert_equal_lower_bound_check(h, new_node, comp, commit_data, pdepth);
@@ -1098,8 +1171,26 @@ class tree_algorithms
       return new_node;
    }
 
+   //! <b>Requires</b>: "header" must be the header node of a tree.
+   //!   "pos" must be a valid iterator or header (end) node.
+   //!   "pos" must be an iterator pointing to the successor to "new_node"
+   //!   once inserted according to the order of already inserted nodes. This function does not
+   //!   check "pos" and this precondition must be guaranteed by the caller.
+   //!
+   //! <b>Effects</b>: Inserts new_node into the tree before "pos".
+   //!
+   //! <b>Complexity</b>: Constant-time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <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, std::size_t *pdepth = 0)
+      (const node_ptr & header, const node_ptr & pos, const node_ptr & new_node
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
    {
       insert_commit_data commit_data;
       insert_before_check(header, pos, commit_data, pdepth);
@@ -1107,59 +1198,56 @@ class tree_algorithms
       return new_node;
    }
 
-   static void insert_before_check
-      (const node_ptr &header, const node_ptr & pos
-      , insert_commit_data &commit_data, std::size_t *pdepth = 0)
-   {
-      node_ptr prev(pos);
-      if(pos != NodeTraits::get_left(header))
-         prev = prev_node(pos);
-      bool link_left = unique(header) || !NodeTraits::get_left(pos);
-      commit_data.link_left = link_left;
-      commit_data.node = link_left ? pos : prev;
-      if(pdepth){
-         *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
-      }
-   }
-
+   //! <b>Requires</b>: "header" must be the header node of a tree.
+   //!   "new_node" must be, according to the used ordering no less than the
+   //!   greatest inserted key.
+   //!
+   //! <b>Effects</b>: Inserts new_node into the tree before "pos".
+   //!
+   //! <b>Complexity</b>: Constant-time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Note</b>: If "new_node" is less than the greatest inserted key
+   //! 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, std::size_t *pdepth = 0)
+      (const node_ptr & header, const node_ptr & new_node
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
    {
       insert_commit_data commit_data;
       push_back_check(header, commit_data, pdepth);
       insert_commit(header, new_node, commit_data);
    }
 
-   static void push_back_check
-      (const node_ptr & header, insert_commit_data &commit_data, std::size_t *pdepth = 0)
-   {
-      node_ptr prev(NodeTraits::get_right(header));
-      if(pdepth){
-         *pdepth = prev == header ? 0 : depth(prev) + 1;
-      }
-      commit_data.link_left = false;
-      commit_data.node = prev;
-   }
-
+   //! <b>Requires</b>: "header" must be the header node of a tree.
+   //!   "new_node" must be, according to the used ordering, no greater than the
+   //!   lowest inserted key.
+   //!
+   //! <b>Effects</b>: Inserts new_node into the tree before "pos".
+   //!
+   //! <b>Complexity</b>: Constant-time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Note</b>: If "new_node" is greater than the lowest inserted key
+   //! 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, std::size_t *pdepth = 0)
+      (const node_ptr & header, const node_ptr & new_node
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
    {
       insert_commit_data commit_data;
       push_front_check(header, commit_data, pdepth);
       insert_commit(header, new_node, commit_data);
    }
 
-   static void push_front_check
-      (const node_ptr & header, insert_commit_data &commit_data, std::size_t *pdepth = 0)
-   {
-      node_ptr pos(NodeTraits::get_left(header));
-      if(pdepth){
-         *pdepth = pos == header ? 0 : depth(pos) + 1;
-      }
-      commit_data.link_left = true;
-      commit_data.node = pos;
-   }
-
    //! <b>Requires</b>: 'node' can't be a header node.
    //!
    //! <b>Effects</b>: Calculates the depth of a node: the depth of a
@@ -1193,26 +1281,582 @@ class tree_algorithms
    //!   the nodes of the target tree. If "cloner" throws, the cloned target nodes
    //!   are disposed using <tt>void disposer(const node_ptr &)</tt>.
    //!
-   //! <b>Complexity</b>: Linear to the number of element of the source tree plus the.
+   //! <b>Complexity</b>: Linear to the number of element of the source tree plus the
    //!   number of elements of tree target tree when calling this function.
    //!
-   //! <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)
+   //! <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)
+   {
+      if(!unique(target_header)){
+         clear_and_dispose(target_header, disposer);
+      }
+
+      node_ptr leftmost, rightmost;
+      node_ptr new_root = clone_subtree
+         (source_header, target_header, cloner, disposer, leftmost, rightmost);
+
+      //Now update header node
+      NodeTraits::set_parent(target_header, new_root);
+      NodeTraits::set_left  (target_header, leftmost);
+      NodeTraits::set_right (target_header, rightmost);
+   }
+
+   //! <b>Requires</b>: header must be the header of a tree, z a node
+   //!    of that tree and z != header.
+   //!
+   //! <b>Effects</b>: Erases node "z" from the tree with header "header".
+   //!
+   //! <b>Complexity</b>: Amortized constant time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   static void erase(const node_ptr & header, const node_ptr & z)
+   {
+      data_for_rebalance ignored;
+      erase(header, z, ignored);
+   }
+
+   //! <b>Requires</b>: node is a tree node but not the header.
+   //!
+   //! <b>Effects</b>: Unlinks the node and rebalances the tree.
+   //!
+   //! <b>Complexity</b>: Average complexity is constant time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   static void unlink(const node_ptr & node)
+   {
+      node_ptr x = NodeTraits::get_parent(node);
+      if(x){
+         while(!base_type::is_header(x))
+            x = NodeTraits::get_parent(x);
+         erase(x, node);
+      }
+   }
+
+   //! <b>Requires</b>: header must be the header of a tree.
+   //!
+   //! <b>Effects</b>: Rebalances the tree.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Linear.
+   static void rebalance(const node_ptr & header)
+   {
+      node_ptr root = NodeTraits::get_parent(header);
+      if(root){
+         rebalance_subtree(root);
+      }
+   }
+
+   //! <b>Requires</b>: old_root is a node of a tree. It shall not be null.
+   //!
+   //! <b>Effects</b>: Rebalances the subtree rooted at old_root.
+   //!
+   //! <b>Returns</b>: The new root of the subtree.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Complexity</b>: Linear.
+   static node_ptr rebalance_subtree(const node_ptr & old_root)
+   {
+      //Taken from:
+      //"Tree rebalancing in optimal time and space"
+      //Quentin F. Stout and Bette L. Warren
+
+      //To avoid irregularities in the algorithm (old_root can be a
+      //left or right child or even the root of the tree) just put the
+      //root as the right child of its parent. Before doing this backup
+      //information to restore the original relationship after
+      //the algorithm is applied.
+      node_ptr super_root = NodeTraits::get_parent(old_root);
+      BOOST_INTRUSIVE_INVARIANT_ASSERT(super_root);
+
+      //Get root info
+      node_ptr super_root_right_backup = NodeTraits::get_right(super_root);
+      bool super_root_is_header = NodeTraits::get_parent(super_root) == old_root;
+      bool old_root_is_right  = is_right_child(old_root);
+      NodeTraits::set_right(super_root, old_root);
+
+      std::size_t size;
+      subtree_to_vine(super_root, size);
+      vine_to_subtree(super_root, size);
+      node_ptr new_root = NodeTraits::get_right(super_root);
+
+      //Recover root
+      if(super_root_is_header){
+         NodeTraits::set_right(super_root, super_root_right_backup);
+         NodeTraits::set_parent(super_root, new_root);
+      }
+      else if(old_root_is_right){
+         NodeTraits::set_right(super_root, new_root);
+      }
+      else{
+         NodeTraits::set_right(super_root, super_root_right_backup);
+         NodeTraits::set_left(super_root, new_root);
+      }
+      return new_root;
+   }
+
+   //! <b>Effects</b>: Asserts the integrity of the container with additional checks provided by the user.
+   //!
+   //! <b>Requires</b>: header must be the header of a tree.
+   //!
+   //! <b>Complexity</b>: Linear time.
+   //!
+   //! <b>Note</b>: The method might not have effect when asserts are turned off (e.g., with NDEBUG).
+   //!   Experimental function, interface might change in future versions.
+   template<class Checker>
+   static void check(const const_node_ptr& header, Checker checker, typename Checker::return_type& checker_return)
+   {
+      const_node_ptr root_node_ptr = NodeTraits::get_parent(header);
+      if (!root_node_ptr){
+         // check left&right header pointers
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_left(header) == header);
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_right(header) == header);
+      }
+      else{
+         // check parent pointer of root node
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_parent(root_node_ptr) == header);
+         // check subtree from root
+         check_subtree(root_node_ptr, checker, checker_return);
+         // check left&right header pointers
+         const_node_ptr p = root_node_ptr;
+         while (NodeTraits::get_left(p)) { p = NodeTraits::get_left(p); }
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_left(header) == p);
+         p = root_node_ptr;
+         while (NodeTraits::get_right(p)) { p = NodeTraits::get_right(p); }
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_right(header) == p);
+      }
+   }
+
+   protected:
+   static void erase(const node_ptr & header, const node_ptr & z, data_for_rebalance &info)
+   {
+      node_ptr y(z);
+      node_ptr x;
+      const node_ptr z_left(NodeTraits::get_left(z));
+      const node_ptr z_right(NodeTraits::get_right(z));
+
+      if(!z_left){
+         x = z_right;    // x might be null.
+      }
+      else if(!z_right){ // z has exactly one non-null child. y == z.
+         x = z_left;       // x is not null.
+         BOOST_ASSERT(x);
+      }
+      else{ //make y != z
+         // y = find z's successor
+         y = base_type::minimum(z_right);
+         x = NodeTraits::get_right(y);     // x might be null.
+      }
+
+      node_ptr x_parent;
+      const node_ptr z_parent(NodeTraits::get_parent(z));
+      const bool z_is_leftchild(NodeTraits::get_left(z_parent) == z);
+
+      if(y != z){ //has two children and y is the minimum of z
+         //y is z's successor and it has a null left child.
+         //x is the right child of y (it can be null)
+         //Relink y in place of z and link x with y's old parent
+         NodeTraits::set_parent(z_left, y);
+         NodeTraits::set_left(y, z_left);
+         if(y != z_right){
+            //Link y with the right tree of z
+            NodeTraits::set_right(y, z_right);
+            NodeTraits::set_parent(z_right, y);
+            //Link x with y's old parent (y must be a left child)
+            x_parent = NodeTraits::get_parent(y);
+            BOOST_ASSERT(NodeTraits::get_left(x_parent) == y);
+            if(x)
+               NodeTraits::set_parent(x, x_parent);
+            //Since y was the successor and not the right child of z, it must be a left child
+            NodeTraits::set_left(x_parent, x);
+         }
+         else{ //y was the right child of y so no need to fix x's position
+            x_parent = y;
+         }
+         NodeTraits::set_parent(y, z_parent);
+         this_type::set_child(header, y, z_parent, z_is_leftchild);
+      }
+      else {  // z has zero or one child, x is one child (it can be null)
+         //Just link x to z's parent
+         x_parent = z_parent;
+         if(x)
+            NodeTraits::set_parent(x, z_parent);
+         this_type::set_child(header, x, z_parent, z_is_leftchild);
+
+         //Now update leftmost/rightmost in case z was one of them
+         if(NodeTraits::get_left(header) == z){
+            //z_left must be null because z is the leftmost
+            BOOST_ASSERT(!z_left);
+            NodeTraits::set_left(header, !z_right ?
+               z_parent :  // makes leftmost == header if z == root
+               base_type::minimum(z_right));
+         }
+         if(NodeTraits::get_right(header) == z){
+            //z_right must be null because z is the rightmost
+            BOOST_ASSERT(!z_right);
+            NodeTraits::set_right(header, !z_left ?
+               z_parent :  // makes rightmost == header if z == root
+               base_type::maximum(z_left));
+         }
+      }
+
+      //If z had 0/1 child, y == z and one of its children (and maybe null)
+      //If z had 2 children, y is the successor of z and x is the right child of y
+      info.x = x;
+      info.y = y;
+      //If z had 0/1 child, x_parent is the new parent of the old right child of y (z's successor)
+      //If z had 2 children, x_parent is the new parent of y (z_parent)
+      BOOST_ASSERT(!x || NodeTraits::get_parent(x) == x_parent);
+      info.x_parent = x_parent;
+   }
+
+   //! <b>Requires</b>: node is a node of the tree but it's not the header.
+   //!
+   //! <b>Effects</b>: Returns the number of nodes of the subtree.
+   //!
+   //! <b>Complexity</b>: Linear time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   static std::size_t subtree_size(const const_node_ptr & subtree)
+   {
+      std::size_t count = 0;
+      if (subtree){
+         node_ptr n = detail::uncast(subtree);
+         node_ptr m = NodeTraits::get_left(n);
+         while(m){
+            n = m;
+            m = NodeTraits::get_left(n);
+         }
+
+         while(1){
+            ++count;
+            node_ptr n_right(NodeTraits::get_right(n));
+            if(n_right){
+               n = n_right;
+               m = NodeTraits::get_left(n);
+               while(m){
+                  n = m;
+                  m = NodeTraits::get_left(n);
+               }
+            }
+            else {
+               do{
+                  if (n == subtree){
+                     return count;
+                  }
+                  m = n;
+                  n = NodeTraits::get_parent(n);
+               }while(NodeTraits::get_left(n) != m);
+            }
+         }
+      }
+      return count;
+   }
+
+   //! <b>Requires</b>: p is a node of a tree.
+   //!
+   //! <b>Effects</b>: Returns true if p is a left child.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Throws</b>: Nothing.
+   static bool is_left_child(const node_ptr & p)
+   {  return NodeTraits::get_left(NodeTraits::get_parent(p)) == p;  }
+
+   //! <b>Requires</b>: p is a node of a tree.
+   //!
+   //! <b>Effects</b>: Returns true if p is a right child.
+   //!
+   //! <b>Complexity</b>: Constant.
+   //!
+   //! <b>Throws</b>: Nothing.
+   static bool is_right_child(const node_ptr & p)
+   {  return NodeTraits::get_right(NodeTraits::get_parent(p)) == p;  }
+
+   static void insert_before_check
+      (const node_ptr &header, const node_ptr & pos
+      , insert_commit_data &commit_data
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
+   {
+      node_ptr prev(pos);
+      if(pos != NodeTraits::get_left(header))
+         prev = base_type::prev_node(pos);
+      bool link_left = unique(header) || !NodeTraits::get_left(pos);
+      commit_data.link_left = link_left;
+      commit_data.node = link_left ? pos : prev;
+      if(pdepth){
+         *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
+      }
+   }
+
+   static void push_back_check
+      (const node_ptr & header, insert_commit_data &commit_data
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
+   {
+      node_ptr prev(NodeTraits::get_right(header));
+      if(pdepth){
+         *pdepth = prev == header ? 0 : depth(prev) + 1;
+      }
+      commit_data.link_left = false;
+      commit_data.node = prev;
+   }
+
+   static void push_front_check
+      (const node_ptr & header, insert_commit_data &commit_data
+         #ifndef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+         , std::size_t *pdepth = 0
+         #endif
+      )
+   {
+      node_ptr pos(NodeTraits::get_left(header));
+      if(pdepth){
+         *pdepth = pos == header ? 0 : depth(pos) + 1;
+      }
+      commit_data.link_left = true;
+      commit_data.node = pos;
+   }
+
+   template<class NodePtrCompare>
+   static void insert_equal_check
+      (const node_ptr &header, const node_ptr & hint, const node_ptr & new_node, NodePtrCompare comp
+      , insert_commit_data &commit_data
+      /// @cond
+      , std::size_t *pdepth = 0
+      /// @endcond
+      )
+   {
+      if(hint == header || !comp(hint, new_node)){
+         node_ptr prev(hint);
+         if(hint == NodeTraits::get_left(header) ||
+            !comp(new_node, (prev = base_type::prev_node(hint)))){
+            bool link_left = unique(header) || !NodeTraits::get_left(hint);
+            commit_data.link_left = link_left;
+            commit_data.node = link_left ? hint : prev;
+            if(pdepth){
+               *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
+            }
+         }
+         else{
+            insert_equal_upper_bound_check(header, new_node, comp, commit_data, pdepth);
+         }
+      }
+      else{
+         insert_equal_lower_bound_check(header, new_node, comp, commit_data, pdepth);
+      }
+   }
+
+   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)
+   {
+      std::size_t depth = 0;
+      node_ptr y(h);
+      node_ptr x(NodeTraits::get_parent(y));
+
+      while(x){
+         ++depth;
+         y = x;
+         x = comp(new_node, x) ?
+               NodeTraits::get_left(x) : NodeTraits::get_right(x);
+      }
+      if(pdepth)  *pdepth = depth;
+      commit_data.link_left = (y == h) || comp(new_node, y);
+      commit_data.node = y;
+   }
+
+   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)
+   {
+      std::size_t depth = 0;
+      node_ptr y(h);
+      node_ptr x(NodeTraits::get_parent(y));
+
+      while(x){
+         ++depth;
+         y = x;
+         x = !comp(x, new_node) ?
+               NodeTraits::get_left(x) : NodeTraits::get_right(x);
+      }
+      if(pdepth)  *pdepth = depth;
+      commit_data.link_left = (y == h) || !comp(y, new_node);
+      commit_data.node = y;
+   }
+
+   static void insert_commit
+      (const node_ptr & header, const 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());
+      node_ptr parent_node(commit_data.node);
+      if(parent_node == header){
+         NodeTraits::set_parent(header, new_node);
+         NodeTraits::set_right(header, new_node);
+         NodeTraits::set_left(header, new_node);
+      }
+      else if(commit_data.link_left){
+         NodeTraits::set_left(parent_node, new_node);
+         if(parent_node == NodeTraits::get_left(header))
+             NodeTraits::set_left(header, new_node);
+      }
+      else{
+         NodeTraits::set_right(parent_node, new_node);
+         if(parent_node == NodeTraits::get_right(header))
+             NodeTraits::set_right(header, new_node);
+      }
+      NodeTraits::set_parent(new_node, parent_node);
+      NodeTraits::set_right(new_node, node_ptr());
+      NodeTraits::set_left(new_node, node_ptr());
+   }
+
+   //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)
+   {
+      if(new_parent == header)
+         NodeTraits::set_parent(header, new_child);
+      else if(link_left)
+         NodeTraits::set_left(new_parent, new_child);
+      else
+         NodeTraits::set_right(new_parent, new_child);
+   }
+
+   // 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)
+   {
+      node_ptr p_right_left(NodeTraits::get_left(p_right));
+      NodeTraits::set_right(p, p_right_left);
+      if(p_right_left){
+         NodeTraits::set_parent(p_right_left, p);
+      }
+      NodeTraits::set_left(p_right, p);
+      NodeTraits::set_parent(p, p_right);
+   }
+
+   // 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)
+   {
+      const bool p_was_left(NodeTraits::get_left(p_parent) == p);
+      rotate_left_no_parent_fix(p, p_right);
+      NodeTraits::set_parent(p_right, p_parent);
+      set_child(header, p_right, p_parent, p_was_left);
+   }
+
+   // 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)
+   {
+      node_ptr p_left_right(NodeTraits::get_right(p_left));
+      NodeTraits::set_left(p, p_left_right);
+      if(p_left_right){
+         NodeTraits::set_parent(p_left_right, p);
+      }
+      NodeTraits::set_right(p_left, p);
+      NodeTraits::set_parent(p, p_left);
+   }
+
+   // 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)
+   {
+      const bool p_was_left(NodeTraits::get_left(p_parent) == p);
+      rotate_right_no_parent_fix(p, p_left);
+      NodeTraits::set_parent(p_left, p_parent);
+      set_child(header, p_left, p_parent, p_was_left);
+   }
+
+   private:
+
+   static void subtree_to_vine(node_ptr vine_tail, std::size_t &size)
+   {
+      //Inspired by LibAVL:
+      //It uses a clever optimization for trees with parent pointers.
+      //No parent pointer is updated when transforming a tree to a vine as
+      //most of them will be overriten during compression rotations.
+      //A final pass must be made after the rebalancing to updated those
+      //pointers not updated by tree_to_vine + compression calls
+      std::size_t len = 0;
+      node_ptr remainder = NodeTraits::get_right(vine_tail);
+      while(remainder){
+         node_ptr tempptr = NodeTraits::get_left(remainder);
+         if(!tempptr){   //move vine-tail down one
+            vine_tail = remainder;
+            remainder = NodeTraits::get_right(remainder);
+            ++len;
+         }
+         else{ //rotate
+            NodeTraits::set_left(remainder, NodeTraits::get_right(tempptr));
+            NodeTraits::set_right(tempptr, remainder);
+            remainder = tempptr;
+            NodeTraits::set_right(vine_tail, tempptr);
+         }
+      }
+      size = len;
+   }
+
+   static void compress_subtree(node_ptr scanner, std::size_t count)
+   {
+      while(count--){   //compress "count" spine nodes in the tree with pseudo-root scanner
+         node_ptr child = NodeTraits::get_right(scanner);
+         node_ptr child_right = NodeTraits::get_right(child);
+         NodeTraits::set_right(scanner, child_right);
+         //Avoid setting the parent of child_right
+         scanner = child_right;
+         node_ptr scanner_left = NodeTraits::get_left(scanner);
+         NodeTraits::set_right(child, scanner_left);
+         if(scanner_left)
+            NodeTraits::set_parent(scanner_left, child);
+         NodeTraits::set_left(scanner, child);
+         NodeTraits::set_parent(child, scanner);
+      }
+   }
+
+   static void vine_to_subtree(const 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));
+      compress_subtree(super_root, leaf_nodes);  //create deepest leaves
+      std::size_t vine_nodes = count - leaf_nodes;
+      while(vine_nodes > 1){
+         vine_nodes /= 2;
+         compress_subtree(super_root, vine_nodes);
+      }
+
+      //Update parents of nodes still in the in the original vine line
+      //as those have not been updated by subtree_to_vine or compress_subtree
+      for ( node_ptr q = super_root, p = NodeTraits::get_right(super_root)
+          ; p
+          ; q = p, p = NodeTraits::get_right(p)){
+         NodeTraits::set_parent(p, q);
+      }
+   }
+
+   //! <b>Requires</b>: "n" must be a node inserted in a tree.
+   //!
+   //! <b>Effects</b>: Returns a pointer to the header node of the tree.
+   //!
+   //! <b>Complexity</b>: Logarithmic.
+   //!
+   //! <b>Throws</b>: Nothing.
+   static node_ptr get_root(const node_ptr & node)
    {
-      if(!unique(target_header)){
-         clear_and_dispose(target_header, disposer);
+      BOOST_INTRUSIVE_INVARIANT_ASSERT((!inited(node)));
+      node_ptr x = NodeTraits::get_parent(node);
+      if(x){
+         while(!base_type::is_header(x)){
+            x = NodeTraits::get_parent(x);
+         }
+         return x;
+      }
+      else{
+         return node;
       }
-
-      node_ptr leftmost, rightmost;
-      node_ptr new_root = clone_subtree
-         (source_header, target_header, cloner, disposer, leftmost, rightmost);
-
-      //Now update header node
-      NodeTraits::set_parent(target_header, new_root);
-      NodeTraits::set_left  (target_header, leftmost);
-      NodeTraits::set_right (target_header, rightmost);
    }
 
    template <class Cloner, class Disposer>
@@ -1310,304 +1954,6 @@ class tree_algorithms
       }
    }
 
-   //! <b>Requires</b>: p is a node of a tree.
-   //!
-   //! <b>Effects</b>: Returns true if p is a left child.
-   //!
-   //! <b>Complexity</b>: Constant.
-   //!
-   //! <b>Throws</b>: Nothing.
-   static bool is_left_child(const node_ptr & p)
-   {  return NodeTraits::get_left(NodeTraits::get_parent(p)) == p;  }
-
-   //! <b>Requires</b>: p is a node of a tree.
-   //!
-   //! <b>Effects</b>: Returns true if p is a right child.
-   //!
-   //! <b>Complexity</b>: Constant.
-   //!
-   //! <b>Throws</b>: Nothing.
-   static bool is_right_child(const node_ptr & p)
-   {  return NodeTraits::get_right(NodeTraits::get_parent(p)) == p;  }
-
-   //Fix header and own's parent data when replacing x with own, providing own's old data with parent
-   static void replace_own_impl(const node_ptr & own, const node_ptr & x, const node_ptr & header, const node_ptr & own_parent, bool own_was_left)
-   {
-      if(NodeTraits::get_parent(header) == own)
-         NodeTraits::set_parent(header, x);
-      else if(own_was_left)
-         NodeTraits::set_left(own_parent, x);
-      else
-         NodeTraits::set_right(own_parent, x);
-   }
-
-   //Fix header and own's parent data when replacing x with own, supposing own
-   //links with its parent are still ok
-   static void replace_own(const node_ptr & own, const node_ptr & x, const node_ptr & header)
-   {
-      node_ptr own_parent(NodeTraits::get_parent(own));
-      bool own_is_left(NodeTraits::get_left(own_parent) == own);
-      replace_own_impl(own, x, header, own_parent, own_is_left);
-   }
-
-   // rotate parent p to left (no header and p's parent fixup)
-   static node_ptr rotate_left(const node_ptr & p)
-   {
-      node_ptr x(NodeTraits::get_right(p));
-      node_ptr x_left(NodeTraits::get_left(x));
-      NodeTraits::set_right(p, x_left);
-      if(x_left){
-         NodeTraits::set_parent(x_left, p);
-      }
-      NodeTraits::set_left(x, p);
-      NodeTraits::set_parent(p, x);
-      return x;
-   }
-
-   // rotate parent p to left (with header and p's parent fixup)
-   static void rotate_left(const node_ptr & p, const node_ptr & header)
-   {
-      bool     p_was_left(is_left_child(p));
-      node_ptr p_old_parent(NodeTraits::get_parent(p));
-      node_ptr x(rotate_left(p));
-      NodeTraits::set_parent(x, p_old_parent);
-      replace_own_impl(p, x, header, p_old_parent, p_was_left);
-   }
-
-   // rotate parent p to right (no header and p's parent fixup)
-   static node_ptr rotate_right(const node_ptr & p)
-   {
-      node_ptr x(NodeTraits::get_left(p));
-      node_ptr x_right(NodeTraits::get_right(x));
-      NodeTraits::set_left(p, x_right);
-      if(x_right){
-         NodeTraits::set_parent(x_right, p);
-      }
-      NodeTraits::set_right(x, p);
-      NodeTraits::set_parent(p, x);
-      return x;
-   }
-
-   // rotate parent p to right (with header and p's parent fixup)
-   static void rotate_right(const node_ptr & p, const node_ptr & header)
-   {
-      bool     p_was_left(is_left_child(p));
-      node_ptr p_old_parent(NodeTraits::get_parent(p));
-      node_ptr x(rotate_right(p));
-      NodeTraits::set_parent(x, p_old_parent);
-      replace_own_impl(p, x, header, p_old_parent, p_was_left);
-   }
-
-   static void erase(const node_ptr & header, const node_ptr & z)
-   {
-      data_for_rebalance ignored;
-      erase_impl(header, z, ignored);
-   }
-
-   struct data_for_rebalance
-   {
-      node_ptr x;
-      node_ptr x_parent;
-      node_ptr y;
-   };
-
-   template<class F>
-   static void erase(const node_ptr & header, const node_ptr & z, F z_and_successor_fixup, data_for_rebalance &info)
-   {
-      erase_impl(header, z, info);
-      if(info.y != z){
-         z_and_successor_fixup(z, info.y);
-      }
-   }
-
-   static void unlink(const node_ptr & node)
-   {
-      node_ptr x = NodeTraits::get_parent(node);
-      if(x){
-         while(!is_header(x))
-            x = NodeTraits::get_parent(x);
-         erase(x, node);
-      }
-   }
-
-   static void tree_to_vine(const node_ptr & header)
-   {  subtree_to_vine(NodeTraits::get_parent(header)); }
-
-   static void vine_to_tree(const node_ptr & header, std::size_t count)
-   {  vine_to_subtree(NodeTraits::get_parent(header), count);  }
-
-   static void rebalance(const node_ptr & header)
-   {
-      //Taken from:
-      //"Tree rebalancing in optimal time and space"
-      //Quentin F. Stout and Bette L. Warren
-      std::size_t len = 0;
-      subtree_to_vine(NodeTraits::get_parent(header), &len);
-      vine_to_subtree(NodeTraits::get_parent(header), len);
-   }
-
-   static node_ptr rebalance_subtree(const node_ptr & old_root)
-   {
-      std::size_t len = 0;
-      node_ptr new_root = subtree_to_vine(old_root, &len);
-      return vine_to_subtree(new_root, len);
-   }
-
-   static node_ptr subtree_to_vine(const node_ptr & old_root, std::size_t *plen = 0)
-   {
-      std::size_t len;
-      len = 0;
-      if(!old_root)   return node_ptr();
-
-      //To avoid irregularities in the algorithm (old_root can be a
-      //left or right child or even the root of the tree) just put the
-      //root as the right child of its parent. Before doing this backup
-      //information to restore the original relationship after
-      //the algorithm is applied.
-      node_ptr super_root = NodeTraits::get_parent(old_root);
-      BOOST_INTRUSIVE_INVARIANT_ASSERT(super_root);
-
-      //Get info
-      node_ptr super_root_right_backup = NodeTraits::get_right(super_root);
-      bool super_root_is_header   = is_header(super_root);
-      bool old_root_is_right  = is_right_child(old_root);
-
-      node_ptr x(old_root);
-      node_ptr new_root(x);
-      node_ptr save;
-      bool moved_to_right = false;
-      for( ; x; x = save){
-         save = NodeTraits::get_left(x);
-         if(save){
-            // Right rotation
-            node_ptr save_right = NodeTraits::get_right(save);
-            node_ptr x_parent   = NodeTraits::get_parent(x);
-            NodeTraits::set_parent(save, x_parent);
-            NodeTraits::set_right (x_parent, save);
-            NodeTraits::set_parent(x, save);
-            NodeTraits::set_right (save, x);
-            NodeTraits::set_left(x, save_right);
-            if(save_right)
-               NodeTraits::set_parent(save_right, x);
-            if(!moved_to_right)
-               new_root = save;
-         }
-         else{
-            moved_to_right = true;
-            save = NodeTraits::get_right(x);
-            ++len;
-         }
-      }
-
-      if(super_root_is_header){
-         NodeTraits::set_right(super_root, super_root_right_backup);
-         NodeTraits::set_parent(super_root, new_root);
-      }
-      else if(old_root_is_right){
-         NodeTraits::set_right(super_root, new_root);
-      }
-      else{
-         NodeTraits::set_right(super_root, super_root_right_backup);
-         NodeTraits::set_left(super_root, new_root);
-      }
-      if(plen) *plen = len;
-      return new_root;
-   }
-
-   static node_ptr vine_to_subtree(const node_ptr & old_root, std::size_t count)
-   {
-      std::size_t leaf_nodes = count + 1 - ((std::size_t) 1 << floor_log2 (count + 1));
-      std::size_t vine_nodes = count - leaf_nodes;
-
-      node_ptr new_root = compress_subtree(old_root, leaf_nodes);
-      while(vine_nodes > 1){
-         vine_nodes /= 2;
-         new_root = compress_subtree(new_root, vine_nodes);
-      }
-      return new_root;
-   }
-
-   static node_ptr compress_subtree(const node_ptr & old_root, std::size_t count)
-   {
-      if(!old_root)   return old_root;
-
-      //To avoid irregularities in the algorithm (old_root can be
-      //left or right child or even the root of the tree) just put the
-      //root as the right child of its parent. First obtain
-      //information to restore the original relationship after
-      //the algorithm is applied.
-      node_ptr super_root = NodeTraits::get_parent(old_root);
-      BOOST_INTRUSIVE_INVARIANT_ASSERT(super_root);
-
-      //Get info
-      node_ptr super_root_right_backup = NodeTraits::get_right(super_root);
-      bool super_root_is_header   = is_header(super_root);
-      bool old_root_is_right  = is_right_child(old_root);
-
-      //Put old_root as right child
-      NodeTraits::set_right(super_root, old_root);
-
-      //Start the compression algorithm
-      node_ptr even_parent = super_root;
-      node_ptr new_root = old_root;
-
-      while(count--){
-         node_ptr even = NodeTraits::get_right(even_parent);
-         node_ptr odd = NodeTraits::get_right(even);
-
-         if(new_root == old_root)
-            new_root = odd;
-
-         node_ptr even_right = NodeTraits::get_left(odd);
-         NodeTraits::set_right(even, even_right);
-         if (even_right)
-            NodeTraits::set_parent(even_right, even);
-
-         NodeTraits::set_right(even_parent, odd);
-         NodeTraits::set_parent(odd, even_parent);
-         NodeTraits::set_left(odd, even);
-         NodeTraits::set_parent(even, odd);
-         even_parent = odd;
-      }
-
-      if(super_root_is_header){
-         NodeTraits::set_parent(super_root, new_root);
-         NodeTraits::set_right(super_root, super_root_right_backup);
-      }
-      else if(old_root_is_right){
-         NodeTraits::set_right(super_root, new_root);
-      }
-      else{
-         NodeTraits::set_left(super_root, new_root);
-         NodeTraits::set_right(super_root, super_root_right_backup);
-      }
-      return new_root;
-   }
-
-   //! <b>Requires</b>: "n" must be a node inserted in a tree.
-   //!
-   //! <b>Effects</b>: Returns a pointer to the header node of the tree.
-   //!
-   //! <b>Complexity</b>: Logarithmic.
-   //!
-   //! <b>Throws</b>: Nothing.
-   static node_ptr get_root(const node_ptr & node)
-   {
-      BOOST_INTRUSIVE_INVARIANT_ASSERT((!inited(node)));
-      node_ptr x = NodeTraits::get_parent(node);
-      if(x){
-         while(!is_header(x)){
-            x = NodeTraits::get_parent(x);
-         }
-         return x;
-      }
-      else{
-         return node;
-      }
-   }
-
-   private:
-
    template<class KeyType, class KeyNodePtrCompare>
    static node_ptr lower_bound_loop
       (node_ptr x, node_ptr y, const KeyType &key, KeyNodePtrCompare comp)
@@ -1640,103 +1986,46 @@ class tree_algorithms
       return y;
    }
 
-
-   template<class NodePtrCompare>
-   static void insert_equal_check_impl
-      (bool upper, const node_ptr & h, const node_ptr & new_node, NodePtrCompare comp, insert_commit_data & commit_data, std::size_t *pdepth = 0)
+   template<class Checker>
+   static void check_subtree(const const_node_ptr& node, Checker checker, typename Checker::return_type& check_return)
    {
-      std::size_t depth = 0;
-      node_ptr y(h);
-      node_ptr x(NodeTraits::get_parent(y));
-      bool link_left;
-
-      if(upper){
-         while(x){
-            ++depth;
-            y = x;
-            x = comp(new_node, x) ?
-                  NodeTraits::get_left(x) : NodeTraits::get_right(x);
-         }
-         link_left = (y == h) || comp(new_node, y);
+      const_node_ptr left = NodeTraits::get_left(node);
+      const_node_ptr right = NodeTraits::get_right(node);
+      typename Checker::return_type check_return_left;
+      typename Checker::return_type check_return_right;
+      if (left)
+      {
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_parent(left) == node);
+         check_subtree(left, checker, check_return_left);
       }
-      else{
-         while(x){
-            ++depth;
-            y = x;
-            x = !comp(x, new_node) ?
-                  NodeTraits::get_left(x) : NodeTraits::get_right(x);
-         }
-         link_left = (y == h) || !comp(y, new_node);
+      if (right)
+      {
+         BOOST_INTRUSIVE_INVARIANT_ASSERT(NodeTraits::get_parent(right) == node);
+         check_subtree(right, checker, check_return_right);
       }
-
-      commit_data.link_left = link_left;
-      commit_data.node = y;
-      if(pdepth)  *pdepth = depth;
+      checker(node, check_return_left, check_return_right, check_return);
    }
+};
 
-   static void erase_impl(const node_ptr & header, const node_ptr & z, data_for_rebalance &info)
-   {
-      node_ptr y(z);
-      node_ptr x;
-      node_ptr x_parent = node_ptr();
-      node_ptr z_left(NodeTraits::get_left(z));
-      node_ptr z_right(NodeTraits::get_right(z));
-      if(!z_left){
-         x = z_right;    // x might be null.
-      }
-      else if(!z_right){ // z has exactly one non-null child. y == z.
-         x = z_left;       // x is not null.
-      }
-      else{
-         // find z's successor
-         y = tree_algorithms::minimum (z_right);
-         x = NodeTraits::get_right(y);     // x might be null.
-      }
+/// @cond
 
-      if(y != z){
-         // relink y in place of z.  y is z's successor
-         NodeTraits::set_parent(NodeTraits::get_left(z), y);
-         NodeTraits::set_left(y, NodeTraits::get_left(z));
-         if(y != NodeTraits::get_right(z)){
-            x_parent = NodeTraits::get_parent(y);
-            if(x)
-               NodeTraits::set_parent(x, x_parent);
-            NodeTraits::set_left(x_parent, x);   // y must be a child of left_
-            NodeTraits::set_right(y, NodeTraits::get_right(z));
-            NodeTraits::set_parent(NodeTraits::get_right(z), y);
-         }
-         else
-            x_parent = y;
-         tree_algorithms::replace_own (z, y, header);
-         NodeTraits::set_parent(y, NodeTraits::get_parent(z));
-      }
-      else {   // y == z --> z has only one child, or none
-         x_parent = NodeTraits::get_parent(z);
-         if(x)
-            NodeTraits::set_parent(x, x_parent);
-         tree_algorithms::replace_own (z, x, header);
-         if(NodeTraits::get_left(header) == z){
-            NodeTraits::set_left(header, !NodeTraits::get_right(z) ?        // z->get_left() must be null also
-               NodeTraits::get_parent(z) :  // makes leftmost == header if z == root
-               tree_algorithms::minimum (x));
-         }
-         if(NodeTraits::get_right(header) == z){
-            NodeTraits::set_right(header, !NodeTraits::get_left(z) ?        // z->get_right() must be null also
-                              NodeTraits::get_parent(z) :  // makes rightmost == header if z == root
-                              tree_algorithms::maximum(x));
-         }
-      }
+template<class NodeTraits>
+struct get_algo<BsTreeAlgorithms, NodeTraits>
+{
+   typedef bstree_algorithms<NodeTraits> type;
+};
 
-      info.x = x;
-      info.x_parent = x_parent;
-      info.y = y;
-   }
+template <class ValueTraits, class NodePtrCompare, class ExtraChecker>
+struct get_node_checker<BsTreeAlgorithms, ValueTraits, NodePtrCompare, ExtraChecker>
+{
+   typedef detail::bstree_node_checker<ValueTraits, NodePtrCompare, ExtraChecker> type;
 };
 
-}  //namespace detail {
+/// @endcond
+
 }  //namespace intrusive
 }  //namespace boost
 
 #include <boost/intrusive/detail/config_end.hpp>
 
-#endif //BOOST_INTRUSIVE_TREE_ALGORITHMS_HPP
+#endif //BOOST_INTRUSIVE_BSTREE_ALGORITHMS_HPP