Added scapegoat trees and an option to store the hash value in the hook for unordered containers

[SVN r41195]

include/boost/intrusive/avl_set.hpp

@@ -113,8 +113,8 @@ class avl_set_impl
    //! <b>Effects</b>: Detaches all elements from this. The objects in the avl_set 
    //!   are not deleted (i.e. no destructors are called).
    //! 
-   //! <b>Complexity</b>: O(log(size()) + size()) if it's a safe-mode or auto-unlink
+   //! <b>Complexity</b>: Linear to the number of elements on the container.
-   //!   value. Otherwise constant.
+   //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
    //! 
    //! <b>Throws</b>: Nothing.
    ~avl_set_impl() 
@@ -1178,8 +1178,8 @@ class avl_multiset_impl
    //! <b>Effects</b>: Detaches all elements from this. The objects in the avl_multiset 
    //!   are not deleted (i.e. no destructors are called).
    //! 
-   //! <b>Complexity</b>: O(log(size()) + size()) if it's a safe-mode or
+   //! <b>Complexity</b>: Linear to the number of elements on the container.
-   //!   auto-unlink value. Otherwise constant.
+   //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
    //! 
    //! <b>Throws</b>: Nothing.
    ~avl_multiset_impl() 

include/boost/intrusive/avl_set_hook.hpp

@@ -57,18 +57,25 @@ struct make_avl_set_base_hook
 };
 
 //! Derive a class from avl_set_base_hook in order to store objects in 
-//! in an set/multiset. avl_set_base_hook holds the data necessary to maintain 
+//! in an avl_set/avl_multiset. avl_set_base_hook holds the data necessary to maintain 
-//! the set/multiset and provides an appropriate value_traits class for set/multiset.
+//! the avl_set/avl_multiset and provides an appropriate value_traits class for avl_set/avl_multiset.
 //! 
-//! The first integer template argument defines a tag to identify the node. 
+//! The hook admits the following options: \c tag<>, \c void_pointer<>,
+//! \c link_mode<> and \c optimize_size<>.
+//!
+//! \c tag<> defines a tag to identify the node. 
 //! The same tag value can be used in different classes, but if a class is 
-//! derived from more than one avl_set_base_hook, then each avl_set_base_hook needs its 
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its 
 //! unique tag.
 //!
-//! The second boolean template parameter will specify the linking mode of the hook.
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
+//! and the the container configured to use this hook.
 //!
-//! The third argument is the pointer type that will be used internally in the hook
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
-//! and the set/multiset configured from this hook.
+//! \c auto_unlink or \c safe_link).
+//!
+//! \c optimize_size<> will tell the hook to optimize the hook for size instead
+//! of speed.
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
@@ -107,7 +114,7 @@ class avl_set_base_hook
 
    //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
    //!   nothing (ie. no code is generated). If link_mode is \c safe_link and the
-   //!   object is stored in an set an assertion is raised. If link_mode is
+   //!   object is stored in a set an assertion is raised. If link_mode is
    //!   \c auto_unlink and \c is_linked() is true, the node is unlinked.
    //! 
    //! <b>Throws</b>: Nothing. 
@@ -169,13 +176,20 @@ struct make_avl_set_member_hook
 };
 
 //! Put a public data member avl_set_member_hook in order to store objects of this class in
-//! an set/multiset. avl_set_member_hook holds the data necessary for maintaining the
+//! an avl_set/avl_multiset. avl_set_member_hook holds the data necessary for maintaining the
-//! set/multiset and provides an appropriate value_traits class for set/multiset.
+//! avl_set/avl_multiset and provides an appropriate value_traits class for avl_set/avl_multiset.
 //! 
-//! The first boolean template parameter will specify the linking mode of the hook.
+//! The hook admits the following options: \c void_pointer<>,
+//! \c link_mode<> and \c optimize_size<>.
 //!
-//! The second argument is the pointer type that will be used internally in the hook
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
-//! and the set/multiset configured from this hook.
+//! and the the container configured to use this hook.
+//!
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
+//! \c auto_unlink or \c safe_link).
+//!
+//! \c optimize_size<> will tell the hook to optimize the hook for size instead
+//! of speed.
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
@@ -214,7 +228,7 @@ class avl_set_member_hook
 
    //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
    //!   nothing (ie. no code is generated). If link_mode is \c safe_link and the
-   //!   object is stored in an set an assertion is raised. If link_mode is
+   //!   object is stored in a set an assertion is raised. If link_mode is
    //!   \c auto_unlink and \c is_linked() is true, the node is unlinked.
    //! 
    //! <b>Throws</b>: Nothing. 

include/boost/intrusive/avltree.hpp

@@ -413,10 +413,7 @@ class avltree_impl
       if(constant_time_size)
          return this->priv_size_traits().get_size();
       else{
-         const_iterator beg(this->cbegin()), end(this->cend());
+         return (size_type)node_algorithms::size(const_node_ptr(&priv_header()));
-         size_type i = 0;
-         for(;beg != end; ++beg) ++i;
-         return i;
       }
    }
 

include/boost/intrusive/avltree_algorithms.hpp

@@ -282,6 +282,16 @@ class avltree_algorithms
    static std::size_t count(const_node_ptr node)
    {  return tree_algorithms::count(node);   }
 
+   //! <b>Requires</b>: header is the header node of the tree.
+   //! 
+   //! <b>Effects</b>: Returns the number of nodes above the header.
+   //! 
+   //! <b>Complexity</b>: Linear time.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static std::size_t size(const_node_ptr header)
+   {  return tree_algorithms::size(header);   }
+
    //! <b>Requires</b>: p is a node from the tree except the header.
    //! 
    //! <b>Effects</b>: Returns the next node of the tree.

include/boost/intrusive/bs_set_hook.hpp

@@ -0,0 +1,288 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+
+#ifndef BOOST_INTRUSIVE_BS_SET_HOOK_HPP
+#define BOOST_INTRUSIVE_BS_SET_HOOK_HPP
+
+#include <boost/intrusive/detail/config_begin.hpp>
+#include <boost/intrusive/intrusive_fwd.hpp>
+#include <boost/intrusive/detail/utilities.hpp>
+#include <boost/intrusive/detail/tree_node.hpp>
+#include <boost/intrusive/detail/tree_algorithms.hpp>
+#include <boost/intrusive/options.hpp>
+#include <boost/intrusive/detail/generic_hook.hpp>
+
+namespace boost {
+namespace intrusive {
+
+/// @cond
+template<class VoidPointer>
+struct get_bs_set_node_algo
+{
+   typedef detail::tree_algorithms<tree_node_traits<VoidPointer> > type;
+};
+/// @endcond
+
+//! Helper metafunction to define a \c bs_set_base_hook that yields to the same
+//! type when the same options (either explicitly or implicitly) are used.
+#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+template<class ...Options>
+#else
+template<class O1 = none, class O2 = none, class O3 = none>
+#endif
+struct make_bs_set_base_hook
+{
+   /// @cond
+   typedef typename pack_options
+      < hook_defaults, O1, O2, O3>::type packed_options;
+
+   //Scapegoat trees can't be auto unlink trees
+   BOOST_STATIC_ASSERT(((int)packed_options::link_mode != (int)auto_unlink));
+
+   typedef detail::generic_hook
+   < get_bs_set_node_algo<typename packed_options::void_pointer>
+   , typename packed_options::tag
+   , packed_options::link_mode
+   , detail::BsSetBaseHook
+   > implementation_defined;
+   /// @endcond
+   typedef implementation_defined type;
+};
+
+//! Derive a class from bs_set_base_hook in order to store objects in 
+//! in a bs_set/bs_multiset. bs_set_base_hook holds the data necessary to maintain 
+//! the bs_set/bs_multiset and provides an appropriate value_traits class for bs_set/bs_multiset.
+//! 
+//! The hook admits the following options: \c tag<>, \c void_pointer<>,
+//! \c link_mode<>.
+//!
+//! \c tag<> defines a tag to identify the node. 
+//! The same tag value can be used in different classes, but if a class is 
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its 
+//! unique tag.
+//!
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
+//! and the the container configured to use this hook.
+//!
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
+//! \c auto_unlink or \c safe_link).
+#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+template<class ...Options>
+#else
+template<class O1, class O2, class O3>
+#endif
+class bs_set_base_hook
+   :  public make_bs_set_base_hook<O1, O2, O3>::type
+{
+   #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+   //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link
+   //!   initializes the node to an unlinked state.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   bs_set_base_hook();
+
+   //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link
+   //!   initializes the node to an unlinked state. The argument is ignored.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   //! 
+   //! <b>Rationale</b>: Providing a copy-constructor
+   //!   makes classes using the hook STL-compliant without forcing the 
+   //!   user to do some additional work. \c swap can be used to emulate
+   //!   move-semantics.
+   bs_set_base_hook(const bs_set_base_hook& );
+
+   //! <b>Effects</b>: Empty function. The argument is ignored.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   //! 
+   //! <b>Rationale</b>: Providing an assignment operator 
+   //!   makes classes using the hook STL-compliant without forcing the 
+   //!   user to do some additional work. \c swap can be used to emulate
+   //!   move-semantics.
+   bs_set_base_hook& operator=(const bs_set_base_hook& );
+
+   //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
+   //!   nothing (ie. no code is generated). If link_mode is \c safe_link and the
+   //!   object is stored in a set an assertion is raised. If link_mode is
+   //!   \c auto_unlink and \c is_linked() is true, the node is unlinked.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   ~bs_set_base_hook();
+
+   //! <b>Effects</b>: Swapping two nodes swaps the position of the elements 
+   //!   related to those nodes in one or two containers. That is, if the node 
+   //!   this is part of the element e1, the node x is part of the element e2 
+   //!   and both elements are included in the containers s1 and s2, then after 
+   //!   the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 
+   //!   at the position of e1. If one element is not in a container, then 
+   //!   after the swap-operation the other element is not in a container. 
+   //!   Iterators to e1 and e2 related to those nodes are invalidated. 
+   //!
+   //! <b>Complexity</b>: Constant 
+   //!
+   //! <b>Throws</b>: Nothing. 
+   void swap_nodes(bs_set_base_hook &other);
+
+   //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink.
+   //!
+   //! <b>Returns</b>: true, if the node belongs to a container, false
+   //!   otherwise. This function can be used to test whether \c set::iterator_to 
+   //!   will return a valid iterator. 
+   //!
+   //! <b>Complexity</b>: Constant 
+   bool is_linked() const;
+
+   //! <b>Effects</b>: Removes the node if it's inserted in a container.
+   //!   This function is only allowed if link_mode is \c auto_unlink.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   void unlink();
+   #endif
+};
+
+//! Helper metafunction to define a \c bs_set_member_hook that yields to the same
+//! type when the same options (either explicitly or implicitly) are used.
+#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+template<class ...Options>
+#else
+template<class O1 = none, class O2 = none, class O3 = none>
+#endif
+struct make_bs_set_member_hook
+{
+   /// @cond
+   typedef typename pack_options
+      < hook_defaults, O1, O2, O3>::type packed_options;
+
+   //Scapegoat trees can't be auto unlink trees
+   BOOST_STATIC_ASSERT(((int)packed_options::link_mode != (int)auto_unlink));
+
+   typedef detail::generic_hook
+   < get_bs_set_node_algo<typename packed_options::void_pointer>
+   , member_tag
+   , packed_options::link_mode
+   , detail::NoBaseHook
+   > implementation_defined;
+   /// @endcond
+   typedef implementation_defined type;
+};
+
+//! Put a public data member bs_set_member_hook in order to store objects of this class in
+//! a bs_set/bs_multiset. bs_set_member_hook holds the data necessary for maintaining the
+//! bs_set/bs_multiset and provides an appropriate value_traits class for bs_set/bs_multiset.
+//! 
+//! The hook admits the following options: \c void_pointer<>, \c link_mode<>.
+//!
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
+//! and the the container configured to use this hook.
+//!
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
+//! \c auto_unlink or \c safe_link).
+#ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+template<class ...Options>
+#else
+template<class O1, class O2, class O3>
+#endif
+class bs_set_member_hook
+   :  public make_bs_set_member_hook<O1, O2, O3>::type
+{
+   #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
+   //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link
+   //!   initializes the node to an unlinked state.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   bs_set_member_hook();
+
+   //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link
+   //!   initializes the node to an unlinked state. The argument is ignored.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   //! 
+   //! <b>Rationale</b>: Providing a copy-constructor
+   //!   makes classes using the hook STL-compliant without forcing the 
+   //!   user to do some additional work. \c swap can be used to emulate
+   //!   move-semantics.
+   bs_set_member_hook(const bs_set_member_hook& );
+
+   //! <b>Effects</b>: Empty function. The argument is ignored.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   //! 
+   //! <b>Rationale</b>: Providing an assignment operator 
+   //!   makes classes using the hook STL-compliant without forcing the 
+   //!   user to do some additional work. \c swap can be used to emulate
+   //!   move-semantics.
+   bs_set_member_hook& operator=(const bs_set_member_hook& );
+
+   //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
+   //!   nothing (ie. no code is generated). If link_mode is \c safe_link and the
+   //!   object is stored in a set an assertion is raised. If link_mode is
+   //!   \c auto_unlink and \c is_linked() is true, the node is unlinked.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   ~bs_set_member_hook();
+
+   //! <b>Effects</b>: Swapping two nodes swaps the position of the elements 
+   //!   related to those nodes in one or two containers. That is, if the node 
+   //!   this is part of the element e1, the node x is part of the element e2 
+   //!   and both elements are included in the containers s1 and s2, then after 
+   //!   the swap-operation e1 is in s2 at the position of e2 and e2 is in s1 
+   //!   at the position of e1. If one element is not in a container, then 
+   //!   after the swap-operation the other element is not in a container. 
+   //!   Iterators to e1 and e2 related to those nodes are invalidated. 
+   //!
+   //! <b>Complexity</b>: Constant 
+   //!
+   //! <b>Throws</b>: Nothing. 
+   void swap_nodes(bs_set_member_hook &other);
+
+   //! <b>Precondition</b>: link_mode must be \c safe_link or \c auto_unlink.
+   //!
+   //! <b>Returns</b>: true, if the node belongs to a container, false
+   //!   otherwise. This function can be used to test whether \c set::iterator_to 
+   //!   will return a valid iterator. 
+   //!
+   //! <b>Complexity</b>: Constant 
+   bool is_linked() const;
+
+   //! <b>Effects</b>: Removes the node if it's inserted in a container.
+   //!   This function is only allowed if link_mode is \c auto_unlink.
+   //! 
+   //! <b>Throws</b>: Nothing. 
+   void unlink();
+   #endif
+};
+
+/// @cond
+
+template <class T>
+struct internal_default_bs_set_hook
+{
+   template <class U> static detail::one test(...);
+   template <class U> static detail::two test(typename U::default_bs_set_hook* = 0);
+   static const bool value = sizeof(test<T>(0)) == sizeof(detail::two);
+};
+
+template <class T>
+struct get_default_bs_set_hook
+{
+   typedef typename T::default_bs_set_hook type;
+};
+
+/// @endcond
+
+} //namespace intrusive 
+} //namespace boost 
+
+#include <boost/intrusive/detail/config_end.hpp>
+
+#endif //BOOST_INTRUSIVE_BS_SET_HOOK_HPP

include/boost/intrusive/detail/config_begin.hpp

@@ -42,6 +42,8 @@
    #pragma warning (disable : 4522)
    #pragma warning (disable : 4146)
    #pragma warning (disable : 4267) //conversion from 'X' to 'Y', possible loss of data
+   #pragma warning (disable : 4127) //conditional expression is constant
+   #pragma warning (disable : 4706) //assignment within conditional expression
 #endif
 
 //#define BOOST_INTRUSIVE_USE_ITERATOR_FACADE

include/boost/intrusive/detail/generic_hook.hpp

@@ -34,6 +34,7 @@ enum
 ,  UsetBaseHook
 ,  SplaySetBaseHook
 ,  AvlSetBaseHook
+,  BsSetBaseHook
 };
 
 struct no_default_definer{};
@@ -65,6 +66,10 @@ template <class Hook>
 struct default_definer<Hook, AvlSetBaseHook>
 {  typedef Hook default_avl_set_hook;  };
 
+template <class Hook>
+struct default_definer<Hook, BsSetBaseHook>
+{  typedef Hook default_bs_set_hook;  };
+
 template <class Hook, unsigned int BaseHookType>
 struct make_default_definer
 {

include/boost/intrusive/detail/tree_algorithms.hpp

@@ -118,7 +118,7 @@ class tree_algorithms
 
    struct nop_erase_fixup
    {
-      void operator()(node_ptr to_erase, node_ptr successor){}
+      void operator()(node_ptr, node_ptr){}
    };
 
    /// @cond
@@ -598,14 +598,49 @@ class tree_algorithms
    //! <b>Complexity</b>: Linear time.
    //! 
    //! <b>Throws</b>: Nothing.
-   static std::size_t count(const_node_ptr node)
+   static std::size_t count(const_node_ptr subtree)
    {
-      std::size_t result = 1;
+      if(!subtree) return 0;
-      if(NodeTraits::get_left(node))
+      std::size_t count = 0;
-         result += count(NodeTraits::get_left(node));
+      node_ptr p = minimum(uncast(subtree));
-      if(NodeTraits::get_right(node))
+      bool continue_looping = true;
-         result += count(NodeTraits::get_right(node));
+      while(continue_looping){
-      return result;
+         ++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.
+   //! 
+   //! <b>Complexity</b>: Linear time.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static std::size_t size(const_node_ptr header)
+   {
+      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;
+      return i;
    }
 
    //! <b>Requires</b>: header1 and header2 must be the header nodes
@@ -659,6 +694,22 @@ class tree_algorithms
 
    static bool is_header(const_node_ptr p)
    {
+/*
+      node_ptr p_parent = NodeTraits::get_parent(p);
+      if(!p_parent)
+         return true;
+      if(!NodeTraits::get_parent(p_parent) != p)
+         return false;
+      if(NodeTraits::get_left(p) != 0){
+         if(NodeTraits::get_parent(NodeTraits::get_left(p)) != p){
+            is_header = true;
+         }
+         if(NodeTraits::get_parent(p) == NodeTraits::get_left(p)){
+            is_header = true;
+         }
+      }
+*/
+      
       bool is_header = false;
       if(NodeTraits::get_parent(p) == p){
          is_header = true;
@@ -875,8 +926,9 @@ class tree_algorithms
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, bool> insert_unique_check
       (const_node_ptr header,  const KeyType &key
-      ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
+      ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0)
    {
+      std::size_t depth = 0;
       node_ptr h(uncast(header));
       node_ptr y(h);
       node_ptr x(NodeTraits::get_parent(y));
@@ -886,11 +938,14 @@ class tree_algorithms
       //store it in the left or right node
       bool left_child = true;
       while(x){
+         ++depth;
          y = x;
          x = (left_child = comp(key, x)) ? 
                NodeTraits::get_left(x) : (prev = y, NodeTraits::get_right(x));
       }
 
+      if(pdepth)  *pdepth = depth;
+
       //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
@@ -909,7 +964,7 @@ class tree_algorithms
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, bool> insert_unique_check
       (const_node_ptr header,  node_ptr hint, const KeyType &key
-      ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
+      ,KeyNodePtrCompare comp, insert_commit_data &commit_data, std::size_t *pdepth = 0)
    {
       //hint must be bigger than the key
       if(hint == header || comp(key, hint)){
@@ -918,15 +973,18 @@ class tree_algorithms
          if(prev == NodeTraits::get_left(header) || comp((prev = 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){
+               *pdepth = commit_data.node == header ? 0 : depth(commit_data.node) + 1;
+            }
             return std::pair<node_ptr, bool>(node_ptr(), true);
          }
          else{
-            return insert_unique_check(header, key, comp, commit_data);
+            return insert_unique_check(header, key, comp, commit_data, pdepth);
          }
       }
       //The hint was wrong, use hintless insert
       else{
-         return insert_unique_check(header, key, comp, commit_data);
+         return insert_unique_check(header, key, comp, commit_data, pdepth);
       }
    }
 
@@ -946,7 +1004,7 @@ class tree_algorithms
    //! <b>Throws</b>: If "comp" throws.
    template<class NodePtrCompare>
    static node_ptr insert_equal
-      (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp)
+      (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp, std::size_t *pdepth = 0)
    {
       if(hint == header || !comp(hint, new_node)){
          node_ptr prev(hint);
@@ -954,25 +1012,48 @@ class tree_algorithms
             !comp(new_node, (prev = prev_node(hint)))){
             bool link_left = unique(header) || !NodeTraits::get_left(hint);
             link(header, new_node, link_left ? hint : prev, link_left);
+            if(pdepth)  *pdepth = depth(new_node) + 1;
             return new_node;
          }
          else{
-            return insert_equal_upper_bound(header, new_node, comp);
+            return insert_equal_upper_bound(header, new_node, comp, pdepth);
          }
       }
       else{
-         return insert_equal_lower_bound(header, new_node, comp);
+         return insert_equal_lower_bound(header, new_node, comp, pdepth);
       }
    }
 
+   //! <b>Requires</b>: p can't be a header node.
+   //! 
+   //! <b>Effects</b>: Calculates the depth of a node: the depth of a
+   //! node is the length (number of edges) of the path from the root
+   //! to that node. (The root node is at depth 0.)
+   //! 
+   //! <b>Complexity</b>: Logarithmic to the number of nodes in the tree. 
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static std::size_t depth(const_node_ptr p)
+   {
+      std::size_t depth = 0;
+      node_ptr p_parent;
+      while(p != NodeTraits::get_parent(p_parent = NodeTraits::get_parent(p))){
+         ++depth;
+         p = p_parent;
+      }
+      return depth;
+   }
+
    template<class NodePtrCompare>
    static node_ptr insert_equal_upper_bound
-      (node_ptr h, node_ptr new_node, NodePtrCompare comp)
+      (node_ptr h, node_ptr new_node, NodePtrCompare comp, 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);
@@ -980,17 +1061,20 @@ class tree_algorithms
 
       bool link_left = (y == h) || comp(new_node, y);
       link(h, new_node, y, link_left);
+      if(pdepth)  *pdepth = depth;
       return new_node;
    }
 
    template<class NodePtrCompare>
    static node_ptr insert_equal_lower_bound
-      (node_ptr h, node_ptr new_node, NodePtrCompare comp)
+      (node_ptr h, node_ptr new_node, NodePtrCompare comp, 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);
@@ -998,6 +1082,7 @@ class tree_algorithms
 
       bool link_left = (y == h) || !comp(y, new_node);
       link(h, new_node, y, link_left);
+      if(pdepth)  *pdepth = depth;
       return new_node;
    }
 
@@ -1240,7 +1325,6 @@ class tree_algorithms
       NodeTraits::set_left(z, 0);
    }
 
-   // delete node                        | complexity : constant        | exception : nothrow
    static void erase(node_ptr header, node_ptr z)
    {
       data_for_rebalance ignored;
@@ -1273,6 +1357,160 @@ class tree_algorithms
       }
    }
 
+   static void tree_to_vine(node_ptr header)
+   {  subtree_to_vine(NodeTraits::get_parent(header)); }
+
+   static void vine_to_tree(node_ptr header, std::size_t count)
+   {  vine_to_subtree(NodeTraits::get_parent(header), count);  }
+
+   static void rebalance(node_ptr header)
+   {
+      //Taken from:
+      //"Tree rebalancing in optimal time and space"
+      //Quentin F. Stout and Bette L. Warren
+      std::size_t len;
+      subtree_to_vine(NodeTraits::get_parent(header), &len);
+      vine_to_subtree(NodeTraits::get_parent(header), len);
+   }
+
+   static node_ptr rebalance_subtree(node_ptr old_root)
+   {
+      std::size_t len;
+      node_ptr new_root = subtree_to_vine(old_root, &len);
+      return vine_to_subtree(new_root, len);
+   }
+
+   static node_ptr subtree_to_vine(node_ptr old_root, std::size_t *plen = 0)
+   {
+      std::size_t len;
+      len = 0;
+      if(!old_root)   return 0;
+
+      //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);
+      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(node_ptr old_root, std::size_t count)
+   {
+      std::size_t leaf_nodes = count + 1 - ((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(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);
+      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;
+   }
+
    private:
    static void erase_impl(node_ptr header, node_ptr z, data_for_rebalance &info)
    {

include/boost/intrusive/detail/utilities.hpp

@@ -19,7 +19,10 @@
 #include <boost/intrusive/detail/ebo_functor_holder.hpp>
 #include <boost/intrusive/link_mode.hpp>
 #include <boost/intrusive/detail/mpl.hpp>
+#include <boost/intrusive/detail/assert.hpp>
+#include <boost/cstdint.hpp>
 #include <cstddef>
+#include <climits>
 #include <iterator>
 
 namespace boost {
@@ -472,6 +475,75 @@ struct member_hook_traits
    }
 };
 
+//This function uses binary search to discover the
+//highest set bit of the integer
+inline std::size_t floor_log2 (std::size_t x)
+{
+   const std::size_t Bits = sizeof(std::size_t)*CHAR_BIT;
+   const bool Size_t_Bits_Power_2= !(Bits & (Bits-1));
+   BOOST_STATIC_ASSERT(Size_t_Bits_Power_2);
+
+   std::size_t n = x;
+   std::size_t log2 = 0;
+   
+   for(std::size_t shift = Bits >> 1; shift; shift >>= 1){
+      std::size_t tmp = n >> shift;
+      if (tmp)
+   	   log2 += shift, n = tmp;
+   }
+
+   return log2;
+}
+
+inline float fast_log2 (float val)
+{
+   boost::uint32_t * const exp_ptr = reinterpret_cast <boost::uint32_t *>(&val);
+   boost::uint32_t x = *exp_ptr;
+   const int log_2 = (int)(((x >> 23) & 255) - 128);
+   x &= ~(255 << 23);
+   x += 127 << 23;
+   *exp_ptr = x;
+
+   val = ((-1.0f/3) * val + 2) * val - 2.0f/3;
+
+   return (val + log_2);
+}
+
+inline std::size_t ceil_log2 (std::size_t x)
+{
+   return ((x & (x-1))!= 0) + floor_log2(x);
+}
+
+template<std::size_t N>
+struct sqrt2_pow_max;
+
+template<>
+struct sqrt2_pow_max<32>
+{
+   static const std::size_t value = 0xb504f334;
+   static const std::size_t pow   = 31;
+};
+
+#ifdef BOOST_NO_INT64_T
+
+template<>
+struct sqrt2_pow_max<64>
+{
+   static const std::size_t value = 0xb504f333f9de6484;
+   static const std::size_t pow   = 63;
+};
+
+#endif
+
+// Returns floor(pow(sqrt(2), x * 2 + 1)).
+// Defined for X from 0 up to the number of bits in size_t minus 1.
+inline std::size_t sqrt2_pow_2xplus1 (std::size_t x)
+{
+   const std::size_t value = sqrt2_pow_max<sizeof(std::size_t)*CHAR_BIT>::value;
+   const std::size_t pow   = sqrt2_pow_max<sizeof(std::size_t)*CHAR_BIT>::pow;
+   return (value >> (pow - x)) + 1;
+}
+
 } //namespace detail
 } //namespace intrusive 
 } //namespace boost 

include/boost/intrusive/hashtable.hpp

@@ -42,6 +42,23 @@ namespace intrusive {
 
 namespace detail{
 
+template <class T>
+struct store_hash_bool
+{
+   template<bool Add>
+   struct two_or_three {one _[2 + Add];};
+   template <class U> static one test(...);
+   template <class U> static two_or_three<U::store_hash>
+      test (detail::bool_<U::store_hash>* = 0);
+   static const std::size_t value = sizeof(test<T>(0));
+};
+
+template <class T>
+struct store_hash_is_true
+{
+   static const bool value = store_hash_bool<T>::value > sizeof(one)*2;
+};
+
 template<class Config>
 struct bucket_plus_size
    : public detail::size_holder
@@ -320,9 +337,11 @@ class hashtable_impl
 
    static const bool constant_time_size = Config::constant_time_size;
    static const bool stateful_value_traits = detail::store_cont_ptr_on_it<hashtable_impl>::value;
+   static const bool store_hash = detail::store_hash_is_true<node_traits>::value;
 
    /// @cond
    private:
+   typedef detail::bool_<store_hash>                                 store_hash_t;
    typedef detail::size_holder<constant_time_size, size_type>        size_traits;
    typedef detail::data_t<Config>                                    base_type;
    typedef detail::transform_iterator
@@ -737,14 +756,15 @@ class hashtable_impl
 
    iterator insert_equal(reference value)
    {
-      size_type bucket_num, hash_func;
+      size_type bucket_num, hash_value;
       siterator it = this->priv_find
-         (value, this->priv_hasher(), this->priv_equal(), bucket_num, hash_func);
+         (value, this->priv_hasher(), this->priv_equal(), bucket_num, hash_value);
       bucket_type &b = this->priv_buckets()[bucket_num];
       if(it == invalid_local_it(this->get_real_bucket_traits())){
          it = b.before_begin();
       }
       node_ptr n = node_ptr(&from_value_to_node(value));
+      this->priv_store_hash(n, hash_value, store_hash_t());
       if(safemode_or_autounlink)
          BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n));
       this->priv_size_traits().increment();
@@ -881,6 +901,7 @@ class hashtable_impl
       bucket_type &b = this->priv_buckets()[bucket_num];
       this->priv_size_traits().increment();
       node_ptr n = node_ptr(&from_value_to_node(value));
+      this->priv_store_hash(n, commit_data.hash, store_hash_t());
       if(safemode_or_autounlink)
          BOOST_INTRUSIVE_SAFE_HOOK_DEFAULT_ASSERT(node_algorithms::unique(n));
       return iterator( b.insert_after(b.before_begin(), *n), this);
@@ -1262,8 +1283,8 @@ class hashtable_impl
    const_iterator find
       (const KeyType &key, KeyHasher hash_func, KeyValueEqual equal_func) const
    {
-      size_type bucket_n, hash;
+      size_type bucket_n, hash_value;
-      siterator sit = this->priv_find(key, hash_func, equal_func, bucket_n, hash);
+      siterator sit = this->priv_find(key, hash_func, equal_func, bucket_n, hash_value);
       return const_iterator(sit, this);
    }
 
@@ -1636,10 +1657,9 @@ class hashtable_impl
                siterator i(old_bucket.begin());
                for(;i != end; ++i){
                   const value_type &v = *this->get_real_value_traits().to_value_ptr(i.pointed_node());
-                  const std::size_t hash_value = this->priv_hasher()(v);
+                  const std::size_t hash_value = this->priv_hash_when_rehashing(v, store_hash_t());
                   const size_type new_n = (power_2_buckets)
-                     ?  ( hash_value & (new_buckets_len-1))
+                     ? (hash_value & (new_buckets_len-1)) : (hash_value % new_buckets_len);
-                     :  ( hash_value % new_buckets_len);
                   //If this is a buffer expansion don't move if it's not necessary
                   if(same_buffer && new_n == n){
                      ++before_i;
@@ -1723,6 +1743,19 @@ class hashtable_impl
 
    /// @cond
    private:
+
+   std::size_t priv_hash_when_rehashing(const value_type &v, detail::true_)
+   {  return node_traits::get_hash(this->get_real_value_traits().to_node_ptr(v));  }
+
+   std::size_t priv_hash_when_rehashing(const value_type &v, detail::false_)
+   {  return priv_hasher()(v);   }
+
+   void priv_store_hash(node_ptr p, std::size_t h, detail::true_)
+   {  return node_traits::set_hash(p, h); }
+
+   void priv_store_hash(node_ptr, std::size_t, detail::false_)
+   {}
+   
    static siterator invalid_local_it(const real_bucket_traits &b)
    {  return b.bucket_begin()->end();  }
 

include/boost/intrusive/intrusive_fwd.hpp

@@ -239,6 +239,48 @@ template
    >
 class avl_set_member_hook;
 
+//sgtree/sg_set/sg_multiset
+template
+   < class T
+   , class O1  = none
+   , class O2  = none
+   , class O3  = none
+   , class O4  = none
+   >
+class sgtree;
+
+template
+   < class T
+   , class O1  = none
+   , class O2  = none
+   , class O3  = none
+   , class O4  = none
+   >
+class sg_set;
+
+template
+   < class T
+   , class O1  = none
+   , class O2  = none
+   , class O3  = none
+   , class O4  = none
+   >
+class sg_multiset;
+
+template
+   < class O1  = none
+   , class O2  = none
+   , class O3  = none
+   >
+class bs_set_base_hook;
+
+template
+   < class O1  = none
+   , class O2  = none
+   , class O3  = none
+   >
+class bs_set_member_hook;
+
 //hash/unordered
 //rbtree/set/multiset
 template
@@ -281,6 +323,7 @@ template
    < class O1  = none
    , class O2  = none
    , class O3  = none
+   , class O4  = none
    >
 class unordered_set_base_hook;
 
@@ -288,6 +331,7 @@ template
    < class O1  = none
    , class O2  = none
    , class O3  = none
+   , class O4  = none
    >
 class unordered_set_member_hook;
 

include/boost/intrusive/options.hpp

@@ -183,6 +183,30 @@ struct compare
 /// @endcond
 };
 
+//!This option setter for scapegoat containers specifies if
+//!the intrusive scapegoat container should use a non-variable
+//!alpha value that does not need floating-point operations.
+//!
+//!If activated, the fixed alpha value is 1/sqrt(2). This
+//!option also saves some space in the container since 
+//!the alpha value and some additional data does not need
+//!to be stored in the container.
+//!
+//!If the user only needs an alpha value near 1/sqrt(2), this
+//!option also improves performance since avoids logarithm
+//!and division operations when rebalancing the tree.
+template<bool Enabled>
+struct floating_point
+{
+/// @cond
+    template<class Base>
+    struct pack : Base
+    {
+        static const bool floating_point = Enabled;
+    };
+/// @endcond
+};
+
 //!This option setter specifies the equality
 //!functor for the value type
 template<class Equal>
@@ -341,6 +365,23 @@ struct bucket_traits
 /// @endcond
 };
 
+//!This option setter specifies if the unordered hook
+//!should offer room to store the hash value.
+//!Storing the hash in the hook will speed up rehashing
+//!processes in applications where rehashing is frequent,
+//!rehashing might throw or the value is heavy to hash.
+template<bool Enabled>
+struct store_hash
+{
+/// @cond
+    template<class Base>
+    struct pack : Base
+    {
+        static const bool store_hash = Enabled;
+    };
+/// @endcond
+};
+
 //!This option setter specifies if the bucket array will be always power of two.
 //!This allows using masks instead of the default modulo operation to determine
 //!the bucket number from the hash value, leading to better performance.
@@ -386,7 +427,7 @@ template
    , class O7         = none
    , class O8         = none
    , class O9         = none
-   , class Option10        = none
+   , class Option10   = none
    >
 struct pack_options
 {
@@ -433,6 +474,7 @@ struct hook_defaults
       , link_mode<safe_link>
       , tag<default_tag>
       , optimize_size<false>
+      , store_hash<false>
       >::type
 {};
 

include/boost/intrusive/rbtree.hpp

@@ -413,10 +413,7 @@ class rbtree_impl
       if(constant_time_size)
          return this->priv_size_traits().get_size();
       else{
-         const_iterator beg(this->cbegin()), end(this->cend());
+         return (size_type)node_algorithms::size(const_node_ptr(&priv_header()));
-         size_type i = 0;
-         for(;beg != end; ++beg) ++i;
-         return i;
       }
    }
 

include/boost/intrusive/rbtree_algorithms.hpp

@@ -334,6 +334,16 @@ class rbtree_algorithms
    static std::size_t count(const_node_ptr node)
    {  return tree_algorithms::count(node);   }
 
+   //! <b>Requires</b>: header is the header node of the tree.
+   //! 
+   //! <b>Effects</b>: Returns the number of nodes above the header.
+   //! 
+   //! <b>Complexity</b>: Linear time.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static std::size_t size(const_node_ptr header)
+   {  return tree_algorithms::size(header);   }
+
    //! <b>Requires</b>: p is a node from the tree except the header.
    //! 
    //! <b>Effects</b>: Returns the next node of the tree.

include/boost/intrusive/set.hpp

@@ -114,8 +114,8 @@ class set_impl
    //! <b>Effects</b>: Detaches all elements from this. The objects in the set 
    //!   are not deleted (i.e. no destructors are called).
    //! 
-   //! <b>Complexity</b>: O(log(size()) + size()) if it's a safe-mode or auto-unlink
+   //! <b>Complexity</b>: Linear to the number of elements on the container.
-   //!   value. Otherwise constant.
+   //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
    //! 
    //! <b>Throws</b>: Nothing.
    ~set_impl() 
@@ -1179,8 +1179,8 @@ class multiset_impl
    //! <b>Effects</b>: Detaches all elements from this. The objects in the set 
    //!   are not deleted (i.e. no destructors are called).
    //! 
-   //! <b>Complexity</b>: O(log(size()) + size()) if it's a safe-mode or
+   //! <b>Complexity</b>: Linear to the number of elements on the container.
-   //!   auto-unlink value. Otherwise constant.
+   //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
    //! 
    //! <b>Throws</b>: Nothing.
    ~multiset_impl() 

include/boost/intrusive/set_hook.hpp

@@ -58,18 +58,25 @@ struct make_set_base_hook
 };
 
 //! Derive a class from set_base_hook in order to store objects in 
-//! in an set/multiset. set_base_hook holds the data necessary to maintain 
+//! in a set/multiset. set_base_hook holds the data necessary to maintain 
 //! the set/multiset and provides an appropriate value_traits class for set/multiset.
 //! 
-//! The first integer template argument defines a tag to identify the node. 
+//! The hook admits the following options: \c tag<>, \c void_pointer<>,
+//! \c link_mode<> and \c optimize_size<>.
+//!
+//! \c tag<> defines a tag to identify the node. 
 //! The same tag value can be used in different classes, but if a class is 
-//! derived from more than one set_base_hook, then each set_base_hook needs its 
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its 
 //! unique tag.
 //!
-//! The second boolean template parameter will specify the linking mode of the hook.
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
+//! and the the container configured to use this hook.
 //!
-//! The third argument is the pointer type that will be used internally in the hook
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
-//! and the set/multiset configured from this hook.
+//! \c auto_unlink or \c safe_link).
+//!
+//! \c optimize_size<> will tell the hook to optimize the hook for size instead
+//! of speed.
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
@@ -108,7 +115,7 @@ class set_base_hook
 
    //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
    //!   nothing (ie. no code is generated). If link_mode is \c safe_link and the
-   //!   object is stored in an set an assertion is raised. If link_mode is
+   //!   object is stored in a set an assertion is raised. If link_mode is
    //!   \c auto_unlink and \c is_linked() is true, the node is unlinked.
    //! 
    //! <b>Throws</b>: Nothing. 
@@ -170,13 +177,20 @@ struct make_set_member_hook
 };
 
 //! Put a public data member set_member_hook in order to store objects of this class in
-//! an set/multiset. set_member_hook holds the data necessary for maintaining the
+//! a set/multiset. set_member_hook holds the data necessary for maintaining the
 //! set/multiset and provides an appropriate value_traits class for set/multiset.
 //! 
-//! The first boolean template parameter will specify the linking mode of the hook.
+//! The hook admits the following options: \c void_pointer<>,
+//! \c link_mode<> and \c optimize_size<>.
 //!
-//! The second argument is the pointer type that will be used internally in the hook
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
-//! and the set/multiset configured from this hook.
+//! and the the container configured to use this hook.
+//!
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
+//! \c auto_unlink or \c safe_link).
+//!
+//! \c optimize_size<> will tell the hook to optimize the hook for size instead
+//! of speed.
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
@@ -215,7 +229,7 @@ class set_member_hook
 
    //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
    //!   nothing (ie. no code is generated). If link_mode is \c safe_link and the
-   //!   object is stored in an set an assertion is raised. If link_mode is
+   //!   object is stored in a set an assertion is raised. If link_mode is
    //!   \c auto_unlink and \c is_linked() is true, the node is unlinked.
    //! 
    //! <b>Throws</b>: Nothing. 

include/boost/intrusive/sgtree_algorithms.hpp

@@ -0,0 +1,704 @@
+/////////////////////////////////////////////////////////////////////////////
+//
+// (C) Copyright Ion Gaztanaga 2007.
+//
+// Distributed under the Boost Software License, Version 1.0.
+//    (See accompanying file LICENSE_1_0.txt or copy at
+//          http://www.boost.org/LICENSE_1_0.txt)
+//
+// See http://www.boost.org/libs/intrusive for documentation.
+//
+/////////////////////////////////////////////////////////////////////////////
+//
+// Scapegoat tree algorithms are taken from the paper titled:
+// "Scapegoat Trees" by Igal Galperin Ronald L. Rivest.
+//
+/////////////////////////////////////////////////////////////////////////////
+#ifndef BOOST_INTRUSIVE_SGTREE_ALGORITHMS_HPP
+#define BOOST_INTRUSIVE_SGTREE_ALGORITHMS_HPP
+
+#include <boost/intrusive/detail/config_begin.hpp>
+
+#include <cstddef>
+#include <boost/intrusive/intrusive_fwd.hpp>
+#include <boost/intrusive/detail/assert.hpp>
+#include <boost/intrusive/detail/no_exceptions_support.hpp>
+#include <boost/intrusive/detail/utilities.hpp>
+#include <boost/intrusive/detail/tree_algorithms.hpp>
+
+
+namespace boost {
+namespace intrusive {
+
+//! sgtree_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_ptr</tt>: A pointer to a node
+//!
+//! <tt>const_node_ptr</tt>: A pointer to a const node
+//!
+//! <b>Static functions</b>:
+//!
+//! <tt>static node_ptr get_parent(const_node_ptr n);</tt>
+//! 
+//! <tt>static void set_parent(node_ptr n, node_ptr parent);</tt>
+//!
+//! <tt>static node_ptr get_left(const_node_ptr n);</tt>
+//! 
+//! <tt>static void set_left(node_ptr n, node_ptr left);</tt>
+//!
+//! <tt>static node_ptr get_right(const_node_ptr n);</tt>
+//! 
+//! <tt>static void set_right(node_ptr n, node_ptr right);</tt>
+template<class NodeTraits>
+class sgtree_algorithms
+{
+   public:
+   typedef NodeTraits                           node_traits;
+   typedef typename NodeTraits::node_ptr        node_ptr;
+   typedef typename NodeTraits::const_node_ptr  const_node_ptr;
+
+   /// @cond
+   private:
+
+   typedef typename NodeTraits::node            node;
+   typedef detail::tree_algorithms<NodeTraits>  tree_algorithms;
+
+   static node_ptr uncast(const_node_ptr ptr)
+   {
+      return node_ptr(const_cast<node*>(::boost::intrusive::detail::get_pointer(ptr)));
+   }
+   /// @endcond
+
+   public:
+   static node_ptr begin_node(const_node_ptr header)
+   {  return tree_algorithms::begin_node(header);   }
+
+   static node_ptr end_node(const_node_ptr header)
+   {  return tree_algorithms::end_node(header);   }
+
+   //! This type is the information that will be
+   //! filled by insert_unique_check
+   struct insert_commit_data
+      :  tree_algorithms::insert_commit_data
+   {
+      std::size_t depth;
+   };
+
+   //! <b>Requires</b>: header1 and header2 must be the header nodes
+   //!  of two trees.
+   //! 
+   //! <b>Effects</b>: Swaps two trees. After the function header1 will contain 
+   //!   links to the second tree and header2 will have links to the first tree.
+   //! 
+   //! <b>Complexity</b>: Constant. 
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static void swap_tree(node_ptr header1, node_ptr header2)
+   {  return tree_algorithms::swap_tree(header1, header2);  }
+
+   //! <b>Requires</b>: node1 and node2 can't be header nodes
+   //!  of two trees.
+   //! 
+   //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted
+   //!   in the position node2 before the function. node2 will be inserted in the
+   //!   position node1 had before the function.
+   //! 
+   //! <b>Complexity</b>: Logarithmic. 
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>: This function will break container ordering invariants if
+   //!   node1 and node2 are not equivalent according to the ordering rules.
+   //!
+   //!Experimental function
+   static void swap_nodes(node_ptr node1, node_ptr node2)
+   {
+      if(node1 == node2)
+         return;
+   
+      node_ptr header1(tree_algorithms::get_header(node1)), header2(tree_algorithms::get_header(node2));
+      swap_nodes(node1, header1, node2, header2);
+   }
+
+   //! <b>Requires</b>: node1 and node2 can't be header nodes
+   //!  of two trees with header header1 and header2.
+   //! 
+   //! <b>Effects</b>: Swaps two nodes. After the function node1 will be inserted
+   //!   in the position node2 before the function. node2 will be inserted in the
+   //!   position node1 had before the function.
+   //! 
+   //! <b>Complexity</b>: Constant. 
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Note</b>: This function will break container ordering invariants if
+   //!   node1 and node2 are not equivalent according to the ordering rules.
+   //!
+   //!Experimental function
+   static void swap_nodes(node_ptr node1, node_ptr header1, node_ptr node2, node_ptr header2)
+   {  tree_algorithms::swap_nodes(node1, header1, node2, header2);  }
+
+   //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree
+   //!   and new_node must not be inserted in a tree.
+   //! 
+   //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the
+   //!   tree with new_node. The tree does not need to be rebalanced
+   //! 
+   //! <b>Complexity</b>: Logarithmic. 
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <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
+   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, tree_algorithms::get_header(node_to_be_replaced), new_node);
+   }
+
+   //! <b>Requires</b>: node_to_be_replaced must be inserted in a tree
+   //!   with header "header" and new_node must not be inserted in a tree.
+   //! 
+   //! <b>Effects</b>: Replaces node_to_be_replaced in its position in the
+   //!   tree with new_node. The tree does not need to be rebalanced
+   //! 
+   //! <b>Complexity</b>: Constant. 
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <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
+   static void replace_node(node_ptr node_to_be_replaced, node_ptr header, node_ptr new_node)
+   {  tree_algorithms::replace_node(node_to_be_replaced, header, new_node);  }
+
+   //! <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(node_ptr node)
+   {
+      node_ptr x = NodeTraits::get_parent(node);
+      if(x){
+         while(!is_header(x))
+            x = NodeTraits::get_parent(x);
+         tree_algorithms::erase(x, node);
+      }
+   }
+
+   //! <b>Requires</b>: header is the header of a tree.
+   //! 
+   //! <b>Effects</b>: Unlinks the leftmost node from the tree, and
+   //!   updates the header link to the new leftmost node.
+   //! 
+   //! <b>Complexity</b>: Average complexity is constant time.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Notes</b>: This function breaks the tree and the tree can
+   //!   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(node_ptr header)
+   {  return tree_algorithms::unlink_leftmost_without_rebalance(header);   }
+
+   //! <b>Requires</b>: node is a node of the tree or an node initialized
+   //!   by init(...).
+   //! 
+   //! <b>Effects</b>: Returns true if the node is initialized by init().
+   //! 
+   //! <b>Complexity</b>: Constant time.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static bool unique(const_node_ptr node)
+   {  return tree_algorithms::unique(node);  }
+
+   //! <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_node_ptr node)
+   {  return tree_algorithms::count(node);   }
+
+   //! <b>Requires</b>: header is the header node of the tree.
+   //! 
+   //! <b>Effects</b>: Returns the number of nodes above the header.
+   //! 
+   //! <b>Complexity</b>: Linear time.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static std::size_t size(const_node_ptr header)
+   {  return tree_algorithms::size(header);   }
+
+   //! <b>Requires</b>: p is a node from the tree except the header.
+   //! 
+   //! <b>Effects</b>: Returns the next node of the tree.
+   //! 
+   //! <b>Complexity</b>: Average constant time.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static node_ptr next_node(node_ptr p)
+   {  return tree_algorithms::next_node(p); }
+
+   //! <b>Requires</b>: p is a node from the tree except the leftmost node.
+   //! 
+   //! <b>Effects</b>: Returns the previous node of the tree.
+   //! 
+   //! <b>Complexity</b>: Average constant time.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static node_ptr prev_node(node_ptr p)
+   {  return tree_algorithms::prev_node(p); }
+
+   //! <b>Requires</b>: node must not be part of any tree.
+   //!
+   //! <b>Effects</b>: After the function unique(node) == true.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
+   static void init(node_ptr node)
+   {  tree_algorithms::init(node);  }
+
+   //! <b>Requires</b>: node must not be part of any tree.
+   //!
+   //! <b>Effects</b>: Initializes the header to represent an empty tree.
+   //!   unique(header) == true.
+   //! 
+   //! <b>Complexity</b>: Constant.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //!
+   //! <b>Nodes</b>: If node is inserted in a tree, this function corrupts the tree.
+   static void init_header(node_ptr header)
+   {  tree_algorithms::init_header(header);  }
+
+   //! <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.
+   template<class AlphaByMaxSize>
+   static node_ptr erase(node_ptr header, node_ptr z, std::size_t tree_size, std::size_t &max_tree_size, AlphaByMaxSize alpha_by_maxsize)
+   {
+      //typename tree_algorithms::data_for_rebalance info;
+      tree_algorithms::erase(header, z);
+      --tree_size;
+      if (tree_size > 0 && 
+          tree_size < alpha_by_maxsize(max_tree_size)){
+         tree_algorithms::rebalance(header);
+         max_tree_size = tree_size;
+      }
+      return z;
+   }
+
+   //! <b>Requires</b>: "cloner" must be a function
+   //!   object taking a node_ptr and returning a new cloned node of it. "disposer" must
+   //!   take a node_ptr and shouldn't throw.
+   //!
+   //! <b>Effects</b>: First empties target tree calling 
+   //!   <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+   //!    except the header.
+   //!    
+   //!   Then, duplicates the entire tree pointed by "source_header" cloning each
+   //!   source node with <tt>node_ptr Cloner::operator()(node_ptr)</tt> to obtain 
+   //!   the nodes of the target tree. If "cloner" throws, the cloned target nodes
+   //!   are disposed using <tt>void disposer(node_ptr)</tt>.
+   //! 
+   //! <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_node_ptr source_header, node_ptr target_header, Cloner cloner, Disposer disposer)
+   {
+      tree_algorithms::clone(source_header, target_header, cloner, disposer);
+   }
+
+   //! <b>Requires</b>: "disposer" must be an object function
+   //!   taking a node_ptr parameter and shouldn't throw.
+   //!
+   //! <b>Effects</b>: Empties the target tree calling 
+   //!   <tt>void disposer::operator()(node_ptr)</tt> for every node of the tree
+   //!    except the header.
+   //! 
+   //! <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 Disposer>
+   static void clear_and_dispose(node_ptr header, Disposer disposer)
+   {  tree_algorithms::clear_and_dispose(header, disposer); }
+
+   //! <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 first element that is
+   //!   not less than "key" according to "comp" or "header" if that element does
+   //!   not exist.
+   //!
+   //! <b>Complexity</b>: Logarithmic.
+   //! 
+   //! <b>Throws</b>: If "comp" throws.
+   template<class KeyType, class KeyNodePtrCompare>
+   static node_ptr lower_bound
+      (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+   {  return tree_algorithms::lower_bound(header, key, comp);  }
+
+   //! <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 first element that is greater
+   //!   than "key" according to "comp" or "header" if that element does not exist.
+   //!
+   //! <b>Complexity</b>: Logarithmic.
+   //! 
+   //! <b>Throws</b>: If "comp" throws.
+   template<class KeyType, class KeyNodePtrCompare>
+   static node_ptr upper_bound
+      (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+   {  return tree_algorithms::upper_bound(header, key, comp);  }
+
+   //! <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
+   //!   "key" according to "comp" or "header" if that element does not exist.
+   //!
+   //! <b>Complexity</b>: Logarithmic.
+   //! 
+   //! <b>Throws</b>: If "comp" throws.
+   template<class KeyType, class KeyNodePtrCompare>
+   static node_ptr find
+      (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+   {  return tree_algorithms::find(header, key, comp);  }
+
+   //! <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 a pair of node_ptr delimiting a range containing
+   //!   all elements that are equivalent to "key" according to "comp" or an
+   //!   empty range that indicates the position where those elements would be
+   //!   if they 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> equal_range
+      (const_node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
+   {  return tree_algorithms::equal_range(header, key, comp);  }
+
+   //! <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, class H_Alpha>
+   static node_ptr insert_equal_upper_bound
+      (node_ptr h, node_ptr new_node, NodePtrCompare comp
+      ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
+   {
+      std::size_t depth;
+      tree_algorithms::insert_equal_upper_bound(h, new_node, comp, &depth);
+      rebalance_after_insertion(new_node, depth, tree_size+1, h_alpha, max_tree_size);
+      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, class H_Alpha>
+   static node_ptr insert_equal_lower_bound
+      (node_ptr h, node_ptr new_node, NodePtrCompare comp
+      ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
+   {
+      std::size_t depth;
+      tree_algorithms::insert_equal_lower_bound(h, new_node, comp, &depth);
+      rebalance_after_insertion(new_node, depth, tree_size+1, h_alpha, max_tree_size);
+      return new_node;
+   }
+
+   //! <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, class H_Alpha>
+   static node_ptr insert_equal
+      (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp
+      ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
+   {
+      std::size_t depth;
+      tree_algorithms::insert_equal(header, hint, new_node, comp, &depth);
+      rebalance_after_insertion(new_node, depth, tree_size+1, h_alpha, max_tree_size);
+      return new_node;
+   }
+
+   //! <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.
+   //! 
+   //! <b>Effects</b>: Checks if there is an equivalent node to "key" in the
+   //!   tree according to "comp" and obtains the needed information to realize
+   //!   a constant-time node insertion if there is no equivalent node.
+   //!
+   //! <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.
+   //!
+   //! <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_node_ptr header,  const KeyType &key
+      ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
+   {
+      std::size_t depth;
+      std::pair<node_ptr, bool> ret = 
+         tree_algorithms::insert_unique_check(header, key, comp, commit_data, &depth);
+      commit_data.depth = depth;
+      return ret;
+   }
+
+   //! <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_node_ptr header,  node_ptr hint, const KeyType &key
+      ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
+   {
+      std::size_t depth;
+      std::pair<node_ptr, bool> ret = 
+         tree_algorithms::insert_unique_check
+            (header, hint, key, comp, commit_data, &depth);
+      commit_data.depth = depth;
+      return ret;
+   }
+
+   //! <b>Requires</b>: "header" must be the header node of a tree.
+   //!   "commit_data" must have been obtained from a previous call to
+   //!   "insert_unique_check". No objects should have been inserted or erased
+   //!   from the set between the "insert_unique_check" that filled "commit_data"
+   //!   and the call to "insert_commit". 
+   //! 
+   //! 
+   //! <b>Effects</b>: Inserts new_node in the set using the information obtained
+   //!   from the "commit_data" that a previous "insert_check" filled.
+   //!
+   //! <b>Complexity</b>: Constant time.
+   //!
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Notes</b>: This function has only sense if a "insert_unique_check" has been
+   //!   previously executed to fill "commit_data". No value should be inserted or
+   //!   erased between the "insert_check" and "insert_commit" calls.
+   template<class H_Alpha>
+   static void insert_unique_commit
+      (node_ptr header, node_ptr new_value, const insert_commit_data &commit_data
+      ,std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
+   {
+      tree_algorithms::insert_unique_commit(header, new_value, commit_data);
+      rebalance_after_insertion(new_value, commit_data.depth, tree_size+1, h_alpha, max_tree_size);
+   }
+
+   //! <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(node_ptr header)
+   {  tree_algorithms::rebalance(header); }
+
+   //! <b>Requires</b>: old_root is a node of a tree.
+   //! 
+   //! <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(node_ptr old_root)
+   {  return tree_algorithms::rebalance_subtree(old_root); }
+
+   /// @cond
+   private:
+
+   //! <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_node_ptr p)
+   {  return tree_algorithms::is_header(p);  }
+
+   template<class H_Alpha>
+   static void rebalance_after_insertion
+      ( node_ptr x, std::size_t depth
+      , std::size_t tree_size, H_Alpha h_alpha, std::size_t &max_tree_size)
+   {
+      if(tree_size > max_tree_size)
+         max_tree_size = tree_size;
+
+      if(tree_size != 1 && depth > h_alpha(tree_size)){
+         //Find the first non height-balanced node
+         //as described in the section 4.2 of the paper.
+         //This method is the alternative method described
+         //in the paper. Authors claim that this method
+         //may tend to yield more balanced trees on the average
+         //than the weight balanced method.
+         node_ptr s = x;
+         std::size_t size = 1;
+
+         for(std::size_t i = 1; true; ++i){
+            bool rebalance = false;
+            if(i == depth){
+               assert(tree_size == count(s));
+               rebalance = true;
+            }
+            else if(i > h_alpha(size)){
+               node_ptr s_parent = NodeTraits::get_parent(s);
+               node_ptr s_parent_left = NodeTraits::get_left(s_parent);
+               size += 1 + tree_algorithms::count
+                  ( s_parent_left == s ? NodeTraits::get_right(s_parent) : s_parent_left );
+               s = s_parent;
+               rebalance = true;
+            }
+            if(rebalance){
+               rebalance_subtree(s);
+               break;
+            }
+         }
+      }
+   }
+
+   /// @endcond
+};
+
+} //namespace intrusive 
+} //namespace boost 
+
+#include <boost/intrusive/detail/config_end.hpp>
+
+#endif //BOOST_INTRUSIVE_SGTREE_ALGORITHMS_HPP

include/boost/intrusive/slist.hpp

@@ -565,7 +565,7 @@ class slist_impl
       if(node_traits::get_next(first) == root) return;
 
       bool end_found = false;
-      node_ptr new_last;
+      node_ptr new_last(0);
 
       //Now find the new last node according to the shift count.
       //If we find the root node before finding the new last node

include/boost/intrusive/slist_hook.hpp

@@ -60,15 +60,19 @@ struct make_slist_base_hook
 //! in an list. slist_base_hook holds the data necessary to maintain the 
 //! list and provides an appropriate value_traits class for list.
 //! 
-//! The first integer template argument defines a tag to identify the node. 
+//! The hook admits the following options: \c tag<>, \c void_pointer<> and
+//! \c link_mode<>.
+//!
+//! \c tag<> defines a tag to identify the node. 
 //! The same tag value can be used in different classes, but if a class is 
-//! derived from more than one slist_base_hook, then each slist_base_hook needs its 
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its 
 //! unique tag.
 //!
-//! The second boolean template parameter will specify the linking mode of the hook.
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
+//! \c auto_unlink or \c safe_link).
 //!
-//! The third argument is the pointer type that will be used internally in the hook
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
-//! and the list configured from this hook.
+//! and the the container configured to use this hook.
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
@@ -171,10 +175,14 @@ struct make_slist_member_hook
 //! an list. slist_member_hook holds the data necessary for maintaining the list and 
 //! provides an appropriate value_traits class for list.
 //! 
-//! The first boolean template parameter will specify the linking mode of the hook.
+//! The hook admits the following options: \c void_pointer<> and
+//! \c link_mode<>.
+//! 
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
+//! \c auto_unlink or \c safe_link).
 //!
-//! The second argument is the pointer type that will be used internally in the hook
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
-//! and the list configured from this hook.
+//! and the the container configured to use this hook.
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else

include/boost/intrusive/splay_set.hpp

@@ -98,7 +98,7 @@ class splay_set_impl
    //!   [b, e).
    //! 
    //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using 
-   //!   comp and otherwise N * log N, where N is std::distance(last, first).
+   //!   comp and otherwise amortized N * log N, where N is std::distance(last, first).
    //! 
    //! <b>Throws</b>: If value_traits::node_traits::node
    //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
@@ -113,8 +113,8 @@ class splay_set_impl
    //! <b>Effects</b>: Detaches all elements from this. The objects in the splay_set 
    //!   are not deleted (i.e. no destructors are called).
    //! 
-   //! <b>Complexity</b>: O(log(size()) + size()) if it's a safe-mode or auto-unlink
+   //! <b>Complexity</b>: Linear to the number of elements on the container.
-   //!   value. Otherwise constant.
+   //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
    //! 
    //! <b>Throws</b>: Nothing.
    ~splay_set_impl() 
@@ -321,8 +321,7 @@ class splay_set_impl
    //!   returns a pair containing an iterator to the already present value
    //!   and false.
    //! 
-   //! <b>Complexity</b>: Average complexity for insert element is at
+   //! <b>Complexity</b>: Amortized logarithmic.
-   //!   most logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee.
    //! 
@@ -339,7 +338,7 @@ class splay_set_impl
    //! <b>Returns</b>: An iterator that points to the position where the 
    //!   new element was inserted into the splay_set.
    //! 
-   //! <b>Complexity</b>: Logarithmic in general, but it's amortized
+   //! <b>Complexity</b>: Amortized logarithmic in general, but it's amortized
    //!   constant time if t is inserted immediately before hint.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee.
@@ -362,7 +361,7 @@ class splay_set_impl
    //!   pair boolean and fills "commit_data" that is meant to be used with
    //!   the "insert_commit" function.
    //! 
-   //! <b>Complexity</b>: Average complexity is at most logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //!
    //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee.
    //! 
@@ -398,7 +397,7 @@ class splay_set_impl
    //!   pair boolean and fills "commit_data" that is meant to be used with
    //!   the "insert_commit" function.
    //! 
-   //! <b>Complexity</b>: Logarithmic in general, but it's amortized
+   //! <b>Complexity</b>: Amortized logarithmic in general, but it's amortized
    //!   constant time if t is inserted immediately before hint.
    //!
    //! <b>Throws</b>: If the key_value_comp ordering function throws. Strong guarantee.
@@ -447,7 +446,7 @@ class splay_set_impl
    //! 
    //! <b>Effects</b>: Inserts a range into the splay_set.
    //! 
-   //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the
+   //! <b>Complexity</b>: Insert range is amortized O(N * log(N)), where N is the
    //!   size of the range. However, it is linear in N if the range is already sorted
    //!   by value_comp().
    //! 
@@ -474,7 +473,7 @@ class splay_set_impl
 
    //! <b>Effects</b>: Erases the range pointed to by b end e. 
    //! 
-   //! <b>Complexity</b>: Average complexity for erase range is at most 
+   //! <b>Complexity</b>: Average complexity for erase range is amortized
    //!   O(log(size() + N)), where N is the number of elements in the range.
    //! 
    //! <b>Returns</b>: An iterator to the element after the erased elements.
@@ -490,7 +489,7 @@ class splay_set_impl
    //! 
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size()) + this->count(value)).
+   //! <b>Complexity</b>: Amortized O(log(size()) + this->count(value)).
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee.
    //! 
@@ -504,7 +503,7 @@ class splay_set_impl
    //! 
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + this->count(key, comp)).
+   //! <b>Complexity</b>: Amortized O(log(size() + this->count(key, comp)).
    //! 
    //! <b>Throws</b>: If the comp ordering function throws. Basic guarantee.
    //! 
@@ -556,7 +555,7 @@ class splay_set_impl
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
    //! 
-   //! <b>Complexity</b>: O(log(size() + this->count(value)). Basic guarantee.
+   //! <b>Complexity</b>: Amortized O(log(size() + this->count(value)). Basic guarantee.
    //! 
    //! <b>Throws</b>: Nothing.
    //! 
@@ -574,7 +573,7 @@ class splay_set_impl
    //!
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + this->count(key, comp)).
+   //! <b>Complexity</b>: Amortized O(log(size() + this->count(key, comp)).
    //! 
    //! <b>Throws</b>: If comp ordering function throws. Basic guarantee.
    //! 
@@ -613,7 +612,7 @@ class splay_set_impl
 
    //! <b>Effects</b>: Returns the number of contained elements with the given key
    //! 
-   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
+   //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal
    //!   to number of objects with the given key.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
@@ -623,7 +622,7 @@ class splay_set_impl
    //! <b>Effects</b>: Returns the number of contained elements with the same key
    //!   compared with the given comparison functor.
    //! 
-   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
+   //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal
    //!   to number of objects with the given key.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
@@ -654,7 +653,7 @@ class splay_set_impl
    //! <b>Effects</b>: Returns an iterator to the first element whose
    //!   key is not less than k or end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
    iterator lower_bound(const_reference value)
@@ -668,7 +667,7 @@ class splay_set_impl
    //!   key according to the comparison functor is not less than k or 
    //!   end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
    //! 
@@ -710,7 +709,7 @@ class splay_set_impl
    //! <b>Effects</b>: Returns an iterator to the first element whose
    //!   key is greater than k or end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
    iterator upper_bound(const_reference value)
@@ -724,7 +723,7 @@ class splay_set_impl
    //!   key according to the comparison functor is greater than key or 
    //!   end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
    //!
@@ -766,7 +765,7 @@ class splay_set_impl
    //! <b>Effects</b>: Finds an iterator to the first element whose value is 
    //!   "value" or end() if that element does not exist.
    //!
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
    iterator find(const_reference value)
@@ -780,7 +779,7 @@ class splay_set_impl
    //!   "key" according to the comparison functor or end() if that element 
    //!   does not exist.
    //!
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
    //!
@@ -823,7 +822,7 @@ class splay_set_impl
    //!   an empty range that indicates the position where those elements would be
    //!   if they there is no elements with key k.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
    std::pair<iterator,iterator> equal_range(const_reference value)
@@ -838,7 +837,7 @@ class splay_set_impl
    //!   that indicates the position where those elements would be
    //!   if they there is no elements with key k.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
    //!
@@ -984,7 +983,7 @@ class splay_set_impl
    //! <b>Effects</b>: Rearranges the splay set so that the element pointed by i
    //!   is placed as the root of the tree, improving future searches of this value.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    void splay_up(iterator i)
@@ -995,7 +994,7 @@ class splay_set_impl
    //!   tree. If the element is not present returns the last node compared with the key.
    //!   If the tree is empty, end() is returned.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty.
    //!
@@ -1008,7 +1007,7 @@ class splay_set_impl
    //!   with a key equivalent to value the element is placed as the root of the
    //!   tree.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty.
    //!
@@ -1016,6 +1015,26 @@ class splay_set_impl
    iterator splay_down(const value_type &value)
    {  return tree_.splay_down(value);   }
 
+   //! <b>Effects</b>: Rebalances the tree.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Complexity</b>: Linear.
+   void rebalance()
+   {  tree_.rebalance(); }
+
+   //! <b>Requires</b>: old_root is a node of a tree.
+   //! 
+   //! <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 to the elements in the subtree.
+   iterator rebalance_subtree(iterator root)
+   {  return tree_.rebalance_subtree(root); }
+
    /// @cond
    friend bool operator==(const splay_set_impl &x, const splay_set_impl &y)
    {  return x.tree_ == y.tree_;  }
@@ -1220,7 +1239,7 @@ class splay_multiset_impl
    //!   [b, e).
    //! 
    //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using
-   //!   comp and otherwise N * log N, where N is the distance between first and last.
+   //!   comp and otherwise amortized N * log N, where N is the distance between first and last.
    //! 
    //! <b>Throws</b>: If value_traits::node_traits::node
    //!   constructor throws (this does not happen with predefined Boost.Intrusive hooks)
@@ -1235,8 +1254,8 @@ class splay_multiset_impl
    //! <b>Effects</b>: Detaches all elements from this. The objects in the set 
    //!   are not deleted (i.e. no destructors are called).
    //! 
-   //! <b>Complexity</b>: O(log(size()) + size()) if it's a safe-mode or
+   //! <b>Complexity</b>: Linear to the number of elements on the container.
-   //!   auto-unlink value. Otherwise constant.
+   //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
    //! 
    //! <b>Throws</b>: Nothing.
    ~splay_multiset_impl() 
@@ -1440,8 +1459,7 @@ class splay_multiset_impl
    //! <b>Returns</b>: An iterator that points to the position where the new
    //!   element was inserted.
    //! 
-   //! <b>Complexity</b>: Average complexity for insert element is at
+   //! <b>Complexity</b>: Amortized logarithmic.
-   //!   most logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee.
    //! 
@@ -1458,7 +1476,7 @@ class splay_multiset_impl
    //! <b>Returns</b>: An iterator that points to the position where the new
    //!   element was inserted.
    //! 
-   //! <b>Complexity</b>: Logarithmic in general, but it is amortized
+   //! <b>Complexity</b>: Amortized logarithmic in general, but it is amortized
    //!   constant time if t is inserted immediately before hint.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws. Strong guarantee.
@@ -1476,7 +1494,7 @@ class splay_multiset_impl
    //! <b>Returns</b>: An iterator that points to the position where the new
    //!   element was inserted.
    //! 
-   //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the
+   //! <b>Complexity</b>: Insert range is amortized O(N * log(N)), where N is the
    //!   size of the range. However, it is linear in N if the range is already sorted
    //!   by value_comp().
    //! 
@@ -1505,7 +1523,7 @@ class splay_multiset_impl
    //!
    //! <b>Returns</b>: An iterator to the element after the erased elements.
    //! 
-   //! <b>Complexity</b>: Average complexity for erase range is at most 
+   //! <b>Complexity</b>: Average complexity for erase range is amortized
    //!   O(log(size() + N)), where N is the number of elements in the range.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -1519,7 +1537,7 @@ class splay_multiset_impl
    //! 
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + this->count(value)).
+   //! <b>Complexity</b>: Amortized O(log(size() + this->count(value)).
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee.
    //! 
@@ -1533,7 +1551,7 @@ class splay_multiset_impl
    //! 
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + this->count(key, comp)).
+   //! <b>Complexity</b>: Amortized O(log(size() + this->count(key, comp)).
    //! 
    //! <b>Throws</b>: If comp ordering function throws. Basic guarantee.
    //! 
@@ -1567,7 +1585,7 @@ class splay_multiset_impl
    //! <b>Effects</b>: Erases the range pointed to by b end e.
    //!   Disposer::operator()(pointer) is called for the removed elements.
    //! 
-   //! <b>Complexity</b>: Average complexity for erase range is at most 
+   //! <b>Complexity</b>: Average complexity for erase range is amortized
    //!   O(log(size() + N)), where N is the number of elements in the range.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -1585,7 +1603,7 @@ class splay_multiset_impl
    //! 
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + this->count(value)).
+   //! <b>Complexity</b>: Amortized O(log(size() + this->count(value)).
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws. Basic guarantee.
    //! 
@@ -1603,7 +1621,7 @@ class splay_multiset_impl
    //!
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + this->count(key, comp)).
+   //! <b>Complexity</b>: Amortized O(log(size() + this->count(key, comp)).
    //! 
    //! <b>Throws</b>: If comp ordering function throws. Basic guarantee.
    //! 
@@ -1642,7 +1660,7 @@ class splay_multiset_impl
 
    //! <b>Effects</b>: Returns the number of contained elements with the given key
    //! 
-   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
+   //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal
    //!   to number of objects with the given key.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
@@ -1652,7 +1670,7 @@ class splay_multiset_impl
    //! <b>Effects</b>: Returns the number of contained elements with the same key
    //!   compared with the given comparison functor.
    //! 
-   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
+   //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal
    //!   to number of objects with the given key.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
@@ -1683,7 +1701,7 @@ class splay_multiset_impl
    //! <b>Effects</b>: Returns an iterator to the first element whose
    //!   key is not less than k or end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
    iterator lower_bound(const_reference value)
@@ -1697,7 +1715,7 @@ class splay_multiset_impl
    //!   key according to the comparison functor is not less than k or 
    //!   end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
    //! 
@@ -1739,7 +1757,7 @@ class splay_multiset_impl
    //! <b>Effects</b>: Returns an iterator to the first element whose
    //!   key is greater than k or end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
    iterator upper_bound(const_reference value)
@@ -1753,7 +1771,7 @@ class splay_multiset_impl
    //!   key according to the comparison functor is greater than key or 
    //!   end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
    //!
@@ -1795,7 +1813,7 @@ class splay_multiset_impl
    //! <b>Effects</b>: Finds an iterator to the first element whose value is 
    //!   "value" or end() if that element does not exist.
    //!
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
    iterator find(const_reference value)
@@ -1809,7 +1827,7 @@ class splay_multiset_impl
    //!   "key" according to the comparison functor or end() if that element 
    //!   does not exist.
    //!
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
    //!
@@ -1852,7 +1870,7 @@ class splay_multiset_impl
    //!   an empty range that indicates the position where those elements would be
    //!   if they there is no elements with key k.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If the internal value_compare ordering function throws.
    std::pair<iterator,iterator> equal_range(const_reference value)
@@ -1867,7 +1885,7 @@ class splay_multiset_impl
    //!   that indicates the position where those elements would be
    //!   if they there is no elements with key k.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: If comp ordering function throws.
    //!
@@ -2013,7 +2031,7 @@ class splay_multiset_impl
    //! <b>Effects</b>: Rearranges the splay set so that the element pointed by i
    //!   is placed as the root of the tree, improving future searches of this value.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    void splay_up(iterator i)
@@ -2024,7 +2042,7 @@ class splay_multiset_impl
    //!   tree. If the element is not present returns the last node compared with the key.
    //!   If the tree is empty, end() is returned.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty.
    //!
@@ -2037,7 +2055,7 @@ class splay_multiset_impl
    //!   with a key equivalent to value the element is placed as the root of the
    //!   tree.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty.
    //!
@@ -2045,6 +2063,26 @@ class splay_multiset_impl
    iterator splay_down(const value_type &value)
    {  return tree_.splay_down(value);   }
 
+   //! <b>Effects</b>: Rebalances the tree.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Complexity</b>: Linear.
+   void rebalance()
+   {  tree_.rebalance(); }
+
+   //! <b>Requires</b>: old_root is a node of a tree.
+   //! 
+   //! <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 to the elements in the subtree.
+   iterator rebalance_subtree(iterator root)
+   {  return tree_.rebalance_subtree(root); }
+
    /// @cond
    friend bool operator==(const splay_multiset_impl &x, const splay_multiset_impl &y)
    {  return x.tree_ == y.tree_;  }

include/boost/intrusive/splay_set_hook.hpp

@@ -56,18 +56,22 @@ struct make_splay_set_base_hook
 };
 
 //! Derive a class from splay_set_base_hook in order to store objects in 
-//! in an set/multiset. splay_set_base_hook holds the data necessary to maintain 
+//! in a splay_set/splay_multiset. splay_set_base_hook holds the data necessary to maintain 
-//! the set/multiset and provides an appropriate value_traits class for set/multiset.
+//! the splay_set/splay_multiset and provides an appropriate value_traits class for splay_set/splay_multiset.
 //! 
-//! The first integer template argument defines a tag to identify the node. 
+//! The hook admits the following options: \c tag<>, \c void_pointer<>,
+//! \c link_mode<> and \c optimize_size<>.
+//!
+//! \c tag<> defines a tag to identify the node. 
 //! The same tag value can be used in different classes, but if a class is 
-//! derived from more than one splay_set_base_hook, then each splay_set_base_hook needs its 
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its 
 //! unique tag.
 //!
-//! The second boolean template parameter will specify the linking mode of the hook.
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
+//! and the the container configured to use this hook.
 //!
-//! The third argument is the pointer type that will be used internally in the hook
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
-//! and the set/multiset configured from this hook.
+//! \c auto_unlink or \c safe_link).
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
@@ -106,7 +110,7 @@ class splay_set_base_hook
 
    //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
    //!   nothing (ie. no code is generated). If link_mode is \c safe_link and the
-   //!   object is stored in an set an assertion is raised. If link_mode is
+   //!   object is stored in a set an assertion is raised. If link_mode is
    //!   \c auto_unlink and \c is_linked() is true, the node is unlinked.
    //! 
    //! <b>Throws</b>: Nothing. 
@@ -166,14 +170,19 @@ struct make_splay_set_member_hook
    typedef implementation_defined type;
 };
 
-//! Put a public data member splay_set_member_hook in order to store objects of this class in
+//! Put a public data member splay_set_member_hook in order to store objects of this
-//! an set/multiset. splay_set_member_hook holds the data necessary for maintaining the
+//! class in a splay_set/splay_multiset. splay_set_member_hook holds the data
-//! set/multiset and provides an appropriate value_traits class for set/multiset.
+//! necessary for maintaining the splay_set/splay_multiset and provides an appropriate
+//! value_traits class for splay_set/splay_multiset.
 //! 
-//! The first boolean template parameter will specify the linking mode of the hook.
+//! The hook admits the following options: \c void_pointer<>,
+//! \c link_mode<> and \c optimize_size<>.
 //!
-//! The second argument is the pointer type that will be used internally in the hook
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
-//! and the set/multiset configured from this hook.
+//! and the the container configured to use this hook.
+//!
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
+//! \c auto_unlink or \c safe_link).
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
@@ -212,7 +221,7 @@ class splay_set_member_hook
 
    //! <b>Effects</b>: If link_mode is \c normal_link, the destructor does
    //!   nothing (ie. no code is generated). If link_mode is \c safe_link and the
-   //!   object is stored in an set an assertion is raised. If link_mode is
+   //!   object is stored in a set an assertion is raised. If link_mode is
    //!   \c auto_unlink and \c is_linked() is true, the node is unlinked.
    //! 
    //! <b>Throws</b>: Nothing. 

include/boost/intrusive/splaytree.hpp

@@ -217,7 +217,7 @@ class splaytree_impl
 
    //! <b>Effects</b>: Constructs an empty tree. 
    //!   
-   //! <b>Complexity</b>: Constant. 
+   //! <b>Complexity</b>: Constant.
    //! 
    //! <b>Throws</b>: Nothing unless the copy constructor of the value_compare object throws. 
    splaytree_impl( value_compare cmp = value_compare()
@@ -235,7 +235,7 @@ class splaytree_impl
    //!   [b, e).
    //!
    //! <b>Complexity</b>: Linear in N if [b, e) is already sorted using
-   //!   comp and otherwise N * log N, where N is the distance between first and last.
+   //!   comp and otherwise amortized N * log N, where N is the distance between first and last.
    //! 
    //! <b>Throws</b>: Nothing unless the copy constructor of the value_compare object throws.
    template<class Iterator>
@@ -256,7 +256,8 @@ class splaytree_impl
    //!   are not deleted (i.e. no destructors are called), but the nodes according to 
    //!   the value_traits template parameter are reinitialized and thus can be reused. 
    //! 
-   //! <b>Complexity</b>: Linear to elements contained in *this. 
+   //! <b>Complexity</b>: Linear to the number of elements on the container.
+   //!   if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
    //! 
    //! <b>Throws</b>: Nothing.
    ~splaytree_impl() 
@@ -413,10 +414,7 @@ class splaytree_impl
          return this->priv_size_traits().get_size();
       }
       else{
-         const_iterator beg(this->cbegin()), end(this->cend());
+         return (size_type)node_algorithms::size(const_node_ptr(&priv_header()));
-         size_type i = 0;
-         for(;beg != end; ++beg) ++i;
-         return i;
       }
    }
 
@@ -443,8 +441,8 @@ class splaytree_impl
    //! 
    //! <b>Effects</b>: Inserts value into the tree before the lower bound.
    //! 
-   //! <b>Complexity</b>: Average complexity for insert element is at
+   //! <b>Complexity</b>: Average complexity for insert element is amortized
-   //!   most logarithmic.
+   //!   logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    //! 
@@ -469,7 +467,7 @@ class splaytree_impl
    //!   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
+   //! <b>Complexity</b>: Amortized logarithmic in general, but it is amortized
    //!   constant time if t is inserted immediately before hint.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -494,7 +492,7 @@ class splaytree_impl
    //! <b>Effects</b>: Inserts a each element of a range into the tree
    //!   before the upper bound of the key of each element.
    //! 
-   //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the
+   //! <b>Complexity</b>: Insert range is in general amortized O(N * log(N)), where N is the
    //!   size of the range. However, it is linear in N if the range is already sorted
    //!   by value_comp().
    //! 
@@ -517,8 +515,7 @@ class splaytree_impl
    //! <b>Effects</b>: Inserts value into the tree if the value
    //!   is not already present.
    //! 
-   //! <b>Complexity</b>: Average complexity for insert element is at
+   //! <b>Complexity</b>: Amortized logarithmic.
-   //!   most logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    //! 
@@ -539,7 +536,7 @@ class splaytree_impl
    //! <b>Effects</b>: Tries to insert x into the tree, using "hint" as a hint
    //!   to where it will be inserted.
    //! 
-   //! <b>Complexity</b>: Logarithmic in general, but it is amortized
+   //! <b>Complexity</b>: Amortized logarithmic in general, but it is amortized
    //!   constant time (two comparisons in the worst case)
    //!   if t is inserted immediately before hint.
    //! 
@@ -561,7 +558,7 @@ class splaytree_impl
    //! 
    //! <b>Effects</b>: Tries to insert each element of a range into the tree.
    //! 
-   //! <b>Complexity</b>: Insert range is in general O(N * log(N)), where N is the 
+   //! <b>Complexity</b>: Insert range is in general amortized O(N * log(N)), where N is the 
    //!   size of the range. However, it is linear in N if the range is already sorted 
    //!   by value_comp().
    //! 
@@ -644,7 +641,7 @@ class splaytree_impl
 
    //! <b>Effects</b>: Erases the range pointed to by b end e. 
    //! 
-   //! <b>Complexity</b>: Average complexity for erase range is at most 
+   //! <b>Complexity</b>: Average complexity for erase range is amortized
    //!   O(log(size() + N)), where N is the number of elements in the range.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -658,7 +655,7 @@ class splaytree_impl
    //! 
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + N).
+   //! <b>Complexity</b>: Amortized O(log(size() + N).
    //! 
    //! <b>Throws</b>: Nothing.
    //! 
@@ -672,7 +669,7 @@ class splaytree_impl
    //!
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + N).
+   //! <b>Complexity</b>: Amortized O(log(size() + N).
    //! 
    //! <b>Throws</b>: Nothing.
    //! 
@@ -712,7 +709,7 @@ class splaytree_impl
    //! <b>Effects</b>: Erases the range pointed to by b end e.
    //!   Disposer::operator()(pointer) is called for the removed elements.
    //! 
-   //! <b>Complexity</b>: Average complexity for erase range is at most 
+   //! <b>Complexity</b>: Average complexity for erase range is amortized
    //!   O(log(size() + N)), where N is the number of elements in the range.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -730,7 +727,7 @@ class splaytree_impl
    //! 
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + N).
+   //! <b>Complexity</b>: Amortized O(log(size() + N).
    //! 
    //! <b>Throws</b>: Nothing.
    //! 
@@ -753,7 +750,7 @@ class splaytree_impl
    //!
    //! <b>Returns</b>: The number of erased elements.
    //! 
-   //! <b>Complexity</b>: O(log(size() + N).
+   //! <b>Complexity</b>: Amortized O(log(size() + N).
    //! 
    //! <b>Throws</b>: Nothing.
    //! 
@@ -790,7 +787,7 @@ class splaytree_impl
 
    //! <b>Effects</b>: Erases all of the elements calling disposer(p) for
    //!   each node to be erased.
-   //! <b>Complexity</b>: Average complexity for is at most O(log(size() + N)),
+   //! <b>Complexity</b>: Amortized O(log(size() + N)),
    //!   where N is the number of elements in the container.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -808,7 +805,7 @@ class splaytree_impl
 
    //! <b>Effects</b>: Returns the number of contained elements with the given value
    //! 
-   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
+   //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal
    //!   to number of objects with the given value.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -817,7 +814,7 @@ class splaytree_impl
 
    //! <b>Effects</b>: Returns the number of contained elements with the given key
    //! 
-   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
+   //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal
    //!   to number of objects with the given key.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -830,7 +827,7 @@ class splaytree_impl
 
    //! <b>Effects</b>: Returns the number of contained elements with the given value
    //! 
-   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
+   //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal
    //!   to number of objects with the given value.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -839,7 +836,7 @@ class splaytree_impl
 
    //! <b>Effects</b>: Returns the number of contained elements with the given key
    //! 
-   //! <b>Complexity</b>: Logarithmic to the number of elements contained plus lineal
+   //! <b>Complexity</b>: Amortized logarithmic to the number of elements contained plus lineal
    //!   to number of objects with the given key.
    //! 
    //! <b>Throws</b>: Nothing.
@@ -853,7 +850,7 @@ class splaytree_impl
    //! <b>Effects</b>: Returns an iterator to the first element whose
    //!   key is not less than k or end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    iterator lower_bound(const_reference value)
@@ -901,7 +898,7 @@ class splaytree_impl
    //! <b>Effects</b>: Returns an iterator to the first element whose
    //!   key is greater than k or end() if that element does not exist.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    iterator upper_bound(const_reference value)
@@ -911,7 +908,7 @@ class splaytree_impl
    //!   key is greater than k according to comp or end() if that element
    //!   does not exist.
    //!
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    template<class KeyType, class KeyValueCompare>
@@ -951,7 +948,7 @@ class splaytree_impl
    //! <b>Effects</b>: Finds an iterator to the first element whose key is 
    //!   k or end() if that element does not exist.
    //!
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    iterator find(const_reference value)
@@ -960,7 +957,7 @@ class splaytree_impl
    //! <b>Effects</b>: Finds an iterator to the first element whose key is 
    //!   k or end() if that element does not exist.
    //!
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    template<class KeyType, class KeyValueCompare>
@@ -1000,7 +997,7 @@ class splaytree_impl
    //!   an empty range that indicates the position where those elements would be
    //!   if they there is no elements with key k.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    std::pair<iterator,iterator> equal_range(const_reference value)
@@ -1010,7 +1007,7 @@ class splaytree_impl
    //!   an empty range that indicates the position where those elements would be
    //!   if they there is no elements with key k.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    template<class KeyType, class KeyValueCompare>
@@ -1106,7 +1103,7 @@ class splaytree_impl
    //! <b>Effects</b>: Rearranges the splay set so that the element pointed by i
    //!   is placed as the root of the tree, improving future searches of this value.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Throws</b>: Nothing.
    void splay_up(iterator i)
@@ -1117,7 +1114,7 @@ class splaytree_impl
    //!   tree. If the element is not present returns the last node compared with the key.
    //!   If the tree is empty, end() is returned.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //!
    //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty.
    //!
@@ -1135,7 +1132,7 @@ class splaytree_impl
    //!   with a key equivalent to value the element is placed as the root of the
    //!   tree.
    //! 
-   //! <b>Complexity</b>: Logarithmic.
+   //! <b>Complexity</b>: Amortized logarithmic.
    //! 
    //! <b>Returns</b>: An iterator to the new root of the tree, end() if the tree is empty.
    //!
@@ -1238,6 +1235,26 @@ class splaytree_impl
    static void init_node(reference value)
    { node_algorithms::init(value_traits::to_node_ptr(value)); }
 
+   //! <b>Effects</b>: Rebalances the tree.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   //! 
+   //! <b>Complexity</b>: Linear.
+   void rebalance()
+   {  node_algorithms::rebalance(node_ptr(&priv_header())); }
+
+   //! <b>Requires</b>: old_root is a node of a tree.
+   //! 
+   //! <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 to the elements in the subtree.
+   iterator rebalance_subtree(iterator root)
+   {  return iterator(node_algorithms::rebalance_subtree(root.pointed_node()), this); }
+
 /*
    //! <b>Effects</b>: removes x from a tree of the appropriate type. It has no effect,
    //! if x is not in such a tree. 

include/boost/intrusive/splaytree_algorithms.hpp

@@ -291,6 +291,16 @@ class splaytree_algorithms
    static std::size_t count(const_node_ptr node)
    {  return tree_algorithms::count(node);   }
 
+   //! <b>Requires</b>: header is the header node of the tree.
+   //! 
+   //! <b>Effects</b>: Returns the number of nodes above the header.
+   //! 
+   //! <b>Complexity</b>: Linear time.
+   //! 
+   //! <b>Throws</b>: Nothing.
+   static std::size_t size(const_node_ptr header)
+   {  return tree_algorithms::size(header);   }
+
    //! <b>Requires</b>: header1 and header2 must be the header nodes
    //!  of two trees.
    //! 
@@ -361,20 +371,18 @@ class splaytree_algorithms
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, bool> insert_unique_check
       (node_ptr header,  const KeyType &key
-      ,KeyNodePtrCompare comp, insert_commit_data &commit_data, bool splay = true)
+      ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
    {
-      if(splay)
+      splay_down(header, key, comp);
-         splay_down(header, key, comp);
       return tree_algorithms::insert_unique_check(header, key, comp, commit_data);
    }
 
    template<class KeyType, class KeyNodePtrCompare>
    static std::pair<node_ptr, bool> insert_unique_check
       (node_ptr header,  node_ptr hint, const KeyType &key
-      ,KeyNodePtrCompare comp, insert_commit_data &commit_data, bool splay = true)
+      ,KeyNodePtrCompare comp, insert_commit_data &commit_data)
    {
-      if(splay)
+      splay_down(header, key, comp);
-         splay_down(header, key, comp);
       return tree_algorithms::insert_unique_check(header, hint, key, comp, commit_data);
    }
 
@@ -494,28 +502,25 @@ class splaytree_algorithms
    //! <b>Throws</b>: If "comp" throws.
    template<class NodePtrCompare>
    static node_ptr insert_equal
-      (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp, bool splay = true)
+      (node_ptr header, node_ptr hint, node_ptr new_node, NodePtrCompare comp)
    {
-      if(splay)
+      splay_down(header, new_node, comp);
-         splay_down(header, new_node, comp);
       return tree_algorithms::insert_equal(header, hint, new_node, comp);
    }
 
    template<class NodePtrCompare>
    static node_ptr insert_equal_upper_bound
-      (node_ptr header, node_ptr new_node, NodePtrCompare comp, bool splay = true)
+      (node_ptr header, node_ptr new_node, NodePtrCompare comp)
    {
-      if(splay)
+      splay_down(header, new_node, comp);
-         splay_down(header, new_node, comp);
       return tree_algorithms::insert_equal_upper_bound(header, new_node, comp);
    }
 
    template<class NodePtrCompare>
    static node_ptr insert_equal_lower_bound
-      (node_ptr header, node_ptr new_node, NodePtrCompare comp, bool splay = true)
+      (node_ptr header, node_ptr new_node, NodePtrCompare comp)
    {
-      if(splay)
+      splay_down(header, new_node, comp);
-         splay_down(header, new_node, comp);
       return tree_algorithms::insert_equal_lower_bound(header, new_node, comp);
    }
 
@@ -629,7 +634,7 @@ class splaytree_algorithms
 
    // top-down splay | complexity : logarithmic    | exception : strong, note A
    template<class KeyType, class KeyNodePtrCompare>
-   static node_ptr splay_down(node_ptr header, const KeyType &key, KeyNodePtrCompare comp, bool splay = true)
+   static node_ptr splay_down(node_ptr header, const KeyType &key, KeyNodePtrCompare comp)
    {
       if(!NodeTraits::get_parent(header))
          return header;
@@ -728,6 +733,28 @@ class splaytree_algorithms
       return t;
    }
 
+   //! <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(node_ptr header)
+   {  tree_algorithms::rebalance(header); }
+
+   //! <b>Requires</b>: old_root is a node of a tree.
+   //! 
+   //! <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(node_ptr old_root)
+   {  return tree_algorithms::rebalance_subtree(old_root); }
+
    private:
 
    /// @cond

include/boost/intrusive/unordered_set_hook.hpp

@@ -25,10 +25,52 @@ namespace boost {
 namespace intrusive {
 
 /// @cond
+
 template<class VoidPointer>
+struct slist_node_plus_hash
+{
+   typedef typename boost::pointer_to_other
+      <VoidPointer, slist_node_plus_hash>::type   node_ptr;
+   node_ptr    next_;
+   std::size_t hash_;
+};
+
+// slist_node_traits can be used with circular_slist_algorithms and supplies
+// a slist_node holding the pointers needed for a singly-linked list
+// it is used by slist_base_hook and slist_member_hook
+template<class VoidPointer>
+struct slist_node_traits_plus_hash
+{
+   typedef slist_node_plus_hash<VoidPointer> node;
+   typedef typename boost::pointer_to_other
+      <VoidPointer, node>::type          node_ptr;
+   typedef typename boost::pointer_to_other
+      <VoidPointer, const node>::type    const_node_ptr;
+
+   static const bool store_hash = true;
+
+   static node_ptr get_next(const_node_ptr n)
+   {  return n->next_;  }
+
+   static void set_next(node_ptr n, node_ptr next)
+   {  n->next_ = next;  }
+
+   static std::size_t get_hash(const_node_ptr n)
+   {  return n->hash_;  }  
+
+   static void set_hash(node_ptr n, std::size_t h)
+   {  n->hash_ = h;  }  
+};
+
+template<class VoidPointer, bool StoreHash>
 struct get_uset_node_algo
 {
-   typedef circular_slist_algorithms<slist_node_traits<VoidPointer> > type;
+   typedef typename detail::if_c
+      < StoreHash
+      , slist_node_traits_plus_hash<VoidPointer> 
+      , slist_node_traits<VoidPointer> 
+      >::type node_traits_type;
+   typedef circular_slist_algorithms<node_traits_type> type;
 };
 /// @endcond
 
@@ -37,16 +79,18 @@ struct get_uset_node_algo
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
-template<class O1 = none, class O2 = none, class O3 = none>
+template<class O1 = none, class O2 = none, class O3 = none, class O4 = none>
 #endif
 struct make_unordered_set_base_hook
 {
    /// @cond
    typedef typename pack_options
-      < hook_defaults, O1, O2, O3>::type packed_options;
+      < hook_defaults, O1, O2, O3, O4>::type packed_options;
 
    typedef detail::generic_hook
-   < get_slist_node_algo<typename packed_options::void_pointer>
+   < get_uset_node_algo<typename packed_options::void_pointer
+                       , packed_options::store_hash
+                       >
    , typename packed_options::tag
    , packed_options::link_mode
    , detail::UsetBaseHook
@@ -59,22 +103,29 @@ struct make_unordered_set_base_hook
 //! in an unordered_set/unordered_multi_set. unordered_set_base_hook holds the data necessary to maintain 
 //! the unordered_set/unordered_multi_set and provides an appropriate value_traits class for unordered_set/unordered_multi_set.
 //! 
-//! The first integer template argument defines a tag to identify the node. 
+//! The hook admits the following options: \c tag<>, \c void_pointer<>,
+//! \c link_mode<> and \c store_hash<>.
+//!
+//! \c tag<> defines a tag to identify the node. 
 //! The same tag value can be used in different classes, but if a class is 
-//! derived from more than one unordered_set_base_hook, then each unordered_set_base_hook needs its 
+//! derived from more than one \c list_base_hook, then each \c list_base_hook needs its 
 //! unique tag.
 //!
-//! The second boolean template parameter will specify the linking mode of the hook.
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
+//! and the the container configured to use this hook.
 //!
-//! The third argument is the pointer type that will be used internally in the hook
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
-//! and the unordered_set/unordered_multi_set configured from this hook.
+//! \c auto_unlink or \c safe_link).
+//!
+//! \c store_hash<> will tell the hook to store the hash of the value
+//! to speed up rehashings.
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
-template<class O1, class O2, class O3>
+template<class O1, class O2, class O3, class O4>
 #endif
 class unordered_set_base_hook
-   :  public make_unordered_set_base_hook<O1, O2, O3>::type
+   :  public make_unordered_set_base_hook<O1, O2, O3, O4>::type
 {
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
    //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link
@@ -149,16 +200,18 @@ class unordered_set_base_hook
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
-template<class O1 = none, class O2 = none, class O3 = none>
+template<class O1 = none, class O2 = none, class O3 = none, class O4 = none>
 #endif
 struct make_unordered_set_member_hook
 {
    /// @cond
    typedef typename pack_options
-      < hook_defaults, O1, O2, O3>::type packed_options;
+      < hook_defaults, O1, O2, O3, O4>::type packed_options;
 
    typedef detail::generic_hook
-   < get_uset_node_algo<typename packed_options::void_pointer>
+   < get_uset_node_algo< typename packed_options::void_pointer
+                       , packed_options::store_hash
+                       >
    , member_tag
    , packed_options::link_mode
    , detail::NoBaseHook
@@ -171,17 +224,24 @@ struct make_unordered_set_member_hook
 //! an unordered_set/unordered_multi_set. unordered_set_member_hook holds the data necessary for maintaining the
 //! unordered_set/unordered_multi_set and provides an appropriate value_traits class for unordered_set/unordered_multi_set.
 //! 
-//! The first boolean template parameter will specify the linking mode of the hook.
+//! The hook admits the following options: \c void_pointer<>,
+//! \c link_mode<> and \c store_hash<>.
 //!
-//! The second argument is the pointer type that will be used internally in the hook
+//! \c void_pointer<> is the pointer type that will be used internally in the hook
-//! and the unordered_set/unordered_multi_set configured from this hook.
+//! and the the container configured to use this hook.
+//!
+//! \c link_mode<> will specify the linking mode of the hook (\c normal_link,
+//! \c auto_unlink or \c safe_link).
+//!
+//! \c store_hash<> will tell the hook to store the hash of the value
+//! to speed up rehashings.
 #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
 template<class ...Options>
 #else
-template<class O1, class O2, class O3>
+template<class O1, class O2, class O3, class O4>
 #endif
 class unordered_set_member_hook
-   :  public make_unordered_set_member_hook<O1, O2, O3>::type
+   :  public make_unordered_set_member_hook<O1, O2, O3, O4>::type
 {
    #ifdef BOOST_INTRUSIVE_DOXYGEN_INVOKED
    //! <b>Effects</b>: If link_mode is \c auto_unlink or \c safe_link