diff options
Diffstat (limited to 'boost/intrusive/sgtree_algorithms.hpp')
| -rw-r--r-- | boost/intrusive/sgtree_algorithms.hpp | 247 |
1 files changed, 136 insertions, 111 deletions
diff --git a/boost/intrusive/sgtree_algorithms.hpp b/boost/intrusive/sgtree_algorithms.hpp index f3c433225e..bad1c325a0 100644 --- a/boost/intrusive/sgtree_algorithms.hpp +++ b/boost/intrusive/sgtree_algorithms.hpp @@ -1,6 +1,6 @@ ///////////////////////////////////////////////////////////////////////////// // -// (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,15 +45,15 @@ 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> template<class NodeTraits> class sgtree_algorithms @@ -90,27 +90,27 @@ class sgtree_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. //! @@ -119,22 +119,22 @@ class sgtree_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. //! @@ -144,14 +144,14 @@ class sgtree_algorithms //! <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 @@ -167,14 +167,14 @@ class sgtree_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 @@ -185,11 +185,11 @@ class sgtree_algorithms { 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(const node_ptr & node) { @@ -202,14 +202,14 @@ class sgtree_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 @@ -219,51 +219,51 @@ class sgtree_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); } @@ -271,9 +271,9 @@ class sgtree_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. @@ -284,9 +284,9 @@ class sgtree_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. @@ -297,9 +297,9 @@ class sgtree_algorithms //! 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(const node_ptr & header, const node_ptr & z, std::size_t tree_size, std::size_t &max_tree_size, AlphaByMaxSize alpha_by_maxsize) @@ -307,7 +307,7 @@ class sgtree_algorithms //typename tree_algorithms::data_for_rebalance info; tree_algorithms::erase(header, z); --tree_size; - if (tree_size > 0 && + if (tree_size > 0 && tree_size < alpha_by_maxsize(max_tree_size)){ tree_algorithms::rebalance(header); max_tree_size = tree_size; @@ -319,18 +319,18 @@ class sgtree_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 @@ -342,13 +342,13 @@ class sgtree_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) @@ -364,7 +364,7 @@ class sgtree_algorithms //! not exist. //! //! <b>Complexity</b>: Logarithmic. - //! + //! //! <b>Throws</b>: If "comp" throws. template<class KeyType, class KeyNodePtrCompare> static node_ptr lower_bound @@ -380,7 +380,7 @@ class sgtree_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 @@ -396,7 +396,7 @@ class sgtree_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 @@ -414,13 +414,38 @@ class sgtree_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 @@ -428,10 +453,10 @@ class sgtree_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, class H_Alpha> static node_ptr insert_equal_upper_bound @@ -451,10 +476,10 @@ class sgtree_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, class H_Alpha> static node_ptr insert_equal_lower_bound @@ -472,14 +497,14 @@ class sgtree_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, class H_Alpha> static node_ptr insert_equal @@ -496,7 +521,7 @@ class sgtree_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. @@ -507,11 +532,11 @@ class sgtree_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 @@ -532,7 +557,7 @@ class sgtree_algorithms ,KeyNodePtrCompare comp, insert_commit_data &commit_data) { std::size_t depth; - std::pair<node_ptr, bool> ret = + std::pair<node_ptr, bool> ret = tree_algorithms::insert_unique_check(header, key, comp, commit_data, &depth); commit_data.depth = depth; return ret; @@ -544,13 +569,13 @@ class sgtree_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. template<class H_Alpha> @@ -567,13 +592,13 @@ class sgtree_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". @@ -589,13 +614,13 @@ class sgtree_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". @@ -613,12 +638,12 @@ class sgtree_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 @@ -627,12 +652,12 @@ class sgtree_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 @@ -653,7 +678,7 @@ class sgtree_algorithms ,KeyNodePtrCompare comp, insert_commit_data &commit_data) { std::size_t depth; - std::pair<node_ptr, bool> ret = + std::pair<node_ptr, bool> ret = tree_algorithms::insert_unique_check (header, hint, key, comp, commit_data, &depth); commit_data.depth = depth; @@ -664,16 +689,16 @@ class sgtree_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. @@ -687,23 +712,23 @@ class sgtree_algorithms } //! <b>Requires</b>: header must be the header of a tree. - //! + //! //! <b>Effects</b>: Rebalances the tree. - //! + //! //! <b>Throws</b>: Nothing. - //! + //! //! <b>Complexity</b>: Linear. static void rebalance(const node_ptr & header) { 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(const node_ptr & old_root) { return tree_algorithms::rebalance_subtree(old_root); } @@ -713,7 +738,7 @@ class sgtree_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); } @@ -722,11 +747,11 @@ class sgtree_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 tree_algorithms::is_header(p); } @@ -774,8 +799,8 @@ class sgtree_algorithms /// @endcond }; -} //namespace intrusive -} //namespace boost +} //namespace intrusive +} //namespace boost #include <boost/intrusive/detail/config_end.hpp> |