Description

The class template treap is an intrusive treap container that is used to construct intrusive set and multiset containers. The no-throw guarantee holds only, if the value_compare object and priority_compare object don't throw.

The template parameter T is the type to be managed by the container. The user can specify additional options and if no options are provided default options are used.

The container supports the following options: base_hook<>/member_hook<>/value_traits<>, constant_time_size<>, size_type<>, compare<> and priority_compare<>

Throws: If value_traits::node_traits::node constructor throws (this does not happen with predefined Boost.Intrusive hooks) or the copy constructor of the value_compare/priority_compare objects throw. Basic guarantee.

Requires: Dereferencing iterator must yield an lvalue of type value_type. cmp must be a comparison function that induces a strict weak ordering.

Effects: Constructs an empty treap and inserts elements from [b, e).

Complexity: 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.

Throws: If value_traits::node_traits::node constructor throws (this does not happen with predefined Boost.Intrusive hooks) or the copy constructor/operator() of the value_compare/priority_compare objects throw. Basic guarantee.

Effects: Detaches all elements from this. The objects in the set 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.

Complexity: Linear to elements contained in *this if constant-time size option is disabled. Constant time otherwise.

Throws: Nothing.

treap public member functions

BOOST_STATIC_ASSERT(!);

constvalue_compare&priv_comp()const;

value_compare&priv_comp();

constpriority_compare&priv_pcomp()const;

priority_compare&priv_pcomp();

constnode&priv_header()const;

node&priv_header();

size_traits&priv_size_traits();

constsize_traits&priv_size_traits()const;

constreal_value_traits&get_real_value_traits(unspecified)const;

constreal_value_traits&get_real_value_traits(unspecified)const;

real_value_traits&get_real_value_traits(unspecified);

real_value_traits&get_real_value_traits(unspecified);

constreal_value_traits&get_real_value_traits()const;

real_value_traits&get_real_value_traits();

iteratorbegin();

Effects: Returns an iterator pointing to the beginning of the treap.

Complexity: Constant.

Throws: Nothing.

const_iteratorbegin()const;

Effects: Returns a const_iterator pointing to the beginning of the treap.

Complexity: Constant.

Throws: Nothing.

const_iteratorcbegin()const;

Effects: Returns a const_iterator pointing to the beginning of the treap.

Complexity: Constant.

Throws: Nothing.

iteratorend();

Effects: Returns an iterator pointing to the end of the treap.

Complexity: Constant.

Throws: Nothing.

const_iteratorend()const;

Effects: Returns a const_iterator pointing to the end of the treap.

Complexity: Constant.

Throws: Nothing.

const_iteratorcend()const;

Effects: Returns a const_iterator pointing to the end of the treap.

Complexity: Constant.

Throws: Nothing.

iteratortop();

Effects: Returns an iterator pointing to the highest priority object of the treap.

Complexity: Constant.

Throws: Nothing.

const_iteratortop()const;

Effects: Returns a const_iterator pointing to the highest priority object of the treap..

Complexity: Constant.

Throws: Nothing.

const_iteratorctop()const;

Effects: Returns a const_iterator pointing to the highest priority object of the treap..

Complexity: Constant.

Throws: Nothing.

reverse_iteratorrbegin();

Effects: Returns a reverse_iterator pointing to the beginning of the reversed treap.

Complexity: Constant.

Throws: Nothing.

const_reverse_iteratorrbegin()const;

Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed treap.

Complexity: Constant.

Throws: Nothing.

const_reverse_iteratorcrbegin()const;

Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed treap.

Complexity: Constant.

Throws: Nothing.

reverse_iteratorrend();

Effects: Returns a reverse_iterator pointing to the end of the reversed treap.

Complexity: Constant.

Throws: Nothing.

const_reverse_iteratorrend()const;

Effects: Returns a const_reverse_iterator pointing to the end of the reversed treap.

Complexity: Constant.

Throws: Nothing.

const_reverse_iteratorcrend()const;

Effects: Returns a const_reverse_iterator pointing to the end of the reversed treap.

Complexity: Constant.

Throws: Nothing.

reverse_iteratorrtop();

Effects: Returns a reverse_iterator pointing to the highest priority object of the reversed treap.

Complexity: Constant.

Throws: Nothing.

const_reverse_iteratorrtop()const;

Effects: Returns a const_reverse_iterator pointing to the highest priority objec of the reversed treap.

Complexity: Constant.

Throws: Nothing.

const_reverse_iteratorcrtop()const;

Effects: Returns a const_reverse_iterator pointing to the highest priority object of the reversed treap.

Complexity: Constant.

Throws: Nothing.

value_comparevalue_comp()const;

Effects: Returns the value_compare object used by the treap.

Complexity: Constant.

Throws: If value_compare copy-constructor throws.

priority_comparepriority_comp()const;

Effects: Returns the priority_compare object used by the treap.

Complexity: Constant.

Throws: If priority_compare copy-constructor throws.

boolempty()const;

Effects: Returns true if the container is empty.

Complexity: Constant.

Throws: Nothing.

size_typesize()const;

Effects: Returns the number of elements stored in the treap.

Complexity: Linear to elements contained in *this if constant-time size option is disabled. Constant time otherwise.

Requires: key_value_comp must be a comparison function that induces the same strict weak ordering as value_compare. key_value_pcomp must be a comparison function that induces the same strict weak ordering as priority_compare. The difference is that key_value_pcomp and key_value_comp compare an arbitrary key with the contained values.

Effects: Checks if a value can be inserted in the container, using a user provided key instead of the value itself.

Returns: If there is an equivalent value returns a pair containing an iterator to the already present value and false. If the value can be inserted returns true in the returned pair boolean and fills "commit_data" that is meant to be used with the "insert_commit" function.

Notes: This function is used to improve performance when constructing a value_type is expensive: 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 value_type 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 value_type and use "insert_commit" to insert the object 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_commit" only if no more objects are inserted or erased from the container.

Requires: key_value_comp must be a comparison function that induces the same strict weak ordering as value_compare. key_value_pcomp must be a comparison function that induces the same strict weak ordering as priority_compare. The difference is that key_value_pcomp and key_value_comp compare an arbitrary key with the contained values.

Effects: Checks if a value can be inserted in the container, using a user provided key instead of the value itself, using "hint" as a hint to where it will be inserted.

Returns: If there is an equivalent value returns a pair containing an iterator to the already present value and false. If the value can be inserted returns true in the returned pair boolean and fills "commit_data" that is meant to be used with the "insert_commit" function.

Complexity: Logarithmic in general, but it's amortized constant time if t is inserted immediately before hint.

Notes: This function is used to improve performance when constructing a value_type is expensive: if there is an equivalent value the constructed object must be discarded. Many times, the part of the constructing that is used to impose the order is much cheaper to construct than the value_type and this function offers the possibility to use that key to check if the insertion will be successful.

If the check is successful, the user can construct the value_type and use "insert_commit" to insert the object in constant-time. This can give a total constant-time complexity to the insertion: check(O(1)) + commit(O(1)).

"commit_data" remains valid for a subsequent "insert_commit" only if no more objects are inserted or erased from the container.

Requires: value must be an lvalue of type value_type. commit_data must have been obtained from a previous call to "insert_check". No objects should have been inserted or erased from the container between the "insert_check" that filled "commit_data" and the call to "insert_commit".

Effects: Inserts the value in the avl_set using the information obtained from the "commit_data" that a previous "insert_check" filled.

Returns: An iterator to the newly inserted object.

Complexity: Constant time.

Throws: Nothing

Notes: This function has only sense if a "insert_check" has been previously executed to fill "commit_data". No value should be inserted or erased between the "insert_check" and "insert_commit" calls.

iteratorinsert_before(const_iterator pos,reference value);

Requires: value must be an lvalue, "pos" must be a valid iterator (or end) and must be the succesor of value once inserted according to the predicate

Note: This function does not check preconditions so if "pos" is not the successor of "value" treap ordering invariant will be broken. This is a low-level function to be used only for performance reasons by advanced users.

voidpush_back(reference value);

Requires: value must be an lvalue, and it must be no less than the greatest inserted key

Note: This function does not check preconditions so if value is less than the greatest inserted key treap ordering invariant will be broken. This function is slightly more efficient than using "insert_before". This is a low-level function to be used only for performance reasons by advanced users.

voidpush_front(reference value);

Requires: value must be an lvalue, and it must be no greater than the minimum inserted key

Note: This function does not check preconditions so if value is greater than the minimum inserted key treap ordering invariant will be broken. This function is slightly more efficient than using "insert_before". This is a low-level function to be used only for performance reasons by advanced users.

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: O(log(size() + N).

Throws: if the priority_compare function throws then weak guarantee and heap invariants are broken. The safest thing would be to clear or destroy the container.

Note: Invalidates the iterators to the erased elements.

voidclear();

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>voidclear_and_dispose(Disposer disposer);

Effects: Erases all of the elements calling disposer(p) for each node to be erased. Complexity: Average complexity for is at most 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_typecount(const_reference value)const;

Effects: Returns the number of contained elements with the given value

Complexity: Logarithmic to the number of elements contained plus lineal to number of objects with the given value.

Requires: Disposer::operator()(pointer) shouldn't throw. Cloner should yield to nodes equivalent to the original nodes.

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. Copies the predicate from the source container.

If cloner throws, all cloned elements are unlinked and disposed calling Disposer::operator()(pointer).

Notes: This function breaks the treap and the treap 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 treap.

voidreplace_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 treap.

Effects: Replaces replace_this in its position in the treap with with_this. The treap 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 and priority rules. This function is faster than erasing and inserting the node, since no rebalancing or comparison is needed.

iteratoriterator_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_iteratoriterator_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