summaryrefslogtreecommitdiff
path: root/boost/intrusive/avltree_algorithms.hpp
diff options
context:
space:
mode:
Diffstat (limited to 'boost/intrusive/avltree_algorithms.hpp')
-rw-r--r--boost/intrusive/avltree_algorithms.hpp253
1 files changed, 139 insertions, 114 deletions
diff --git a/boost/intrusive/avltree_algorithms.hpp b/boost/intrusive/avltree_algorithms.hpp
index 9b917c767d..11463c71fb 100644
--- a/boost/intrusive/avltree_algorithms.hpp
+++ b/boost/intrusive/avltree_algorithms.hpp
@@ -1,7 +1,7 @@
/////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Daniel K. O. 2005.
-// (C) Copyright Ion Gaztanaga 2007.
+// (C) Copyright Ion Gaztanaga 2007-2012
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
@@ -45,25 +45,25 @@ namespace intrusive {
//! <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>
-//!
+//!
//! <tt>static balance get_balance(const_node_ptr n);</tt>
-//!
+//!
//! <tt>static void set_balance(node_ptr n, balance b);</tt>
-//!
+//!
//! <tt>static balance negative();</tt>
-//!
+//!
//! <tt>static balance zero();</tt>
-//!
+//!
//! <tt>static balance positive();</tt>
template<class NodeTraits>
class avltree_algorithms
@@ -88,7 +88,7 @@ class avltree_algorithms
avltree_node_cloner(F f)
: base_t(f)
{}
-
+
node_ptr operator()(const node_ptr &p)
{
node_ptr n = base_t::get()(p);
@@ -120,27 +120,27 @@ class avltree_algorithms
//! <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
+ //!
+ //! <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>Complexity</b>: Constant.
+ //!
//! <b>Throws</b>: Nothing.
static void swap_tree(const node_ptr & header1, const 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>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.
//!
@@ -149,22 +149,22 @@ class avltree_algorithms
{
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>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.
//!
@@ -176,20 +176,20 @@ class avltree_algorithms
tree_algorithms::swap_nodes(node1, header1, node2, header2);
//Swap balance
balance c = NodeTraits::get_balance(node1);
- NodeTraits::set_balance(node1, NodeTraits::get_balance(node2));
- NodeTraits::set_balance(node2, c);
+ NodeTraits::set_balance(node1, NodeTraits::get_balance(node2));
+ NodeTraits::set_balance(node2, c);
}
//! <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>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
@@ -205,14 +205,14 @@ class avltree_algorithms
//! <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>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
@@ -222,15 +222,15 @@ class avltree_algorithms
static void replace_node(const node_ptr & node_to_be_replaced, const node_ptr & header, const node_ptr & new_node)
{
tree_algorithms::replace_node(node_to_be_replaced, header, new_node);
- NodeTraits::set_balance(new_node, NodeTraits::get_balance(node_to_be_replaced));
+ NodeTraits::set_balance(new_node, NodeTraits::get_balance(node_to_be_replaced));
}
//! <b>Requires</b>: node is a tree node but not the header.
- //!
+ //!
//! <b>Effects</b>: Unlinks the node and rebalances the tree.
- //!
+ //!
//! <b>Complexity</b>: Average complexity is constant time.
- //!
+ //!
//! <b>Throws</b>: Nothing.
static void unlink(const node_ptr & node)
{
@@ -243,14 +243,14 @@ class avltree_algorithms
}
//! <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
@@ -260,51 +260,51 @@ class avltree_algorithms
//! <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 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 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 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(const 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(const node_ptr & p)
{ return tree_algorithms::prev_node(p); }
@@ -312,9 +312,9 @@ class avltree_algorithms
//! <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.
@@ -325,25 +325,25 @@ class avltree_algorithms
//!
//! <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(const node_ptr & header)
{
tree_algorithms::init_header(header);
- NodeTraits::set_balance(header, NodeTraits::zero());
+ NodeTraits::set_balance(header, NodeTraits::zero());
}
//! <b>Requires</b>: header must be the header of a tree, z a node
//! of that tree and z != header.
//!
//! <b>Effects</b>: Erases node "z" from the tree with header "header".
- //!
+ //!
//! <b>Complexity</b>: Amortized constant time.
- //!
+ //!
//! <b>Throws</b>: Nothing.
static node_ptr erase(const node_ptr & header, const node_ptr & z)
{
@@ -361,18 +361,18 @@ class avltree_algorithms
//! 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
+ //! <b>Effects</b>: First empties target tree calling
//! <tt>void disposer::operator()(const 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()(const node_ptr &)</tt> to obtain
+ //! source node with <tt>node_ptr Cloner::operator()(const node_ptr &)</tt> to obtain
//! the nodes of the target tree. If "cloner" throws, the cloned target nodes
//! are disposed using <tt>void disposer(const node_ptr &)</tt>.
- //!
+ //!
//! <b>Complexity</b>: Linear to the number of element of the source tree plus the.
//! 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
@@ -385,13 +385,13 @@ class avltree_algorithms
//! <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
+ //! <b>Effects</b>: Empties the target tree calling
//! <tt>void disposer::operator()(const 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(const node_ptr & header, Disposer disposer)
@@ -407,7 +407,7 @@ class avltree_algorithms
//! not exist.
//!
//! <b>Complexity</b>: Logarithmic.
- //!
+ //!
//! <b>Throws</b>: If "comp" throws.
template<class KeyType, class KeyNodePtrCompare>
static node_ptr lower_bound
@@ -423,7 +423,7 @@ class avltree_algorithms
//! 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
@@ -439,7 +439,7 @@ class avltree_algorithms
//! "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
@@ -457,13 +457,38 @@ class avltree_algorithms
//! 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 const_node_ptr & header, const KeyType &key, KeyNodePtrCompare comp)
{ return tree_algorithms::equal_range(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.
+ //! 'lower_key' must not be greater than 'upper_key' according to 'comp'. If
+ //! 'lower_key' == 'upper_key', ('left_closed' || 'right_closed') must be false.
+ //!
+ //! <b>Effects</b>: Returns an a pair with the following criteria:
+ //!
+ //! first = lower_bound(lower_key) if left_closed, upper_bound(lower_key) otherwise
+ //!
+ //! second = upper_bound(upper_key) if right_closed, lower_bound(upper_key) otherwise
+ //!
+ //! <b>Complexity</b>: Logarithmic.
+ //!
+ //! <b>Throws</b>: If "comp" throws.
+ //!
+ //! <b>Note</b>: This function can be more efficient than calling upper_bound
+ //! and lower_bound for lower_key and upper_key.
+ template<class KeyType, class KeyNodePtrCompare>
+ static std::pair<node_ptr, node_ptr> bounded_range
+ (const const_node_ptr & header, const KeyType &lower_key, const KeyType &upper_key, KeyNodePtrCompare comp
+ , bool left_closed, bool right_closed)
+ { return tree_algorithms::bounded_range(header, lower_key, upper_key, comp, left_closed, right_closed); }
+
//! <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
@@ -471,10 +496,10 @@ class avltree_algorithms
//!
//! <b>Effects</b>: Inserts new_node into the tree before the upper bound
//! according to "comp".
- //!
+ //!
//! <b>Complexity</b>: Average complexity for insert element is at
//! most logarithmic.
- //!
+ //!
//! <b>Throws</b>: If "comp" throws.
template<class NodePtrCompare>
static node_ptr insert_equal_upper_bound
@@ -492,10 +517,10 @@ class avltree_algorithms
//!
//! <b>Effects</b>: Inserts new_node into the tree before the lower bound
//! according to "comp".
- //!
+ //!
//! <b>Complexity</b>: Average complexity for insert element is at
//! most logarithmic.
- //!
+ //!
//! <b>Throws</b>: If "comp" throws.
template<class NodePtrCompare>
static node_ptr insert_equal_lower_bound
@@ -511,14 +536,14 @@ class avltree_algorithms
//! ordering compatible with the strict weak ordering used to create the
//! the tree. NodePtrCompare compares two node_ptrs. "hint" is node from
//! the "header"'s tree.
- //!
+ //!
//! <b>Effects</b>: Inserts new_node into the tree, using "hint" as a hint to
//! where it will be inserted. If "hint" is the upper_bound
//! the insertion takes constant time (two comparisons in the worst case).
//!
//! <b>Complexity</b>: Logarithmic in general, but it is amortized
//! constant time if new_node is inserted immediately before "hint".
- //!
+ //!
//! <b>Throws</b>: If "comp" throws.
template<class NodePtrCompare>
static node_ptr insert_equal
@@ -534,13 +559,13 @@ class avltree_algorithms
//! "pos" must be an iterator pointing to the successor to "new_node"
//! once inserted according to the order of already inserted nodes. This function does not
//! check "pos" and this precondition must be guaranteed by the caller.
- //!
+ //!
//! <b>Effects</b>: Inserts new_node into the tree before "pos".
//!
//! <b>Complexity</b>: Constant-time.
- //!
+ //!
//! <b>Throws</b>: Nothing.
- //!
+ //!
//! <b>Note</b>: If "pos" is not the successor of the newly inserted "new_node"
//! tree invariants might be broken.
static node_ptr insert_before
@@ -554,13 +579,13 @@ class avltree_algorithms
//! <b>Requires</b>: "header" must be the header node of a tree.
//! "new_node" must be, according to the used ordering no less than the
//! greatest inserted key.
- //!
+ //!
//! <b>Effects</b>: Inserts new_node into the tree before "pos".
//!
//! <b>Complexity</b>: Constant-time.
- //!
+ //!
//! <b>Throws</b>: Nothing.
- //!
+ //!
//! <b>Note</b>: If "new_node" is less than the greatest inserted key
//! tree invariants are broken. This function is slightly faster than
//! using "insert_before".
@@ -573,13 +598,13 @@ class avltree_algorithms
//! <b>Requires</b>: "header" must be the header node of a tree.
//! "new_node" must be, according to the used ordering, no greater than the
//! lowest inserted key.
- //!
+ //!
//! <b>Effects</b>: Inserts new_node into the tree before "pos".
//!
//! <b>Complexity</b>: Constant-time.
- //!
+ //!
//! <b>Throws</b>: Nothing.
- //!
+ //!
//! <b>Note</b>: If "new_node" is greater than the lowest inserted key
//! tree invariants are broken. This function is slightly faster than
//! using "insert_before".
@@ -593,7 +618,7 @@ class avltree_algorithms
//! 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.
@@ -604,11 +629,11 @@ class avltree_algorithms
//! 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
@@ -634,12 +659,12 @@ class avltree_algorithms
//! 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
+ //! 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
@@ -648,12 +673,12 @@ class avltree_algorithms
//! 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
@@ -678,16 +703,16 @@ class avltree_algorithms
//! "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".
- //!
- //!
+ //! 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.
@@ -703,7 +728,7 @@ class avltree_algorithms
//! <b>Effects</b>: Returns a pointer to the header node of the tree.
//!
//! <b>Complexity</b>: Logarithmic.
- //!
+ //!
//! <b>Throws</b>: Nothing.
static node_ptr get_header(const node_ptr & n)
{ return tree_algorithms::get_header(n); }
@@ -712,11 +737,11 @@ class avltree_algorithms
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 const_node_ptr & p)
{ return NodeTraits::get_balance(p) == NodeTraits::zero() && tree_algorithms::is_header(p); }
@@ -727,7 +752,7 @@ class avltree_algorithms
for (node_ptr root = NodeTraits::get_parent(header); x != root; root = NodeTraits::get_parent(header)) {
const balance x_parent_balance = NodeTraits::get_balance(x_parent);
if(x_parent_balance == NodeTraits::zero()){
- NodeTraits::set_balance(x_parent,
+ NodeTraits::set_balance(x_parent,
(x == NodeTraits::get_right(x_parent) ? NodeTraits::negative() : NodeTraits::positive()));
break; // the height didn't change, let's stop here
}
@@ -935,8 +960,8 @@ class avltree_algorithms
/// @endcond
};
-} //namespace intrusive
-} //namespace boost
+} //namespace intrusive
+} //namespace boost
#include <boost/intrusive/detail/config_end.hpp>