const real_value_traits & get_real_value_traits() const;
real_value_traits & get_real_value_traits() ;
-
iterator begin() ;
Effects: Returns an iterator pointing to the beginning of the tree.
Complexity: Constant.
Throws: Nothing.
-
const_iterator begin() const;
Effects: Returns a const_iterator pointing to the beginning of the tree.
Complexity: Constant.
Throws: Nothing.
-
const_iterator cbegin() const;
Effects: Returns a const_iterator pointing to the beginning of the tree.
Complexity: Constant.
Throws: Nothing.
-
iterator end() ;
Effects: Returns an iterator pointing to the end of the tree.
Complexity: Constant.
Throws: Nothing.
-
const_iterator end() const;
Effects: Returns a const_iterator pointing to the end of the tree.
Complexity: Constant.
Throws: Nothing.
-
const_iterator cend() const;
Effects: Returns a const_iterator pointing to the end of the tree.
Complexity: Constant.
Throws: Nothing.
-
reverse_iterator rbegin() ;
Effects: Returns a reverse_iterator pointing to the beginning of the reversed tree.
Complexity: Constant.
Throws: Nothing.
-
const_reverse_iterator rbegin() const;
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed tree.
Complexity: Constant.
Throws: Nothing.
-
const_reverse_iterator crbegin() const;
Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed tree.
Complexity: Constant.
Throws: Nothing.
-
reverse_iterator rend() ;
Effects: Returns a reverse_iterator pointing to the end of the reversed tree.
Complexity: Constant.
Throws: Nothing.
-
const_reverse_iterator rend() const;
Effects: Returns a const_reverse_iterator pointing to the end of the reversed tree.
Complexity: Constant.
Throws: Nothing.
-
const_reverse_iterator crend() const;
Effects: Returns a const_reverse_iterator pointing to the end of the reversed tree.
Complexity: Constant.
Throws: Nothing.
-
value_compare value_comp() const;
Effects: Returns the value_compare object used by the tree.
Complexity: Constant.
Throws: If value_compare copy-constructor throws.
-
bool empty() const;
Effects: Returns true is the container is empty.
Complexity: Constant.
Throws: Nothing.
-
size_type size() const;
Effects: Returns the number of elements stored in the tree.
Complexity: Linear to elements contained in *this.
Throws: Nothing.
-
void swap(splaytree & other) ;
Effects: Swaps the contents of two multisets.
Complexity: Constant.
Throws: If the comparison functor's swap call throws.
-
iterator insert_equal(reference value) ;
Requires: value must be an lvalue
Effects: Inserts value into the tree before the lower bound.
Complexity: Average complexity for insert element is amortized logarithmic.
Throws: Nothing.
Note: Does not affect the validity of iterators and references. No copy-constructors are called.
-
iterator insert_equal(const_iterator hint, reference value) ;
Requires: value must be an lvalue, and "hint" must be a valid iterator.
Effects: Inserts x 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)
Complexity: Amortized logarithmic in general, but it is amortized constant time if t is inserted immediately before hint.
Throws: Nothing.
Note: Does not affect the validity of iterators and references. No copy-constructors are called.
-
template<typename Iterator> void insert_equal(Iterator b, Iterator e) ;
Requires: Dereferencing iterator must yield an lvalue of type value_type.
Effects: Inserts a each element of a range into the tree before the upper bound of the key of each element.
Complexity: 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().
Throws: Nothing.
Note: Does not affect the validity of iterators and references. No copy-constructors are called.
-
std::pair< iterator, bool > insert_unique(reference value) ;
Requires: value must be an lvalue
Effects: Inserts value into the tree if the value is not already present.
Complexity: Amortized logarithmic.
Throws: Nothing.
Note: Does not affect the validity of iterators and references. No copy-constructors are called.
-
iterator insert_unique(const_iterator hint, reference value) ;
Requires: value must be an lvalue, and "hint" must be a valid iterator
Effects: Tries to insert x into the tree, using "hint" as a hint to where it will be inserted.
Complexity: Amortized logarithmic in general, but it is amortized constant time (two comparisons in the worst case) if t is inserted immediately before hint.
Throws: Nothing.
Note: Does not affect the validity of iterators and references. No copy-constructors are called.
-
template<typename Iterator> void insert_unique(Iterator b, Iterator e) ;
Requires: Dereferencing iterator must yield an lvalue of type value_type.
Effects: Tries to insert each element of a range into the tree.
Complexity: 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().
Throws: Nothing.
Note: Does not affect the validity of iterators and references. No copy-constructors are called.
std::pair< iterator, bool >
insert_unique_check(const_reference value, insert_commit_data & commit_data) ;
template<typename KeyType, typename KeyValueCompare>
std::pair< iterator, bool >
insert_unique_check(const KeyType & key, KeyValueCompare key_value_comp,
insert_commit_data & commit_data) ;
std::pair< iterator, bool >
insert_unique_check(const_iterator hint, const_reference value,
insert_commit_data & commit_data) ;
template<typename KeyType, typename KeyValueCompare>
std::pair< iterator, bool >
insert_unique_check(const_iterator hint, const KeyType & key,
KeyValueCompare key_value_comp,
insert_commit_data & commit_data) ;
iterator insert_unique_commit(reference value,
const insert_commit_data & commit_data) ;
-
iterator erase(iterator i) ;
Effects: Erases the element pointed to by pos.
Complexity: Average complexity for erase element is constant time.
Throws: Nothing.
Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.
-
iterator erase(iterator b, iterator e) ;
Effects: Erases the range pointed to by b end e.
Complexity: Average complexity for erase range is amortized O(log(size() + N)), where N is the number of elements in the range.
Throws: Nothing.
Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.
-
size_type erase(const_reference value) ;
Effects: Erases all the elements with the given value.
Returns: The number of erased elements.
Complexity: Amortized O(log(size() + N).
Throws: Nothing.
Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.
-
template<typename KeyType, typename KeyValueCompare>
size_type erase(const KeyType & key, KeyValueCompare comp) ;
Effects: Erases all the elements with the given key. according to the comparison functor "comp".
Returns: The number of erased elements.
Complexity: Amortized O(log(size() + N).
Throws: Nothing.
Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.
-
template<typename Disposer>
iterator erase_and_dispose(iterator i, Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases the element pointed to by pos. Disposer::operator()(pointer) is called for the removed element.
Complexity: Average complexity for erase element is constant time.
Throws: Nothing.
Note: Invalidates the iterators to the erased elements.
-
template<typename Disposer>
iterator erase_and_dispose(iterator b, iterator e, Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases the range pointed to by b end e. Disposer::operator()(pointer) is called for the removed elements.
Complexity: Average complexity for erase range is amortized O(log(size() + N)), where N is the number of elements in the range.
Throws: Nothing.
Note: Invalidates the iterators to the erased elements.
-
template<typename Disposer>
size_type erase_and_dispose(const_reference value, Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases all the elements with the given value. Disposer::operator()(pointer) is called for the removed elements.
Returns: The number of erased elements.
Complexity: Amortized O(log(size() + N).
Throws: Nothing.
Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.
-
template<typename KeyType, typename KeyValueCompare, typename Disposer>
size_type erase_and_dispose(const KeyType & key, KeyValueCompare comp,
Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases all the elements with the given key. according to the comparison functor "comp". Disposer::operator()(pointer) is called for the removed elements.
Returns: The number of erased elements.
Complexity: Amortized O(log(size() + N).
Throws: Nothing.
Note: Invalidates the iterators to the erased elements.
-
void clear() ;
Effects: Erases all of the elements.
Complexity: Linear to the number of elements on the container. if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
Throws: Nothing.
Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.
-
template<typename Disposer> void clear_and_dispose(Disposer disposer) ;
Effects: Erases all of the elements calling disposer(p) for each node to be erased. Complexity: Amortized O(log(size() + N)), where N is the number of elements in the container.
Throws: Nothing.
Note: Invalidates the iterators (but not the references) to the erased elements. Calls N times to disposer functor.
-
size_type count(const_reference value) ;
Effects: Returns the number of contained elements with the given value
Complexity: Amortized logarithmic to the number of elements contained plus lineal to number of objects with the given value.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
size_type count(const KeyType & key, KeyValueCompare comp) ;
Effects: Returns the number of contained elements with the given key
Complexity: Amortized logarithmic to the number of elements contained plus lineal to number of objects with the given key.
Throws: Nothing.
-
size_type count_dont_splay(const_reference value) const;
Effects: Returns the number of contained elements with the given value
Complexity: Amortized logarithmic to the number of elements contained plus lineal to number of objects with the given value.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
size_type count_dont_splay(const KeyType & key, KeyValueCompare comp) const;
Effects: Returns the number of contained elements with the given key
Complexity: Amortized logarithmic to the number of elements contained plus lineal to number of objects with the given key.
Throws: Nothing.
-
iterator lower_bound(const_reference value) ;
Effects: Returns an iterator to the first element whose key is not less than k or end() if that element does not exist.
Complexity: Amortized logarithmic.
Throws: Nothing.
-
const_iterator lower_bound_dont_splay(const_reference value) const;
Effects: Returns an iterator to the first element whose key is not less than k or end() if that element does not exist.
Complexity: Logarithmic.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
iterator lower_bound(const KeyType & key, KeyValueCompare comp) ;
Effects: Returns an iterator to the first element whose key is not less than k or end() if that element does not exist.
Complexity: Logarithmic.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
const_iterator
lower_bound_dont_splay(const KeyType & key, KeyValueCompare comp) const;
Effects: Returns a const iterator to the first element whose key is not less than k or end() if that element does not exist.
Complexity: Logarithmic.
Throws: Nothing.
-
iterator upper_bound(const_reference value) ;
Effects: Returns an iterator to the first element whose key is greater than k or end() if that element does not exist.
Complexity: Amortized logarithmic.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
iterator upper_bound(const KeyType & key, KeyValueCompare comp) ;
Effects: Returns an iterator to the first element whose key is greater than k according to comp or end() if that element does not exist.
Complexity: Amortized logarithmic.
Throws: Nothing.
-
const_iterator upper_bound_dont_splay(const_reference value) const;
Effects: Returns an iterator to the first element whose key is greater than k or end() if that element does not exist.
Complexity: Logarithmic.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
const_iterator
upper_bound_dont_splay(const KeyType & key, KeyValueCompare comp) const;
Effects: Returns an iterator to the first element whose key is greater than k according to comp or end() if that element does not exist.
Complexity: Logarithmic.
Throws: Nothing.
-
iterator find(const_reference value) ;
Effects: Finds an iterator to the first element whose key is k or end() if that element does not exist.
Complexity: Amortized logarithmic.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
iterator find(const KeyType & key, KeyValueCompare comp) ;
Effects: Finds an iterator to the first element whose key is k or end() if that element does not exist.
Complexity: Amortized logarithmic.
Throws: Nothing.
-
const_iterator find_dont_splay(const_reference value) const;
Effects: Finds a const_iterator to the first element whose key is k or end() if that element does not exist.
Complexity: Logarithmic.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
const_iterator
find_dont_splay(const KeyType & key, KeyValueCompare comp) const;
Effects: Finds a const_iterator to the first element whose key is k or end() if that element does not exist.
Complexity: Logarithmic.
Throws: Nothing.
-
std::pair< iterator, iterator > equal_range(const_reference value) ;
Effects: Finds a range containing all elements whose key is k or an empty range that indicates the position where those elements would be if they there is no elements with key k.
Complexity: Amortized logarithmic.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
std::pair< iterator, iterator >
equal_range(const KeyType & key, KeyValueCompare comp) ;
Effects: Finds a range containing all elements whose key is k or an empty range that indicates the position where those elements would be if they there is no elements with key k.
Complexity: Amortized logarithmic.
Throws: Nothing.
-
std::pair< const_iterator, const_iterator >
equal_range_dont_splay(const_reference value) const;
Effects: Finds a range containing all elements whose key is k or an empty range that indicates the position where those elements would be if they there is no elements with key k.
Complexity: Logarithmic.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
std::pair< const_iterator, const_iterator >
equal_range_dont_splay(const KeyType & key, KeyValueCompare comp) const;
Effects: Finds a range containing all elements whose key is k or an empty range that indicates the position where those elements would be if they there is no elements with key k.
Complexity: Logarithmic.
Throws: Nothing.
-
template<typename Cloner, typename Disposer>
void clone_from(const splaytree & src, Cloner cloner, Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases all the elements from *this calling Disposer::operator()(pointer), clones all the elements from src calling Cloner::operator()(const_reference ) and inserts them on *this.
If cloner throws, all cloned elements are unlinked and disposed calling Disposer::operator()(pointer).
Complexity: Linear to erased plus inserted elements.
Throws: If cloner throws.
-
pointer unlink_leftmost_without_rebalance() ;
Effects: Unlinks the leftmost node from the tree.
Complexity: Average complexity is constant time.
Throws: Nothing.
Notes: 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.
-
void splay_up(iterator i) ;
Requires: i must be a valid iterator of *this.
Effects: 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.
Complexity: Amortized logarithmic.
Throws: Nothing.
-
template<typename KeyType, typename KeyValueCompare>
iterator splay_down(const KeyType & key, KeyValueCompare comp) ;
Effects: Rearranges the splay set so that if *this stores an element with a key equivalent to value the element is placed as the root of the tree. If the element is not present returns the last node compared with the key. If the tree is empty, end() is returned.
Complexity: Amortized logarithmic.
Returns: An iterator to the new root of the tree, end() if the tree is empty.
Throws: If the comparison functor throws.
-
iterator splay_down(const value_type & value) ;
Effects: Rearranges the splay set so that if *this stores an element with a key equivalent to value the element is placed as the root of the tree.
Complexity: Amortized logarithmic.
Returns: An iterator to the new root of the tree, end() if the tree is empty.
Throws: If the predicate throws.
-
void replace_node(iterator replace_this, reference with_this) ;
Requires: replace_this must be a valid iterator of *this and with_this must not be inserted in any tree.
Effects: Replaces replace_this in its position in the tree with with_this. The tree does not need to be rebalanced.
Complexity: Constant.
Throws: Nothing.
Note: This function will break container ordering invariants if with_this is not equivalent to *replace_this according to the ordering rules. This function is faster than erasing and inserting the node, since no rebalancing or comparison is needed.
-
iterator iterator_to(reference value) ;
Requires: value must be an lvalue and shall be in a set of appropriate type. Otherwise the behavior is undefined.
Effects: Returns: a valid iterator i belonging to the set that points to the value
Complexity: Constant.
Throws: Nothing.
-
const_iterator iterator_to(const_reference value) const;
Requires: value must be an lvalue and shall be in a set of appropriate type. Otherwise the behavior is undefined.
Effects: Returns: a valid const_iterator i belonging to the set that points to the value
Complexity: Constant.
Throws: Nothing.
-
void rebalance() ;
Effects: Rebalances the tree.
Throws: Nothing.
Complexity: Linear.
-
iterator rebalance_subtree(iterator root) ;
Requires: old_root is a node of a tree.
Effects: Rebalances the subtree rooted at old_root.
Returns: The new root of the subtree.
Throws: Nothing.
Complexity: Linear to the elements in the subtree.