const real_value_traits & get_real_value_traits() const;
real_value_traits & get_real_value_traits() ;
-
void clear() ;
Effects: Erases all the elements of the container.
Throws: Nothing.
Complexity: Linear to the number of elements of the list. if it's a safe-mode or auto-unlink value_type. Constant time otherwise.
Note: Invalidates the iterators (but not the references) to the erased elements.
-
template<typename Disposer> void clear_and_dispose(Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases all the elements of the container Disposer::operator()(pointer) is called for the removed elements.
Throws: Nothing.
Complexity: Linear to the number of elements of the list.
Note: Invalidates the iterators to the erased elements.
-
void push_front(reference value) ;
Requires: value must be an lvalue.
Effects: Inserts the value in the front of the list. No copy constructors are called.
Throws: Nothing.
Complexity: Constant.
Note: Does not affect the validity of iterators and references.
-
void push_back(reference value) ;
Requires: value must be an lvalue.
Effects: Inserts the value in the back of the list. No copy constructors are called.
Throws: Nothing.
Complexity: Constant.
Note: Does not affect the validity of iterators and references. This function is only available is cache_last<> is true.
-
void pop_front() ;
Effects: Erases the first element of the list. No destructors are called.
Throws: Nothing.
Complexity: Constant.
Note: Invalidates the iterators (but not the references) to the erased element.
-
template<typename Disposer> void pop_front_and_dispose(Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases the first element of the list. Disposer::operator()(pointer) is called for the removed element.
Throws: Nothing.
Complexity: Constant.
Note: Invalidates the iterators to the erased element.
-
reference front() ;
Effects: Returns a reference to the first element of the list.
Throws: Nothing.
Complexity: Constant.
-
const_reference front() const;
Effects: Returns a const_reference to the first element of the list.
Throws: Nothing.
Complexity: Constant.
-
reference back() ;
Effects: Returns a reference to the last element of the list.
Throws: Nothing.
Complexity: Constant.
Note: Does not affect the validity of iterators and references. This function is only available is cache_last<> is true.
-
const_reference back() const;
Effects: Returns a const_reference to the last element of the list.
Throws: Nothing.
Complexity: Constant.
Note: Does not affect the validity of iterators and references. This function is only available is cache_last<> is true.
-
iterator begin() ;
Effects: Returns an iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant.
-
const_iterator begin() const;
Effects: Returns a const_iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant.
-
const_iterator cbegin() const;
Effects: Returns a const_iterator to the first element contained in the list.
Throws: Nothing.
Complexity: Constant.
-
iterator end() ;
Effects: Returns an iterator to the end of the list.
Throws: Nothing.
Complexity: Constant.
-
const_iterator end() const;
Effects: Returns a const_iterator to the end of the list.
Throws: Nothing.
Complexity: Constant.
-
const_iterator cend() const;
Effects: Returns a const_iterator to the end of the list.
Throws: Nothing.
Complexity: Constant.
-
iterator before_begin() ;
Effects: Returns an iterator that points to a position before the first element. Equivalent to "end()"
Throws: Nothing.
Complexity: Constant.
-
const_iterator before_begin() const;
Effects: Returns an iterator that points to a position before the first element. Equivalent to "end()"
Throws: Nothing.
Complexity: Constant.
-
const_iterator cbefore_begin() const;
Effects: Returns an iterator that points to a position before the first element. Equivalent to "end()"
Throws: Nothing.
Complexity: Constant.
-
size_type size() const;
Effects: Returns the number of the elements contained in the list.
Throws: Nothing.
Complexity: Linear to the number of elements contained in the list. if constant_time_size is false. Constant time otherwise.
Note: Does not affect the validity of iterators and references.
-
bool empty() const;
Effects: Returns true if the list contains no elements.
Throws: Nothing.
Complexity: Constant.
Note: Does not affect the validity of iterators and references.
-
void swap(slist & other) ;
Effects: Swaps the elements of x and *this.
Throws: Nothing.
Complexity: Linear to the number of elements of both lists. Constant-time if linear<> and/or cache_last<> options are used.
Note: Does not affect the validity of iterators and references.
-
void shift_backwards(size_type n = 1) ;
Effects: Moves backwards all the elements, so that the first element becomes the second, the second becomes the third... the last element becomes the first one.
Throws: Nothing.
Complexity: Linear to the number of elements plus the number shifts.
Note: Iterators Does not affect the validity of iterators and references.
-
void shift_forward(size_type n = 1) ;
Effects: Moves forward all the elements, so that the second element becomes the first, the third becomes the second... the first element becomes the last one.
Throws: Nothing.
Complexity: Linear to the number of elements plus the number shifts.
Note: Does not affect the validity of iterators and references.
-
template<typename Cloner, typename Disposer>
void clone_from(const slist & 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.
-
iterator insert_after(iterator prev_p, reference value) ;
Requires: value must be an lvalue and prev_p must point to an element contained by the list or to end().
Effects: Inserts the value after the position pointed by prev_p. No copy constructor is called.
Returns: An iterator to the inserted element.
Throws: Nothing.
Complexity: Constant.
Note: Does not affect the validity of iterators and references.
-
template<typename Iterator>
void insert_after(iterator prev_p, Iterator first, Iterator last) ;
Requires: Dereferencing iterator must yield an lvalue of type value_type and prev_p must point to an element contained by the list or to the end node.
Effects: Inserts the [first, last) after the position prev_p.
Throws: Nothing.
Complexity: Linear to the number of elements inserted.
Note: Does not affect the validity of iterators and references.
-
iterator insert(iterator p, reference value) ;
Requires: value must be an lvalue and p must point to an element contained by the list or to end().
Effects: Inserts the value before the position pointed by p. No copy constructor is called.
Throws: Nothing.
Complexity: Linear to the number of elements before p. Constant-time if cache_last<> is true and p == end().
Note: Does not affect the validity of iterators and references.
-
template<typename Iterator> void insert(iterator p, Iterator b, Iterator e) ;
Requires: Dereferencing iterator must yield an lvalue of type value_type and p must point to an element contained by the list or to the end node.
Effects: Inserts the pointed by b and e before the position p. No copy constructors are called.
Throws: Nothing.
Complexity: Linear to the number of elements inserted plus linear to the elements before b. Linear to the number of elements to insert if cache_last<> option is true and p == end().
Note: Does not affect the validity of iterators and references.
-
iterator erase_after(iterator prev) ;
Effects: Erases the element after the element pointed by prev of the list. No destructors are called.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
Complexity: Constant.
Note: Invalidates the iterators (but not the references) to the erased element.
-
iterator erase_after(iterator before_first, iterator last) ;
Effects: Erases the range (before_first, last) from the list. No destructors are called.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
Complexity: Linear to the number of erased elements if it's a safe-mode , auto-unlink value or constant-time size is activated. Constant time otherwise.
Note: Invalidates the iterators (but not the references) to the erased element.
-
iterator erase_after(iterator before_first, iterator last, difference_type n) ;
Effects: Erases the range (before_first, last) from the list. n must be std::distance(before_first, last) - 1. No destructors are called.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
Complexity: constant-time if link_mode is normal_link. Linear to the elements (last - before_first) otherwise.
Note: Invalidates the iterators (but not the references) to the erased element.
-
iterator erase(iterator i) ;
Effects: Erases the element pointed by i of the list. No destructors are called.
Returns: the first element remaining beyond the removed element, or end() if no such element exists.
Throws: Nothing.
Complexity: Linear to the elements before i.
Note: Invalidates the iterators (but not the references) to the erased element.
-
iterator erase(iterator first, iterator last) ;
Requires: first and last must be valid iterator to elements in *this.
Effects: Erases the range pointed by b and e. No destructors are called.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
Complexity: Linear to the elements before last.
Note: Invalidates the iterators (but not the references) to the erased elements.
-
iterator erase(iterator first, iterator last, difference_type n) ;
Effects: Erases the range [first, last) from the list. n must be std::distance(first, last). No destructors are called.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
Complexity: linear to the elements before first if link_mode is normal_link and constant_time_size is activated. Linear to the elements before last otherwise.
Note: Invalidates the iterators (but not the references) to the erased element.
-
template<typename Disposer>
iterator erase_after_and_dispose(iterator prev, Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases the element after the element pointed by prev of the list. Disposer::operator()(pointer) is called for the removed element.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
Complexity: Constant.
Note: Invalidates the iterators to the erased element.
-
template<typename Disposer>
iterator erase_after_and_dispose(iterator before_first, iterator last,
Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases the range (before_first, last) from the list. Disposer::operator()(pointer) is called for the removed elements.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
Complexity: Lineal to the elements (last - before_first + 1).
Note: Invalidates the iterators to the erased element.
-
template<typename Disposer>
iterator erase_and_dispose(iterator i, Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Erases the element pointed by i of the list. No destructors are called. Disposer::operator()(pointer) is called for the removed element.
Returns: the first element remaining beyond the removed element, or end() if no such element exists.
Throws: Nothing.
Complexity: Linear to the elements before i.
Note: Invalidates the iterators (but not the references) to the erased element.
-
template<typename Disposer>
iterator erase_and_dispose(iterator first, iterator last, Disposer disposer) ;
Requires: first and last must be valid iterator to elements in *this. Disposer::operator()(pointer) shouldn't throw.
Effects: Erases the range pointed by b and e. No destructors are called. Disposer::operator()(pointer) is called for the removed elements.
Returns: the first element remaining beyond the removed elements, or end() if no such element exists.
Throws: Nothing.
Complexity: Linear to the number of erased elements plus linear to the elements before first.
Note: Invalidates the iterators (but not the references) to the erased elements.
-
template<typename Iterator> void assign(Iterator b, Iterator e) ;
Requires: Dereferencing iterator must yield an lvalue of type value_type.
Effects: Clears the list and inserts the range pointed by b and e. No destructors or copy constructors are called.
Throws: Nothing.
Complexity: Linear to the number of elements inserted plus linear to the elements contained in the list if it's a safe-mode or auto-unlink value. Linear to the number of elements inserted in the list otherwise.
Note: Invalidates the iterators (but not the references) to the erased elements.
-
template<typename Iterator, typename Disposer>
void dispose_and_assign(Disposer disposer, Iterator b, Iterator e) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Requires: Dereferencing iterator must yield an lvalue of type value_type.
Effects: Clears the list and inserts the range pointed by b and e. No destructors or copy constructors are called. Disposer::operator()(pointer) is called for the removed elements.
Throws: Nothing.
Complexity: Linear to the number of elements inserted plus linear to the elements contained in the list.
Note: Invalidates the iterators (but not the references) to the erased elements.
-
iterator splice_after(iterator prev, slist & x) ;
Requires: prev is an iterator to an element or x.end()/x.before_begin() in x.
Effects: Transfers all the elements of list x to this list, after the the element pointed by prev. No destructors or copy constructors are called.
Returns: The last element inserted of x or prev if x is empty. This iterator can be used as new "prev" iterator for a new splice_after call. that will splice new values after the previously spliced values.
Throws: Nothing.
Complexity: Linear to the elements contained in x. Constant-time if cache_last<> option is true.
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
-
void splice_after(iterator prev_pos, slist & x, iterator prev_ele) ;
Requires: prev must point to an element contained by this list or to the before_begin() element. prev_ele must point to an element contained in list x or must be x.before_begin().
Effects: Transfers the element after prev_ele, from list x to this list, after the element pointed by prev. No destructors or copy constructors are called.
Throws: Nothing.
Complexity: Constant.
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
-
void splice_after(iterator prev_pos, slist & x, iterator before_first,
iterator before_last) ;
Requires: prev_pos must be a dereferenceable iterator in *this or be before_begin(), and before_first and before_last belong to x and ++before_first != x.end() && before_last != x.end().
Effects: Transfers the range (before_first, before_last] from list x to this list, after the element pointed by prev_pos. No destructors or copy constructors are called.
Throws: Nothing.
Complexity: Linear to the number of elements transferred if constant_time_size is true. Constant-time otherwise.
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
-
void splice_after(iterator prev_pos, slist & x, iterator before_first,
iterator before_last, difference_type n) ;
Requires: prev_pos must be a dereferenceable iterator in *this or be before_begin(), and before_first and before_last belong to x and ++before_first != x.end() && before_last != x.end() and n == std::distance(before_first, before_last).
Effects: Transfers the range (before_first, before_last] from list x to this list, after the element pointed by p. No destructors or copy constructors are called.
Throws: Nothing.
Complexity: Constant time.
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
-
iterator splice(iterator it, slist & x) ;
Requires: it is an iterator to an element in x.
Effects: Transfers all the elements of list x to this list, before the the element pointed by it. No destructors or copy constructors are called.
Returns: The last element inserted of x or the previous element of it if x is empty. This iterator can be used as new "prev" iterator for a new splice call. that will splice new values after the previously spliced values.
Throws: Nothing.
Complexity: Linear to the elements contained in x plus linear to the elements before it. Linear to the elements before it if cache_last<> option is true. Constant-time if cache_last<> option is true and it == end().
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
-
void splice(iterator pos, slist & x, iterator elem) ;
Requires: it p must be a valid iterator of *this. elem must point to an element contained in list x.
Effects: Transfers the element elem, from list x to this list, before the element pointed by pos. No destructors or copy constructors are called.
Throws: Nothing.
Complexity: Linear to the elements before pos and before elem. Linear to the elements before elem if cache_last<> option is true and pos == end().
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
-
void splice(iterator pos, slist & x, iterator first, iterator last) ;
Requires: pos must be a dereferenceable iterator in *this and first and last belong to x and first and last a valid range on x.
Effects: Transfers the range [first, last) from list x to this list, before the element pointed by pos. No destructors or copy constructors are called.
Throws: Nothing.
Complexity: Linear to the sum of elements before pos, first, and last plus linear to the number of elements transferred if constant_time_size is true. Linear to the sum of elements before first, and last plus linear to the number of elements transferred if constant_time_size is true if cache_last<> is true and pos == end()
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
-
void splice(iterator pos, slist & x, iterator first, iterator last,
difference_type n) ;
Requires: pos must be a dereferenceable iterator in *this and first and last belong to x and first and last a valid range on x. n == std::distance(first, last).
Effects: Transfers the range [first, last) from list x to this list, before the element pointed by pos. No destructors or copy constructors are called.
Throws: Nothing.
Complexity: Linear to the sum of elements before pos, first, and last. Linear to the sum of elements before first and last if cache_last<> is true and pos == end().
Note: Iterators of values obtained from list x now point to elements of this list. Iterators of this list and all the references are not invalidated.
-
template<typename Predicate> void sort(Predicate p) ;
Effects: This function sorts the list *this according to std::less<value_type>. The sort is stable, that is, the relative order of equivalent elements is preserved.
Throws: If value_traits::node_traits::node constructor throws (this does not happen with predefined Boost.Intrusive hooks) or the predicate throws. Basic guarantee.
Complexity: The number of comparisons is approximately N log N, where N is the list's size.
Note: Iterators and references are not invalidated
-
void sort() ;
Requires: p must be a comparison function that induces a strict weak ordering and both *this and x must be sorted according to that ordering The lists x and *this must be distinct.
Effects: This function removes all of x's elements and inserts them in order into *this. The merge is stable; that is, if an element from *this is equivalent to one from x, then the element from *this will precede the one from x.
Throws: If value_traits::node_traits::node constructor throws (this does not happen with predefined Boost.Intrusive hooks) or std::less<value_type> throws. Basic guarantee.
Complexity: This function is linear time: it performs at most size() + x.size() - 1 comparisons.
Note: Iterators and references are not invalidated.
-
template<typename Predicate> iterator merge(slist & x, Predicate p) ;
Requires: p must be a comparison function that induces a strict weak ordering and both *this and x must be sorted according to that ordering The lists x and *this must be distinct.
Effects: This function removes all of x's elements and inserts them in order into *this. The merge is stable; that is, if an element from *this is equivalent to one from x, then the element from *this will precede the one from x.
Returns: An iterator to the last transferred value, end() is x is empty.
Throws: If the predicate throws. Basic guarantee.
Complexity: This function is linear time: it performs at most size() + x.size() - 1 comparisons.
Note: Iterators and references are not invalidated.
-
void merge(slist & x) ;
Effects: This function removes all of x's elements and inserts them in order into *this according to std::less<value_type>. The merge is stable; that is, if an element from *this is equivalent to one from x, then the element from *this will precede the one from x.
Throws: if std::less<value_type> throws. Basic guarantee.
Complexity: This function is linear time: it performs at most size() + x.size() - 1 comparisons.
Note: Iterators and references are not invalidated
-
void reverse() ;
Effects: Reverses the order of elements in the list.
Throws: Nothing.
Complexity: This function is linear to the contained elements.
Note: Iterators and references are not invalidated
-
void remove(const_reference value) ;
Effects: Removes all the elements that compare equal to value. No destructors are called.
Throws: If std::equal_to<value_type> throws. Basic guarantee.
Complexity: Linear time. It performs exactly size() comparisons for equality.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid. This function is linear time: it performs exactly size() comparisons for equality.
-
template<typename Disposer>
void remove_and_dispose(const_reference value, Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Removes all the elements that compare equal to value. Disposer::operator()(pointer) is called for every removed element.
Throws: If std::equal_to<value_type> throws. Basic guarantee.
Complexity: Linear time. It performs exactly size() comparisons for equality.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
-
template<typename Pred> void remove_if(Pred pred) ;
Effects: Removes all the elements for which a specified predicate is satisfied. No destructors are called.
Throws: If pred throws. Basic guarantee.
Complexity: Linear time. It performs exactly size() calls to the predicate.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
-
template<typename Pred, typename Disposer>
void remove_and_dispose_if(Pred pred, Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Removes all the elements for which a specified predicate is satisfied. Disposer::operator()(pointer) is called for every removed element.
Throws: If pred throws. Basic guarantee.
Complexity: Linear time. It performs exactly size() comparisons for equality.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
-
void unique() ;
Effects: Removes adjacent duplicate elements or adjacent elements that are equal from the list. No destructors are called.
Throws: If std::equal_to<value_type> throws. Basic guarantee.
Complexity: Linear time (size()-1) comparisons calls to pred()).
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
-
template<typename BinaryPredicate> void unique(BinaryPredicate pred) ;
Effects: Removes adjacent duplicate elements or adjacent elements that satisfy some binary predicate from the list. No destructors are called.
Throws: If the predicate throws. Basic guarantee.
Complexity: Linear time (size()-1) comparisons equality comparisons.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
-
template<typename Disposer> void unique_and_dispose(Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Removes adjacent duplicate elements or adjacent elements that satisfy some binary predicate from the list. Disposer::operator()(pointer) is called for every removed element.
Throws: If std::equal_to<value_type> throws. Basic guarantee.
Complexity: Linear time (size()-1) comparisons equality comparisons.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
-
template<typename BinaryPredicate, typename Disposer>
void unique_and_dispose(BinaryPredicate pred, Disposer disposer) ;
Requires: Disposer::operator()(pointer) shouldn't throw.
Effects: Removes adjacent duplicate elements or adjacent elements that satisfy some binary predicate from the list. Disposer::operator()(pointer) is called for every removed element.
Throws: If the predicate throws. Basic guarantee.
Complexity: Linear time (size()-1) comparisons equality comparisons.
Note: The relative order of elements that are not removed is unchanged, and iterators to elements that are not removed remain valid.
-
iterator iterator_to(reference value) ;
Requires: value must be a reference to a value inserted in a list.
Effects: This function returns a const_iterator pointing to the element
Throws: Nothing.
Complexity: Constant time.
Note: Iterators and references are not invalidated.
-
const_iterator iterator_to(const_reference value) const;
Requires: value must be a const reference to a value inserted in a list.
Effects: This function returns an iterator pointing to the element.
Throws: Nothing.
Complexity: Constant time.
Note: Iterators and references are not invalidated.
-
iterator previous(iterator i) ;
Returns: The iterator to the element before i in the list. Returns the end-iterator, if either i is the begin-iterator or the list is empty.
Throws: Nothing.
Complexity: Linear to the number of elements before i. Constant if cache_last<> is true and i == end().
-
const_iterator previous(const_iterator i) const;
Returns: The const_iterator to the element before i in the list. Returns the end-const_iterator, if either i is the begin-const_iterator or the list is empty.
Throws: Nothing.
Complexity: Linear to the number of elements before i. Constant if cache_last<> is true and i == end().