| Home | Libraries | People | FAQ | More

## Class template treap

boost::intrusive::treap

## Synopsis

    // In header: <boost/intrusive/treap.hpp>

    template<typename T, class... Options>
    class treap {
    public:
      // types
      typedef Config::value_traits                                                   value_traits;
      typedef real_value_traits::pointer                                             pointer;
      typedef real_value_traits::const_pointer                                       const_pointer;
      typedef pointer_traits< pointer >::element_type                                value_type;
      typedef pointer_traits< pointer >::reference                                   reference;
      typedef pointer_traits< const_pointer >::reference                             const_reference;
      typedef pointer_traits< pointer >::difference_type                             difference_type;
      typedef value_type                                                             key_type;
      typedef Config::size_type                                                      size_type;
      typedef Config::compare                                                        value_compare;
      typedef Config::priority_compare                                               priority_compare;
      typedef value_compare                                                          key_compare;
      typedef tree_iterator< treap, false >                                          iterator;
      typedef tree_iterator< treap, true >                                           const_iterator;
      typedef unspecified                                                            reverse_iterator;
      typedef unspecified                                                            const_reverse_iterator;
      typedef real_value_traits::node_traits                                         node_traits;
      typedef node_traits::node                                                      node;
      typedef pointer_traits< pointer >::template rebind_pointer< node >::type       node_ptr;
      typedef pointer_traits< pointer >::template rebind_pointer< const node >::type const_node_ptr;
      typedef treap_algorithms< node_traits >                                        node_algorithms;
      typedef node_algorithms::insert_commit_data                                    insert_commit_data;

      // construct/copy/destruct
      explicit treap(const value_compare & = value_compare(),
                     const priority_compare & = priority_compare(),
                     const value_traits & = value_traits());
      template<typename Iterator>
        treap(bool, Iterator, Iterator, const value_compare & = value_compare(),
              const priority_compare & = priority_compare(),
              const value_traits & = value_traits());
      treap(BOOST_RV_REF(treap));
      treap& operator=(BOOST_RV_REF(treap));
      ~treap();

      // public member functions
      const real_value_traits & get_real_value_traits() const;
      real_value_traits & get_real_value_traits();
      iterator begin();
      const_iterator begin() const;
      const_iterator cbegin() const;
      iterator end();
      const_iterator end() const;
      const_iterator cend() const;
      iterator top();
      const_iterator top() const;
      const_iterator ctop() const;
      reverse_iterator rbegin();
      const_reverse_iterator rbegin() const;
      const_reverse_iterator crbegin() const;
      reverse_iterator rend();
      const_reverse_iterator rend() const;
      const_reverse_iterator crend() const;
      reverse_iterator rtop();
      const_reverse_iterator rtop() const;
      const_reverse_iterator crtop() const;
      value_compare value_comp() const;
      priority_compare priority_comp() const;
      bool empty() const;
      size_type size() const;
      void swap(treap &);
      iterator insert_equal(reference);
      iterator insert_equal(const_iterator, reference);
      template<typename Iterator> void insert_equal(Iterator, Iterator);
      std::pair< iterator, bool > insert_unique(reference);
      iterator insert_unique(const_iterator, reference);
      template<typename Iterator> void insert_unique(Iterator, Iterator);
      template<typename KeyType, typename KeyValueCompare,
               typename KeyValuePrioCompare>
        std::pair< iterator, bool >
        insert_unique_check(const KeyType &, KeyValueCompare, KeyValuePrioCompare,
                            insert_commit_data &);
      template<typename KeyType, typename KeyValueCompare,
               typename KeyValuePrioCompare>
        std::pair< iterator, bool >
        insert_unique_check(const_iterator, const KeyType &, KeyValueCompare,
                            KeyValuePrioCompare, insert_commit_data &);
      iterator insert_unique_commit(reference, const insert_commit_data &);
      iterator insert_before(const_iterator, reference);
      void push_back(reference);
      void push_front(reference);
      iterator erase(const_iterator);
      iterator erase(const_iterator, const_iterator);
      size_type erase(const_reference);
      template<typename KeyType, typename KeyValueCompare>
        size_type erase(const KeyType &, KeyValueCompare);
      template<typename Disposer>
        iterator erase_and_dispose(const_iterator, Disposer);
      template<typename Disposer>
        iterator erase_and_dispose(const_iterator, const_iterator, Disposer);
      template<typename Disposer>
        size_type erase_and_dispose(const_reference, Disposer);
      template<typename KeyType, typename KeyValueCompare, typename Disposer>
        size_type erase_and_dispose(const KeyType &, KeyValueCompare, Disposer);
      void clear();
      template<typename Disposer> void clear_and_dispose(Disposer);
      size_type count(const_reference) const;
      template<typename KeyType, typename KeyValueCompare>
        size_type count(const KeyType &, KeyValueCompare) const;
      iterator lower_bound(const_reference);
      const_iterator lower_bound(const_reference) const;
      template<typename KeyType, typename KeyValueCompare>
        iterator lower_bound(const KeyType &, KeyValueCompare);
      template<typename KeyType, typename KeyValueCompare>
        const_iterator lower_bound(const KeyType &, KeyValueCompare) const;
      iterator upper_bound(const_reference);
      template<typename KeyType, typename KeyValueCompare>
        iterator upper_bound(const KeyType &, KeyValueCompare);
      const_iterator upper_bound(const_reference) const;
      template<typename KeyType, typename KeyValueCompare>
        const_iterator upper_bound(const KeyType &, KeyValueCompare) const;
      iterator find(const_reference);
      template<typename KeyType, typename KeyValueCompare>
        iterator find(const KeyType &, KeyValueCompare);
      const_iterator find(const_reference) const;
      template<typename KeyType, typename KeyValueCompare>
        const_iterator find(const KeyType &, KeyValueCompare) const;
      std::pair< iterator, iterator > equal_range(const_reference);
      template<typename KeyType, typename KeyValueCompare>
        std::pair< iterator, iterator >
        equal_range(const KeyType &, KeyValueCompare);
      std::pair< const_iterator, const_iterator >
      equal_range(const_reference) const;
      template<typename KeyType, typename KeyValueCompare>
        std::pair< const_iterator, const_iterator >
        equal_range(const KeyType &, KeyValueCompare) const;
      std::pair< iterator, iterator >
      bounded_range(const_reference, const_reference, bool, bool);
      template<typename KeyType, typename KeyValueCompare>
        std::pair< iterator, iterator >
        bounded_range(const KeyType &, const KeyType &, KeyValueCompare, bool,
                      bool);
      std::pair< const_iterator, const_iterator >
      bounded_range(const_reference, const_reference, bool, bool) const;
      template<typename KeyType, typename KeyValueCompare>
        std::pair< const_iterator, const_iterator >
        bounded_range(const KeyType &, const KeyType &, KeyValueCompare, bool,
                      bool) const;
      template<typename Cloner, typename Disposer>
        void clone_from(const treap &, Cloner, Disposer);
      pointer unlink_leftmost_without_rebalance();
      void replace_node(iterator, reference);
      iterator iterator_to(reference);
      const_iterator iterator_to(const_reference) const;

      // public static functions
      static treap & container_from_end_iterator(iterator);
      static const treap & container_from_end_iterator(const_iterator);
      static treap & container_from_iterator(iterator);
      static const treap & container_from_iterator(const_iterator);
      static iterator s_iterator_to(reference);
      static const_iterator s_iterator_to(const_reference);
      static void init_node(reference);

      // private static functions
      static treap & priv_container_from_end_iterator(const const_iterator &);
      static treap & priv_container_from_iterator(const const_iterator &);

      // public data members
      static const bool constant_time_size;
      static const bool stateful_value_traits;
    };

## 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<>`

### `treap` public construct/copy/destruct

1.     explicit treap(const value_compare & cmp = value_compare(),
                      const priority_compare & pcmp = priority_compare(),
                      const value_traits & v_traits = value_traits());

   Effects: Constructs an empty treap.

   Complexity: Constant.

   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.

2.     template<typename Iterator>
         treap(bool unique, Iterator b, Iterator e,
               const value_compare & cmp = value_compare(),
               const priority_compare & pcmp = priority_compare(),
               const value_traits & v_traits = value_traits());

   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.

3.     treap(BOOST_RV_REF(treap) x);

   Effects: to-do

4.     treap& operator=(BOOST_RV_REF(treap) x);

   Effects: to-do

5.     ~treap();

   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

1.     const real_value_traits & get_real_value_traits() const;

2.     real_value_traits & get_real_value_traits();

3.     iterator begin();

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

   Complexity: Constant.

   Throws: Nothing.

4.     const_iterator begin() const;

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

   Complexity: Constant.

   Throws: Nothing.

5.     const_iterator cbegin() const;

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

   Complexity: Constant.

   Throws: Nothing.

6.     iterator end();

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

   Complexity: Constant.

   Throws: Nothing.

7.     const_iterator end() const;

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

   Complexity: Constant.

   Throws: Nothing.

8.     const_iterator cend() const;

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

   Complexity: Constant.

   Throws: Nothing.

9.     iterator top();

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

   Complexity: Constant.

   Throws: Nothing.

10.     const_iterator top() const;

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

    Complexity: Constant.

    Throws: Nothing.

11.     const_iterator ctop() const;

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

    Complexity: Constant.

    Throws: Nothing.

12.     reverse_iterator rbegin();

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

    Complexity: Constant.

    Throws: Nothing.

13.     const_reverse_iterator rbegin() const;

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

    Complexity: Constant.

    Throws: Nothing.

14.     const_reverse_iterator crbegin() const;

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

    Complexity: Constant.

    Throws: Nothing.

15.     reverse_iterator rend();

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

    Complexity: Constant.

    Throws: Nothing.

16.     const_reverse_iterator rend() const;

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

    Complexity: Constant.

    Throws: Nothing.

17.     const_reverse_iterator crend() const;

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

    Complexity: Constant.

    Throws: Nothing.

18.     reverse_iterator rtop();

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

    Complexity: Constant.

    Throws: Nothing.

19.     const_reverse_iterator rtop() const;

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

    Complexity: Constant.

    Throws: Nothing.

20.     const_reverse_iterator crtop() const;

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

    Complexity: Constant.

    Throws: Nothing.

21.     value_compare value_comp() const;

    Effects: Returns the value_compare object used by the treap.

    Complexity: Constant.

    Throws: If value_compare copy-constructor throws.

22.     priority_compare priority_comp() const;

    Effects: Returns the priority_compare object used by the treap.

    Complexity: Constant.

    Throws: If priority_compare copy-constructor throws.

23.     bool empty() const;

    Effects: Returns true if the container is empty.

    Complexity: Constant.

    Throws: Nothing.

24.     size_type size() 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.

    Throws: Nothing.

25.     void swap(treap & other);

    Effects: Swaps the contents of two treaps.

    Complexity: Constant.

    Throws: If the comparison functor's swap call throws.

26.     iterator insert_equal(reference value);

    Requires: value must be an lvalue

    Effects: Inserts value into the treap before the upper bound.

    Complexity: Average complexity for insert element is at most logarithmic.

    Throws: If the internal value_compare or priority_compare functions throw. Strong guarantee.

    Note: Does not affect the validity of iterators and references. No copy-constructors are called.

27.     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 treap, 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: Logarithmic in general, but it is amortized constant time if t is inserted immediately before hint.

    Throws: If the internal value_compare or priority_compare functions throw. Strong guarantee.

    Note: Does not affect the validity of iterators and references. No copy-constructors are called.

28.     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 treap before the upper bound of the key of each element.

    Complexity: Insert range is in general 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: If the internal value_compare or priority_compare functions throw. Strong guarantee.

    Note: Does not affect the validity of iterators and references. No copy-constructors are called.

29.     std::pair< iterator, bool > insert_unique(reference value);

    Requires: value must be an lvalue

    Effects: Inserts value into the treap if the value is not already present.

    Complexity: Average complexity for insert element is at most logarithmic.

    Throws: If the internal value_compare or priority_compare functions throw. Strong guarantee.

    Note: Does not affect the validity of iterators and references. No copy-constructors are called.

30.     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 treap, using "hint" as a hint to where it will be inserted.

    Complexity: Logarithmic in general, but it is amortized constant time (two comparisons in the worst case) if t is inserted immediately before hint.

    Throws: If the internal value_compare or priority_compare functions throw. Strong guarantee.

    Note: Does not affect the validity of iterators and references. No copy-constructors are called.

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

    Complexity: Insert range is in general 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: If the internal value_compare or priority_compare functions throw. Strong guarantee.

    Note: Does not affect the validity of iterators and references. No copy-constructors are called.

32.     template<typename KeyType, typename KeyValueCompare,
                 typename KeyValuePrioCompare>
          std::pair< iterator, bool >
          insert_unique_check(const KeyType & key, KeyValueCompare key_value_comp,
                              KeyValuePrioCompare key_value_pcomp,
                              insert_commit_data & commit_data);

    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.

    Complexity: Average complexity is at most logarithmic.

    Throws: If the key_value_comp or key_value_pcomp ordering functions throw. Strong guarantee.

    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.

33.     template<typename KeyType, typename KeyValueCompare,
                 typename KeyValuePrioCompare>
          std::pair< iterator, bool >
          insert_unique_check(const_iterator hint, const KeyType & key,
                              KeyValueCompare key_value_comp,
                              KeyValuePrioCompare key_value_pcomp,
                              insert_commit_data & commit_data);

    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.

    Throws: If the key_value_comp or key_value_pcomp ordering functions throw. Strong guarantee.

    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.

34.     iterator insert_unique_commit(reference value,
                                      const insert_commit_data & commit_data);

    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.

35.     iterator insert_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

    Effects: Inserts x into the treap before "pos".

    Complexity: Constant time.

    Throws: If the internal priority_compare function throws. Strong guarantee.

    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.

36.     void push_back(reference value);

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

    Effects: Inserts x into the treap in the last position.

    Complexity: Constant time.

    Throws: If the internal priority_compare function throws. Strong guarantee.

    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.

37.     void push_front(reference value);

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

    Effects: Inserts x into the treap in the first position.

    Complexity: Constant time.

    Throws: If the internal priority_compare function throws. Strong guarantee.

    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.

38.     iterator erase(const_iterator i);

    Effects: Erases the element pointed to by pos.

    Complexity: Average complexity for erase element is constant time.

    Throws: if the internal priority_compare function throws. Strong guarantee.

    Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.

39.     iterator erase(const_iterator b, const_iterator e);

    Effects: Erases the range pointed to by b end e.

    Complexity: Average complexity for erase range is at most O(log(size() + N)), where N is the number of elements in the range.

    Throws: if the internal priority_compare function throws. Strong guarantee.

    Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.

40.     size_type erase(const_reference value);

    Effects: Erases all the elements with the given value.

    Returns: The number of erased elements.

    Complexity: O(log(size() + N).

    Throws: if the internal priority_compare function throws. Strong guarantee.

    Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.

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

    Throws: if the internal priority_compare function throws. Equivalent guarantee to while(beg != end) erase(beg++);

    Note: Invalidates the iterators (but not the references) to the erased elements. No destructors are called.

42.     template<typename Disposer>
          iterator erase_and_dispose(const_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: if the internal priority_compare function throws. Strong guarantee.

    Note: Invalidates the iterators to the erased elements.

43.     template<typename Disposer>
          iterator erase_and_dispose(const_iterator b, const_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 at most O(log(size() + N)), where N is the number of elements in the range.

    Throws: if the internal priority_compare function throws. Strong guarantee.

    Note: Invalidates the iterators to the erased elements.

44.     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: 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 (but not the references) to the erased elements. No destructors are called.

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

46.     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.

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

48.     size_type count(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.

    Throws: Nothing.

49.     template<typename KeyType, typename KeyValueCompare>
          size_type count(const KeyType & key, KeyValueCompare comp) const;

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

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

    Throws: Nothing.

50.     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: Logarithmic.

    Throws: Nothing.

51.     const_iterator lower_bound(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.

52.     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.

53.     template<typename KeyType, typename KeyValueCompare>
          const_iterator lower_bound(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.

54.     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: Logarithmic.

    Throws: Nothing.

55.     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: Logarithmic.

    Throws: Nothing.

56.     const_iterator upper_bound(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.

57.     template<typename KeyType, typename KeyValueCompare>
          const_iterator upper_bound(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.

58.     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: Logarithmic.

    Throws: Nothing.

59.     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: Logarithmic.

    Throws: Nothing.

60.     const_iterator find(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.

61.     template<typename KeyType, typename KeyValueCompare>
          const_iterator find(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.

62.     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: Logarithmic.

    Throws: Nothing.

63.     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: Logarithmic.

    Throws: Nothing.

64.     std::pair< const_iterator, const_iterator >
        equal_range(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.

65.     template<typename KeyType, typename KeyValueCompare>
          std::pair< const_iterator, const_iterator >
          equal_range(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.

66.     std::pair< iterator, iterator >
        bounded_range(const_reference lower_value, const_reference upper_value,
                      bool left_closed, bool right_closed);

    Requires: 'lower_value' must not be greater than 'upper_value'. If 'lower_value' == 'upper_value', ('left_closed' || 'right_closed') must be false.

    Effects: 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

    Complexity: Logarithmic.

    Throws: If the predicate throws.

    Note: This function can be more efficient than calling upper_bound and lower_bound for lower_value and upper_value.

67.     template<typename KeyType, typename KeyValueCompare>
          std::pair< iterator, iterator >
          bounded_range(const KeyType & lower_key, const KeyType & upper_key,
                        KeyValueCompare comp, bool left_closed, bool right_closed);

    Requires: KeyValueCompare is a function object that induces a strict weak ordering compatible with the strict weak ordering used to create the the tree. 'lower_key' must not be greater than 'upper_key' according to 'comp'. If 'lower_key' == 'upper_key', ('left_closed' || 'right_closed') must be false.

    Effects: Returns an a pair with the following criteria:

    first = lower_bound(lower_key, comp) if left_closed, upper_bound(lower_key, comp) otherwise

    second = upper_bound(upper_key, comp) if right_closed, lower_bound(upper_key, comp) otherwise

    Complexity: Logarithmic.

    Throws: If "comp" throws.

    Note: This function can be more efficient than calling upper_bound and lower_bound for lower_key and upper_key.

68.     std::pair< const_iterator, const_iterator >
        bounded_range(const_reference lower_value, const_reference upper_value,
                      bool left_closed, bool right_closed) const;

    Requires: 'lower_value' must not be greater than 'upper_value'. If 'lower_value' == 'upper_value', ('left_closed' || 'right_closed') must be false.

    Effects: 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

    Complexity: Logarithmic.

    Throws: If the predicate throws.

    Note: This function can be more efficient than calling upper_bound and lower_bound for lower_value and upper_value.

69.     template<typename KeyType, typename KeyValueCompare>
          std::pair< const_iterator, const_iterator >
          bounded_range(const KeyType & lower_key, const KeyType & upper_key,
                        KeyValueCompare comp, bool left_closed, bool right_closed) const;

    Requires: KeyValueCompare is a function object that induces a strict weak ordering compatible with the strict weak ordering used to create the the tree. 'lower_key' must not be greater than 'upper_key' according to 'comp'. If 'lower_key' == 'upper_key', ('left_closed' || 'right_closed') must be false.

    Effects: Returns an a pair with the following criteria:

    first = lower_bound(lower_key, comp) if left_closed, upper_bound(lower_key, comp) otherwise

    second = upper_bound(upper_key, comp) if right_closed, lower_bound(upper_key, comp) otherwise

    Complexity: Logarithmic.

    Throws: If "comp" throws.

    Note: This function can be more efficient than calling upper_bound and lower_bound for lower_key and upper_key.

70.     template<typename Cloner, typename Disposer>
          void clone_from(const treap & src, Cloner cloner, Disposer disposer);

    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).

    Complexity: Linear to erased plus inserted elements.

    Throws: If cloner throws or predicate copy assignment throws. Basic guarantee.

71.     pointer unlink_leftmost_without_rebalance();

    Effects: Unlinks the leftmost node from the treap.

    Complexity: Average complexity is constant time.

    Throws: Nothing.

    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.

72.     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 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.

73.     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.

74.     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.

### `treap` public static functions

1.     static treap & container_from_end_iterator(iterator end_iterator);

   Precondition: end_iterator must be a valid end iterator of treap.

   Effects: Returns a const reference to the treap associated to the end iterator

   Throws: Nothing.

   Complexity: Constant.

2.     static const treap & container_from_end_iterator(const_iterator end_iterator);

   Precondition: end_iterator must be a valid end const_iterator of treap.

   Effects: Returns a const reference to the treap associated to the iterator

   Throws: Nothing.

   Complexity: Constant.

3.     static treap & container_from_iterator(iterator it);

   Precondition: it must be a valid iterator of treap.

   Effects: Returns a const reference to the treap associated to the iterator

   Throws: Nothing.

   Complexity: Logarithmic.

4.     static const treap & container_from_iterator(const_iterator it);

   Precondition: it must be a valid end const_iterator of treap.

   Effects: Returns a const reference to the treap associated to the end iterator

   Throws: Nothing.

   Complexity: Logarithmic.

5.     static iterator s_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.

   Note: This static function is available only if the value traits is stateless.

6.     static const_iterator s_iterator_to(const_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 const_iterator i belonging to the set that points to the value

   Complexity: Constant.

   Throws: Nothing.

   Note: This static function is available only if the value traits is stateless.

7.     static void init_node(reference value);

   Requires: value shall not be in a treap.

   Effects: init_node puts the hook of a value in a well-known default state.

   Throws: Nothing.

   Complexity: Constant time.

   Note: This function puts the hook in the well-known default state used by auto_unlink and safe hooks.

### `treap` private static functions

1.     static treap &
       priv_container_from_end_iterator(const const_iterator & end_iterator);

2.     static treap & priv_container_from_iterator(const const_iterator & it);