diff options
Diffstat (limited to 'boost/container/flat_set.hpp')
| -rw-r--r-- | boost/container/flat_set.hpp | 1450 |
1 files changed, 678 insertions, 772 deletions
diff --git a/boost/container/flat_set.hpp b/boost/container/flat_set.hpp index 09c95eb2f5..1307f3492f 100644 --- a/boost/container/flat_set.hpp +++ b/boost/container/flat_set.hpp @@ -1,6 +1,6 @@ ////////////////////////////////////////////////////////////////////////////// // -// (C) Copyright Ion Gaztanaga 2005-2012. Distributed under the Boost +// (C) Copyright Ion Gaztanaga 2005-2013. Distributed under the Boost // Software License, Version 1.0. (See accompanying file // LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // @@ -11,7 +11,7 @@ #ifndef BOOST_CONTAINER_FLAT_SET_HPP #define BOOST_CONTAINER_FLAT_SET_HPP -#if (defined _MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -24,39 +24,19 @@ #include <memory> #include <boost/container/detail/flat_tree.hpp> #include <boost/container/detail/mpl.hpp> -#include <boost/move/move.hpp> +#include <boost/container/allocator_traits.hpp> +#include <boost/move/utility_core.hpp> +#include <boost/move/detail/move_helpers.hpp> +#include <boost/move/traits.hpp> -#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -namespace boost { -namespace container { -#else +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) +#include <initializer_list> +#endif namespace boost { namespace container { -#endif - -/// @cond -// Forward declarations of operators < and ==, needed for friend declaration. - -#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -template <class T, class Pred = std::less<T>, class A = std::allocator<T> > -#else -template <class T, class Pred, class A> -#endif -class flat_set; - -template <class T, class Pred, class A> -inline bool operator==(const flat_set<T,Pred,A>& x, - const flat_set<T,Pred,A>& y); - -template <class T, class Pred, class A> -inline bool operator<(const flat_set<T,Pred,A>& x, - const flat_set<T,Pred,A>& y); -/// @endcond //! flat_set is a Sorted Associative Container that stores objects of type Key. -//! flat_set is a Simple Associative Container, meaning that its value type, -//! as well as its key type, is Key. It is also a Unique Associative Container, -//! meaning that no two elements are the same. +//! It is also a Unique Associative Container, meaning that no two elements are the same. //! //! flat_set is similar to std::set but it's implemented like an ordered vector. //! This means that inserting a new element into a flat_set invalidates @@ -64,71 +44,95 @@ inline bool operator<(const flat_set<T,Pred,A>& x, //! //! Erasing an element of a flat_set invalidates iterators and references //! pointing to elements that come after (their keys are bigger) the erased element. +//! +//! This container provides random-access iterators. +//! +//! \tparam Key is the type to be inserted in the set, which is also the key_type +//! \tparam Compare is the comparison functor used to order keys +//! \tparam Allocator is the allocator to be used to allocate memory for this container #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -template <class T, class Pred = std::less<T>, class A = std::allocator<T> > +template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> > #else -template <class T, class Pred, class A> +template <class Key, class Compare, class Allocator> #endif class flat_set + ///@cond + : public container_detail::flat_tree<Key, Key, container_detail::identity<Key>, Compare, Allocator> + ///@endcond { - /// @cond + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: BOOST_COPYABLE_AND_MOVABLE(flat_set) - typedef container_detail::flat_tree<T, T, container_detail::identity<T>, Pred, A> tree_t; - tree_t m_flat_tree; // flat tree representing flat_set - typedef typename container_detail:: - move_const_ref_type<T>::type insert_const_ref_type; - /// @endcond + typedef container_detail::flat_tree<Key, Key, container_detail::identity<Key>, Compare, Allocator> base_t; + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + + public: + ////////////////////////////////////////////// + // + // types + // + ////////////////////////////////////////////// + typedef Key key_type; + typedef Key value_type; + typedef Compare key_compare; + typedef Compare value_compare; + typedef ::boost::container::allocator_traits<Allocator> allocator_traits_type; + typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer; + typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer; + typedef typename ::boost::container::allocator_traits<Allocator>::reference reference; + typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference; + typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type; + typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type; + typedef Allocator allocator_type; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::stored_allocator_type) stored_allocator_type; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::iterator) iterator; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_iterator) const_iterator; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::reverse_iterator) reverse_iterator; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_reverse_iterator) const_reverse_iterator; public: + ////////////////////////////////////////////// + // + // construct/copy/destroy + // + ////////////////////////////////////////////// - // typedefs: - typedef typename tree_t::key_type key_type; - typedef typename tree_t::value_type value_type; - typedef typename tree_t::pointer pointer; - typedef typename tree_t::const_pointer const_pointer; - typedef typename tree_t::reference reference; - typedef typename tree_t::const_reference const_reference; - typedef typename tree_t::key_compare key_compare; - typedef typename tree_t::value_compare value_compare; - typedef typename tree_t::iterator iterator; - typedef typename tree_t::const_iterator const_iterator; - typedef typename tree_t::reverse_iterator reverse_iterator; - typedef typename tree_t::const_reverse_iterator const_reverse_iterator; - typedef typename tree_t::size_type size_type; - typedef typename tree_t::difference_type difference_type; - typedef typename tree_t::allocator_type allocator_type; - typedef typename tree_t::stored_allocator_type stored_allocator_type; - - //! <b>Effects</b>: Default constructs an empty flat_set. + //! <b>Effects</b>: Default constructs an empty container. //! //! <b>Complexity</b>: Constant. explicit flat_set() - : m_flat_tree() + : base_t() {} - //! <b>Effects</b>: Constructs an empty flat_set using the specified + //! <b>Effects</b>: Constructs an empty container using the specified //! comparison object and allocator. //! //! <b>Complexity</b>: Constant. - explicit flat_set(const Pred& comp, + explicit flat_set(const Compare& comp, const allocator_type& a = allocator_type()) - : m_flat_tree(comp, a) + : base_t(comp, a) {} - //! <b>Effects</b>: Constructs an empty set using the specified comparison object and + //! <b>Effects</b>: Constructs an empty container using the specified allocator. + //! + //! <b>Complexity</b>: Constant. + explicit flat_set(const allocator_type& a) + : base_t(a) + {} + + //! <b>Effects</b>: Constructs an empty container using the specified comparison object and //! allocator, and inserts elements from the range [first ,last ). //! //! <b>Complexity</b>: Linear in N if the range [first ,last ) is already sorted using //! comp and otherwise N logN, where N is last - first. template <class InputIterator> flat_set(InputIterator first, InputIterator last, - const Pred& comp = Pred(), + const Compare& comp = Compare(), const allocator_type& a = allocator_type()) - : m_flat_tree(comp, a) - { m_flat_tree.insert_unique(first, last); } + : base_t(true, first, last, comp, a) + {} - //! <b>Effects</b>: Constructs an empty flat_set using the specified comparison object and + //! <b>Effects</b>: Constructs an empty container using the specified comparison object and //! allocator, and inserts elements from the ordered unique range [first ,last). This function //! is more efficient than the normal range creation for ordered ranges. //! @@ -140,173 +144,207 @@ class flat_set //! <b>Note</b>: Non-standard extension. template <class InputIterator> flat_set(ordered_unique_range_t, InputIterator first, InputIterator last, - const Pred& comp = Pred(), + const Compare& comp = Compare(), const allocator_type& a = allocator_type()) - : m_flat_tree(ordered_range, first, last, comp, a) + : base_t(ordered_range, first, last, comp, a) {} - //! <b>Effects</b>: Copy constructs a set. +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: Constructs an empty container using the specified comparison object and + //! allocator, and inserts elements from the range [il.begin(), il.end()). + //! + //! <b>Complexity</b>: Linear in N if the range [il.begin(), il.end()) is already sorted using + //! comp and otherwise N logN, where N is il.begin() - il.end(). + flat_set(std::initializer_list<value_type> il, const Compare& comp = Compare(), + const allocator_type& a = allocator_type()) + : base_t(true, il.begin(), il.end(), comp, a) + { + + } + + //! <b>Effects</b>: Constructs an empty container using the specified comparison object and + //! allocator, and inserts elements from the ordered unique range [il.begin(), il.end()). This function + //! is more efficient than the normal range creation for ordered ranges. + //! + //! <b>Requires</b>: [il.begin(), il.end()) must be ordered according to the predicate and must be + //! unique values. + //! + //! <b>Complexity</b>: Linear in N. + //! + //! <b>Note</b>: Non-standard extension. + flat_set(ordered_unique_range_t, std::initializer_list<value_type> il, + const Compare& comp = Compare(), const allocator_type& a = allocator_type()) + : base_t(ordered_range, il.begin(), il.end(), comp, a) + { + + } +#endif + + //! <b>Effects</b>: Copy constructs the container. //! //! <b>Complexity</b>: Linear in x.size(). flat_set(const flat_set& x) - : m_flat_tree(x.m_flat_tree) + : base_t(static_cast<const base_t&>(x)) {} - //! <b>Effects</b>: Move constructs a set. Constructs *this using x's resources. + //! <b>Effects</b>: Move constructs thecontainer. Constructs *this using mx's resources. //! //! <b>Complexity</b>: Constant. //! - //! <b>Postcondition</b>: x is emptied. + //! <b>Postcondition</b>: mx is emptied. flat_set(BOOST_RV_REF(flat_set) mx) - : m_flat_tree(boost::move(mx.m_flat_tree)) + : base_t(boost::move(static_cast<base_t&>(mx))) {} - //! <b>Effects</b>: Copy constructs a set using the specified allocator. + //! <b>Effects</b>: Copy constructs a container using the specified allocator. //! //! <b>Complexity</b>: Linear in x.size(). flat_set(const flat_set& x, const allocator_type &a) - : m_flat_tree(x.m_flat_tree, a) + : base_t(static_cast<const base_t&>(x), a) {} - //! <b>Effects</b>: Move constructs a set using the specified allocator. - //! Constructs *this using x's resources. + //! <b>Effects</b>: Move constructs a container using the specified allocator. + //! Constructs *this using mx's resources. //! //! <b>Complexity</b>: Constant if a == mx.get_allocator(), linear otherwise flat_set(BOOST_RV_REF(flat_set) mx, const allocator_type &a) - : m_flat_tree(boost::move(mx.m_flat_tree), a) + : base_t(boost::move(static_cast<base_t&>(mx)), a) {} //! <b>Effects</b>: Makes *this a copy of x. //! //! <b>Complexity</b>: Linear in x.size(). flat_set& operator=(BOOST_COPY_ASSIGN_REF(flat_set) x) - { m_flat_tree = x.m_flat_tree; return *this; } - - //! <b>Effects</b>: Makes *this a copy of the previous value of xx. - //! - //! <b>Complexity</b>: Linear in x.size(). - flat_set& operator=(BOOST_RV_REF(flat_set) mx) - { m_flat_tree = boost::move(mx.m_flat_tree); return *this; } + { return static_cast<flat_set&>(this->base_t::operator=(static_cast<const base_t&>(x))); } + + //! <b>Throws</b>: If allocator_traits_type::propagate_on_container_move_assignment + //! is false and (allocation throws or value_type's move constructor throws) + //! + //! <b>Complexity</b>: Constant if allocator_traits_type:: + //! propagate_on_container_move_assignment is true or + //! this->get>allocator() == x.get_allocator(). Linear otherwise. + flat_set& operator=(BOOST_RV_REF(flat_set) x) + BOOST_CONTAINER_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value) + { return static_cast<flat_set&>(this->base_t::operator=(boost::move(static_cast<base_t&>(x)))); } + +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: Copy all elements from il to *this. + //! + //! <b>Complexity</b>: Linear in il.size(). + flat_set& operator=(std::initializer_list<value_type> il) + { + this->clear(); + this->insert(il.begin(), il.end()); + return *this; + } +#endif - //! <b>Effects</b>: Returns the comparison object out - //! of which a was constructed. + #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED + //! <b>Effects</b>: Returns a copy of the Allocator that + //! was passed to the object's constructor. //! //! <b>Complexity</b>: Constant. - key_compare key_comp() const - { return m_flat_tree.key_comp(); } + allocator_type get_allocator() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns an object of value_compare constructed out - //! of the comparison object. + //! <b>Effects</b>: Returns a reference to the internal allocator. + //! + //! <b>Throws</b>: Nothing //! //! <b>Complexity</b>: Constant. - value_compare value_comp() const - { return m_flat_tree.key_comp(); } + //! + //! <b>Note</b>: Non-standard extension. + stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a copy of the Allocator that - //! was passed to the object's constructor. + //! <b>Effects</b>: Returns a reference to the internal allocator. + //! + //! <b>Throws</b>: Nothing //! //! <b>Complexity</b>: Constant. - allocator_type get_allocator() const - { return m_flat_tree.get_allocator(); } - - const stored_allocator_type &get_stored_allocator() const - { return m_flat_tree.get_stored_allocator(); } - - stored_allocator_type &get_stored_allocator() - { return m_flat_tree.get_stored_allocator(); } + //! + //! <b>Note</b>: Non-standard extension. + const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns an iterator to the first element contained in the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - iterator begin() - { return m_flat_tree.begin(); } + iterator begin() BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_iterator begin() const - { return m_flat_tree.begin(); } + const_iterator begin() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container. + //! <b>Effects</b>: Returns an iterator to the end of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_iterator cbegin() const - { return m_flat_tree.cbegin(); } + iterator end() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns an iterator to the end of the container. + //! <b>Effects</b>: Returns a const_iterator to the end of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - iterator end() - { return m_flat_tree.end(); } + const_iterator end() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_iterator to the end of the container. + //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning + //! of the reversed container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_iterator end() const - { return m_flat_tree.end(); } + reverse_iterator rbegin() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_iterator to the end of the container. + //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning + //! of the reversed container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_iterator cend() const - { return m_flat_tree.cend(); } + const_reverse_iterator rbegin() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning + //! <b>Effects</b>: Returns a reverse_iterator pointing to the end //! of the reversed container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - reverse_iterator rbegin() - { return m_flat_tree.rbegin(); } + reverse_iterator rend() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning + //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end //! of the reversed container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator rbegin() const - { return m_flat_tree.rbegin(); } + const_reverse_iterator rend() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed container. + //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator crbegin() const - { return m_flat_tree.crbegin(); } + const_iterator cbegin() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed container. + //! <b>Effects</b>: Returns a const_iterator to the end of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - reverse_iterator rend() - { return m_flat_tree.rend(); } + const_iterator cend() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end + //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning //! of the reversed container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator rend() const - { return m_flat_tree.rend(); } + const_reverse_iterator crbegin() const BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end //! of the reversed container. @@ -314,42 +352,68 @@ class flat_set //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator crend() const - { return m_flat_tree.crend(); } + const_reverse_iterator crend() const BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns true if the container contains no elements. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - bool empty() const - { return m_flat_tree.empty(); } + bool empty() const BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns the number of the elements contained in the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - size_type size() const - { return m_flat_tree.size(); } + size_type size() const BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns the largest possible size of the container. //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - size_type max_size() const - { return m_flat_tree.max_size(); } + size_type max_size() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Swaps the contents of *this and x. + //! <b>Effects</b>: Number of elements for which memory has been allocated. + //! capacity() is always greater than or equal to size(). //! //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - void swap(flat_set& x) - { m_flat_tree.swap(x.m_flat_tree); } + size_type capacity() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Inserts x if and only if there is no element in the container + //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no + //! effect. Otherwise, it is a request for allocation of additional memory. + //! If the request is successful, then capacity() is greater than or equal to + //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged. + //! + //! <b>Throws</b>: If memory allocation allocation throws or Key's copy constructor throws. + //! + //! <b>Note</b>: If capacity() is less than "cnt", iterators and references to + //! to values might be invalidated. + void reserve(size_type cnt); + + //! <b>Effects</b>: Tries to deallocate the excess of memory created + // with previous allocations. The size of the vector is unchanged + //! + //! <b>Throws</b>: If memory allocation throws, or Key's copy constructor throws. + //! + //! <b>Complexity</b>: Linear to size(). + void shrink_to_fit(); + + #endif // #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + ////////////////////////////////////////////// + // + // modifiers + // + ////////////////////////////////////////////// + + #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + //! <b>Effects</b>: Inserts an object x of type Key constructed with + //! std::forward<Args>(args)... if and only if there is no element in the container //! with key equivalent to the key of x. //! //! <b>Returns</b>: The bool component of the returned pair is true if and only @@ -360,17 +424,57 @@ class flat_set //! to the elements with bigger keys than x. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - std::pair<iterator, bool> insert(insert_const_ref_type x) - { return priv_insert(x); } + template <class... Args> + std::pair<iterator,bool> emplace(Args&&... args) + { return this->base_t::emplace_unique(boost::forward<Args>(args)...); } - #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - std::pair<iterator, bool> insert(T &x) - { return this->insert(const_cast<const T &>(x)); } + //! <b>Effects</b>: Inserts an object of type Key constructed with + //! std::forward<Args>(args)... in the container if and only if there is + //! no element in the container with key equivalent to the key of x. + //! p is a hint pointing to where the insert should start to search. + //! + //! <b>Returns</b>: An iterator pointing to the element with key equivalent + //! to the key of x. + //! + //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted + //! right before p) plus insertion linear to the elements with bigger keys than x. + //! + //! <b>Note</b>: If an element is inserted it might invalidate elements. + template <class... Args> + iterator emplace_hint(const_iterator p, Args&&... args) + { return this->base_t::emplace_hint_unique(p, boost::forward<Args>(args)...); } - template<class U> - std::pair<iterator, bool> insert(const U &u, typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0) - { return priv_insert(u); } - #endif + #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + + #define BOOST_PP_LOCAL_MACRO(n) \ + BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ + std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ + { return this->base_t::emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); }\ + \ + BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ + iterator emplace_hint(const_iterator p \ + BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ + { return this->base_t::emplace_hint_unique \ + (p BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \ + //! + #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS) + #include BOOST_PP_LOCAL_ITERATE() + + #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + //! <b>Effects</b>: Inserts x if and only if there is no element in the container + //! with key equivalent to the key of x. + //! + //! <b>Returns</b>: The bool component of the returned pair is true if and only + //! if the insertion takes place, and the iterator component of the pair + //! points to the element with key equivalent to the key of x. + //! + //! <b>Complexity</b>: Logarithmic search time plus linear insertion + //! to the elements with bigger keys than x. + //! + //! <b>Note</b>: If an element is inserted it might invalidate elements. + std::pair<iterator, bool> insert(const value_type &x); //! <b>Effects</b>: Inserts a new value_type move constructed from the pair if and //! only if there is no element in the container with key equivalent to the key of x. @@ -383,9 +487,15 @@ class flat_set //! to the elements with bigger keys than x. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x) - { return m_flat_tree.insert_unique(boost::move(x)); } + std::pair<iterator, bool> insert(value_type &&x); + #else + private: + typedef std::pair<iterator, bool> insert_return_pair; + public: + BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, insert_return_pair, this->priv_insert) + #endif + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Effects</b>: Inserts a copy of x in the container if and only if there is //! no element in the container with key equivalent to the key of x. //! p is a hint pointing to where the insert should start to search. @@ -397,17 +507,7 @@ class flat_set //! right before p) plus insertion linear to the elements with bigger keys than x. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - iterator insert(const_iterator p, insert_const_ref_type x) - { return priv_insert(p, x); } - - #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - iterator insert(const_iterator position, T &x) - { return this->insert(position, const_cast<const T &>(x)); } - - template<class U> - iterator insert(const_iterator position, const U &u, typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0) - { return priv_insert(position, u); } - #endif + iterator insert(const_iterator p, const value_type &x); //! <b>Effects</b>: Inserts an element move constructed from x in the container. //! p is a hint pointing to where the insert should start to search. @@ -418,8 +518,10 @@ class flat_set //! right before p) plus insertion linear to the elements with bigger keys than x. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - iterator insert(const_iterator position, BOOST_RV_REF(value_type) x) - { return m_flat_tree.insert_unique(position, boost::move(x)); } + iterator insert(const_iterator p, value_type &&x); + #else + BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, value_type, iterator, this->priv_insert, const_iterator, const_iterator) + #endif //! <b>Requires</b>: first, last are not iterators into *this. //! @@ -432,7 +534,7 @@ class flat_set //! <b>Note</b>: If an element is inserted it might invalidate elements. template <class InputIterator> void insert(InputIterator first, InputIterator last) - { m_flat_tree.insert_unique(first, last); } + { this->base_t::insert_unique(first, last); } //! <b>Requires</b>: first, last are not iterators into *this and //! must be ordered according to the predicate and must be @@ -447,72 +549,46 @@ class flat_set //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements. template <class InputIterator> void insert(ordered_unique_range_t, InputIterator first, InputIterator last) - { m_flat_tree.insert_unique(ordered_unique_range, first, last); } + { this->base_t::insert_unique(ordered_unique_range, first, last); } - #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - - //! <b>Effects</b>: Inserts an object x of type T constructed with - //! std::forward<Args>(args)... if and only if there is no element in the container - //! with key equivalent to the key of x. - //! - //! <b>Returns</b>: The bool component of the returned pair is true if and only - //! if the insertion takes place, and the iterator component of the pair - //! points to the element with key equivalent to the key of x. +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()) if and only + //! if there is no element with key equivalent to the key of that element. //! - //! <b>Complexity</b>: Logarithmic search time plus linear insertion - //! to the elements with bigger keys than x. + //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from il.begin() to il.end()) + //! search time plus N*size() insertion time. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - template <class... Args> - std::pair<iterator,bool> emplace(Args&&... args) - { return m_flat_tree.emplace_unique(boost::forward<Args>(args)...); } + void insert(std::initializer_list<value_type> il) + { this->base_t::insert_unique(il.begin(), il.end()); } - //! <b>Effects</b>: Inserts an object of type T constructed with - //! std::forward<Args>(args)... in the container if and only if there is - //! no element in the container with key equivalent to the key of x. - //! p is a hint pointing to where the insert should start to search. + //! <b>Requires</b>: Range [il.begin(), il.end()) must be ordered according to the predicate + //! and must be unique values. //! - //! <b>Returns</b>: An iterator pointing to the element with key equivalent - //! to the key of x. - //! - //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted - //! right before p) plus insertion linear to the elements with bigger keys than x. + //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()) .This function + //! is more efficient than the normal range creation for ordered ranges. //! - //! <b>Note</b>: If an element is inserted it might invalidate elements. - template <class... Args> - iterator emplace_hint(const_iterator hint, Args&&... args) - { return m_flat_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); } - - #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING - - #define BOOST_PP_LOCAL_MACRO(n) \ - BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ - std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ - { return m_flat_tree.emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \ - \ - BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ - iterator emplace_hint(const_iterator hint \ - BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ - { return m_flat_tree.emplace_hint_unique \ - (hint BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \ + //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from il.begin() to il.end()) + //! search time plus N*size() insertion time. //! - #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS) - #include BOOST_PP_LOCAL_ITERATE() + //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements. + void insert(ordered_unique_range_t, std::initializer_list<value_type> il) + { this->base_t::insert_unique(ordered_unique_range, il.begin(), il.end()); } +#endif - #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - //! <b>Effects</b>: Erases the element pointed to by position. + //! <b>Effects</b>: Erases the element pointed to by p. //! //! <b>Returns</b>: Returns an iterator pointing to the element immediately //! following q prior to the element being erased. If no such element exists, //! returns end(). //! - //! <b>Complexity</b>: Linear to the elements with keys bigger than position + //! <b>Complexity</b>: Linear to the elements with keys bigger than p //! //! <b>Note</b>: Invalidates elements with keys //! not less than the erased element. - iterator erase(const_iterator position) - { return m_flat_tree.erase(position); } + iterator erase(const_iterator p); //! <b>Effects</b>: Erases all elements in the container with key equivalent to x. //! @@ -520,8 +596,7 @@ class flat_set //! //! <b>Complexity</b>: Logarithmic search time plus erasure time //! linear to the elements with bigger keys. - size_type erase(const key_type& x) - { return m_flat_tree.erase(x); } + size_type erase(const key_type& x); //! <b>Effects</b>: Erases all the elements in the range [first, last). //! @@ -531,254 +606,239 @@ class flat_set //! //! <b>Complexity</b>: Logarithmic search time plus erasure time //! linear to the elements with bigger keys. - iterator erase(const_iterator first, const_iterator last) - { return m_flat_tree.erase(first, last); } + iterator erase(const_iterator first, const_iterator last); + + //! <b>Effects</b>: Swaps the contents of *this and x. + //! + //! <b>Throws</b>: Nothing. + //! + //! <b>Complexity</b>: Constant. + void swap(flat_set& x); //! <b>Effects</b>: erase(a.begin(),a.end()). //! //! <b>Postcondition</b>: size() == 0. //! //! <b>Complexity</b>: linear in size(). - void clear() - { m_flat_tree.clear(); } + void clear() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Tries to deallocate the excess of memory created - // with previous allocations. The size of the vector is unchanged + //! <b>Effects</b>: Returns the comparison object out + //! of which a was constructed. //! - //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws. + //! <b>Complexity</b>: Constant. + key_compare key_comp() const; + + //! <b>Effects</b>: Returns an object of value_compare constructed out + //! of the comparison object. //! - //! <b>Complexity</b>: Linear to size(). - void shrink_to_fit() - { m_flat_tree.shrink_to_fit(); } + //! <b>Complexity</b>: Constant. + value_compare value_comp() const; //! <b>Returns</b>: An iterator pointing to an element with the key //! equivalent to x, or end() if such an element is not found. //! //! <b>Complexity</b>: Logarithmic. - iterator find(const key_type& x) - { return m_flat_tree.find(x); } + iterator find(const key_type& x); - //! <b>Returns</b>: A const_iterator pointing to an element with the key + //! <b>Returns</b>: Allocator const_iterator pointing to an element with the key //! equivalent to x, or end() if such an element is not found. //! - //! <b>Complexity</b>: Logarithmic.s - const_iterator find(const key_type& x) const - { return m_flat_tree.find(x); } + //! <b>Complexity</b>: Logarithmic. + const_iterator find(const key_type& x) const; + + #endif // #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Returns</b>: The number of elements with key equivalent to x. //! //! <b>Complexity</b>: log(size())+count(k) size_type count(const key_type& x) const - { return m_flat_tree.find(x) == m_flat_tree.end() ? 0 : 1; } + { return static_cast<size_type>(this->base_t::find(x) != this->base_t::cend()); } + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Returns</b>: An iterator pointing to the first element with key not less //! than k, or a.end() if such an element is not found. //! //! <b>Complexity</b>: Logarithmic - iterator lower_bound(const key_type& x) - { return m_flat_tree.lower_bound(x); } + iterator lower_bound(const key_type& x); - //! <b>Returns</b>: A const iterator pointing to the first element with key not + //! <b>Returns</b>: Allocator const iterator pointing to the first element with key not //! less than k, or a.end() if such an element is not found. //! //! <b>Complexity</b>: Logarithmic - const_iterator lower_bound(const key_type& x) const - { return m_flat_tree.lower_bound(x); } + const_iterator lower_bound(const key_type& x) const; //! <b>Returns</b>: An iterator pointing to the first element with key not less //! than x, or end() if such an element is not found. //! //! <b>Complexity</b>: Logarithmic - iterator upper_bound(const key_type& x) - { return m_flat_tree.upper_bound(x); } + iterator upper_bound(const key_type& x); - //! <b>Returns</b>: A const iterator pointing to the first element with key not + //! <b>Returns</b>: Allocator const iterator pointing to the first element with key not //! less than x, or end() if such an element is not found. //! //! <b>Complexity</b>: Logarithmic - const_iterator upper_bound(const key_type& x) const - { return m_flat_tree.upper_bound(x); } + const_iterator upper_bound(const key_type& x) const; + + #endif // #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)). //! //! <b>Complexity</b>: Logarithmic - std::pair<const_iterator, const_iterator> - equal_range(const key_type& x) const - { return m_flat_tree.equal_range(x); } + std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const + { return this->base_t::lower_bound_range(x); } //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)). //! //! <b>Complexity</b>: Logarithmic - std::pair<iterator,iterator> - equal_range(const key_type& x) - { return m_flat_tree.equal_range(x); } + std::pair<iterator,iterator> equal_range(const key_type& x) + { return this->base_t::lower_bound_range(x); } - //! <b>Effects</b>: Number of elements for which memory has been allocated. - //! capacity() is always greater than or equal to size(). - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - size_type capacity() const - { return m_flat_tree.capacity(); } + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no - //! effect. Otherwise, it is a request for allocation of additional memory. - //! If the request is successful, then capacity() is greater than or equal to - //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged. + //! <b>Effects</b>: Returns true if x and y are equal //! - //! <b>Throws</b>: If memory allocation allocation throws or T's copy constructor throws. - //! - //! <b>Note</b>: If capacity() is less than "count", iterators and references to - //! to values might be invalidated. - void reserve(size_type count) - { m_flat_tree.reserve(count); } - - /// @cond - template <class K1, class C1, class A1> - friend bool operator== (const flat_set<K1,C1,A1>&, const flat_set<K1,C1,A1>&); - - template <class K1, class C1, class A1> - friend bool operator< (const flat_set<K1,C1,A1>&, const flat_set<K1,C1,A1>&); - - private: - std::pair<iterator, bool> priv_insert(const T &x) - { return m_flat_tree.insert_unique(x); } + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator==(const flat_set& x, const flat_set& y); - iterator priv_insert(const_iterator p, const T &x) - { return m_flat_tree.insert_unique(p, x); } - /// @endcond -}; + //! <b>Effects</b>: Returns true if x and y are unequal + //! + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator!=(const flat_set& x, const flat_set& y); -template <class T, class Pred, class A> -inline bool operator==(const flat_set<T,Pred,A>& x, - const flat_set<T,Pred,A>& y) - { return x.m_flat_tree == y.m_flat_tree; } + //! <b>Effects</b>: Returns true if x is less than y + //! + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator<(const flat_set& x, const flat_set& y); -template <class T, class Pred, class A> -inline bool operator<(const flat_set<T,Pred,A>& x, - const flat_set<T,Pred,A>& y) - { return x.m_flat_tree < y.m_flat_tree; } + //! <b>Effects</b>: Returns true if x is greater than y + //! + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator>(const flat_set& x, const flat_set& y); -template <class T, class Pred, class A> -inline bool operator!=(const flat_set<T,Pred,A>& x, - const flat_set<T,Pred,A>& y) - { return !(x == y); } + //! <b>Effects</b>: Returns true if x is equal or less than y + //! + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator<=(const flat_set& x, const flat_set& y); -template <class T, class Pred, class A> -inline bool operator>(const flat_set<T,Pred,A>& x, - const flat_set<T,Pred,A>& y) - { return y < x; } + //! <b>Effects</b>: Returns true if x is equal or greater than y + //! + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator>=(const flat_set& x, const flat_set& y); -template <class T, class Pred, class A> -inline bool operator<=(const flat_set<T,Pred,A>& x, - const flat_set<T,Pred,A>& y) - { return !(y < x); } + //! <b>Effects</b>: x.swap(y) + //! + //! <b>Complexity</b>: Constant. + friend void swap(flat_set& x, flat_set& y); -template <class T, class Pred, class A> -inline bool operator>=(const flat_set<T,Pred,A>& x, - const flat_set<T,Pred,A>& y) - { return !(x < y); } + #endif //#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -template <class T, class Pred, class A> -inline void swap(flat_set<T,Pred,A>& x, flat_set<T,Pred,A>& y) - { x.swap(y); } + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + private: + template<class KeyType> + std::pair<iterator, bool> priv_insert(BOOST_FWD_REF(KeyType) x) + { return this->base_t::insert_unique(::boost::forward<KeyType>(x)); } + + template<class KeyType> + iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x) + { return this->base_t::insert_unique(p, ::boost::forward<KeyType>(x)); } + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED +}; -/// @cond +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED } //namespace container { -/* + //!has_trivial_destructor_after_move<> == true_type //!specialization for optimizations -template <class T, class C, class A> -struct has_trivial_destructor_after_move<boost::container::flat_set<T, C, A> > +template <class Key, class C, class Allocator> +struct has_trivial_destructor_after_move<boost::container::flat_set<Key, C, Allocator> > { - static const bool value = has_trivial_destructor<A>::value &&has_trivial_destructor<C>::value; + static const bool value = has_trivial_destructor_after_move<Allocator>::value &&has_trivial_destructor_after_move<C>::value; }; -*/ -namespace container { - -// Forward declaration of operators < and ==, needed for friend declaration. - -#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -template <class T, class Pred = std::less<T>, class A = std::allocator<T> > -#else -template <class T, class Pred, class A> -#endif -class flat_multiset; -template <class T, class Pred, class A> -inline bool operator==(const flat_multiset<T,Pred,A>& x, - const flat_multiset<T,Pred,A>& y); +namespace container { -template <class T, class Pred, class A> -inline bool operator<(const flat_multiset<T,Pred,A>& x, - const flat_multiset<T,Pred,A>& y); -/// @endcond +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED //! flat_multiset is a Sorted Associative Container that stores objects of type Key. -//! flat_multiset is a Simple Associative Container, meaning that its value type, -//! as well as its key type, is Key. -//! flat_Multiset can store multiple copies of the same key value. +//! +//! flat_multiset can store multiple copies of the same key value. //! //! flat_multiset is similar to std::multiset but it's implemented like an ordered vector. //! This means that inserting a new element into a flat_multiset invalidates //! previous iterators and references //! -//! Erasing an element of a flat_multiset invalidates iterators and references -//! pointing to elements that come after (their keys are equal or bigger) the erased element. +//! Erasing an element invalidates iterators and references +//! pointing to elements that come after (their keys are bigger) the erased element. +//! +//! This container provides random-access iterators. +//! +//! \tparam Key is the type to be inserted in the multiset, which is also the key_type +//! \tparam Compare is the comparison functor used to order keys +//! \tparam Allocator is the allocator to be used to allocate memory for this container #ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -template <class T, class Pred = std::less<T>, class A = std::allocator<T> > +template <class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> > #else -template <class T, class Pred, class A> +template <class Key, class Compare, class Allocator> #endif class flat_multiset + ///@cond + : public container_detail::flat_tree<Key, Key, container_detail::identity<Key>, Compare, Allocator> + ///@endcond { - /// @cond + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: BOOST_COPYABLE_AND_MOVABLE(flat_multiset) - typedef container_detail::flat_tree<T, T, container_detail::identity<T>, Pred, A> tree_t; - tree_t m_flat_tree; // flat tree representing flat_multiset - typedef typename container_detail:: - move_const_ref_type<T>::type insert_const_ref_type; - /// @endcond + typedef container_detail::flat_tree<Key, Key, container_detail::identity<Key>, Compare, Allocator> base_t; + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED public: - // typedefs: - typedef typename tree_t::key_type key_type; - typedef typename tree_t::value_type value_type; - typedef typename tree_t::pointer pointer; - typedef typename tree_t::const_pointer const_pointer; - typedef typename tree_t::reference reference; - typedef typename tree_t::const_reference const_reference; - typedef typename tree_t::key_compare key_compare; - typedef typename tree_t::value_compare value_compare; - typedef typename tree_t::iterator iterator; - typedef typename tree_t::const_iterator const_iterator; - typedef typename tree_t::reverse_iterator reverse_iterator; - typedef typename tree_t::const_reverse_iterator const_reverse_iterator; - typedef typename tree_t::size_type size_type; - typedef typename tree_t::difference_type difference_type; - typedef typename tree_t::allocator_type allocator_type; - typedef typename tree_t::stored_allocator_type stored_allocator_type; - - //! <b>Effects</b>: Default constructs an empty flat_multiset. - //! - //! <b>Complexity</b>: Constant. + ////////////////////////////////////////////// + // + // types + // + ////////////////////////////////////////////// + typedef Key key_type; + typedef Key value_type; + typedef Compare key_compare; + typedef Compare value_compare; + typedef ::boost::container::allocator_traits<Allocator> allocator_traits_type; + typedef typename ::boost::container::allocator_traits<Allocator>::pointer pointer; + typedef typename ::boost::container::allocator_traits<Allocator>::const_pointer const_pointer; + typedef typename ::boost::container::allocator_traits<Allocator>::reference reference; + typedef typename ::boost::container::allocator_traits<Allocator>::const_reference const_reference; + typedef typename ::boost::container::allocator_traits<Allocator>::size_type size_type; + typedef typename ::boost::container::allocator_traits<Allocator>::difference_type difference_type; + typedef Allocator allocator_type; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::stored_allocator_type) stored_allocator_type; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::iterator) iterator; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_iterator) const_iterator; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::reverse_iterator) reverse_iterator; + typedef typename BOOST_CONTAINER_IMPDEF(base_t::const_reverse_iterator) const_reverse_iterator; + + //! @copydoc ::boost::container::flat_set::flat_set() explicit flat_multiset() - : m_flat_tree() + : base_t() {} - explicit flat_multiset(const Pred& comp, + //! @copydoc ::boost::container::flat_set::flat_set(const Compare&, const allocator_type&) + explicit flat_multiset(const Compare& comp, const allocator_type& a = allocator_type()) - : m_flat_tree(comp, a) {} + : base_t(comp, a) + {} + //! @copydoc ::boost::container::flat_set::flat_set(const allocator_type&) + explicit flat_multiset(const allocator_type& a) + : base_t(a) + {} + + //! @copydoc ::boost::container::flat_set::flat_set(InputIterator, InputIterator, const Compare& comp, const allocator_type&) template <class InputIterator> flat_multiset(InputIterator first, InputIterator last, - const Pred& comp = Pred(), + const Compare& comp = Compare(), const allocator_type& a = allocator_type()) - : m_flat_tree(comp, a) - { m_flat_tree.insert_equal(first, last); } + : base_t(false, first, last, comp, a) + {} //! <b>Effects</b>: Constructs an empty flat_multiset using the specified comparison object and //! allocator, and inserts elements from the ordered range [first ,last ). This function @@ -791,215 +851,185 @@ class flat_multiset //! <b>Note</b>: Non-standard extension. template <class InputIterator> flat_multiset(ordered_range_t, InputIterator first, InputIterator last, - const Pred& comp = Pred(), + const Compare& comp = Compare(), const allocator_type& a = allocator_type()) - : m_flat_tree(ordered_range, first, last, comp, a) + : base_t(ordered_range, first, last, comp, a) {} - //! <b>Effects</b>: Copy constructs a flat_multiset. - //! - //! <b>Complexity</b>: Linear in x.size(). +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! @copydoc ::boost::container::flat_set::flat_set(std::initializer_list<value_type>, const Compare& comp, const allocator_type&) + flat_multiset(std::initializer_list<value_type> il, const Compare& comp = Compare(), + const allocator_type& a = allocator_type()) + : base_t(false, il.begin(), il.end(), comp, a) + {} + + //! @copydoc ::boost::container::flat_set::flat_set(ordered_unique_range_t, std::initializer_list<value_type>, const Compare& comp, const allocator_type&) + flat_multiset(ordered_unique_range_t, std::initializer_list<value_type> il, + const Compare& comp = Compare(), const allocator_type& a = allocator_type()) + : base_t(ordered_range, il.begin(), il.end(), comp, a) + {} +#endif + + //! @copydoc ::boost::container::flat_set::flat_set(const flat_set &) flat_multiset(const flat_multiset& x) - : m_flat_tree(x.m_flat_tree) + : base_t(static_cast<const base_t&>(x)) {} - //! <b>Effects</b>: Move constructs a flat_multiset. Constructs *this using x's resources. - //! - //! <b>Complexity</b>: Constant. - //! - //! <b>Postcondition</b>: x is emptied. + //! @copydoc ::boost::container::flat_set(flat_set &&) flat_multiset(BOOST_RV_REF(flat_multiset) mx) - : m_flat_tree(boost::move(mx.m_flat_tree)) + : base_t(boost::move(static_cast<base_t&>(mx))) {} - //! <b>Effects</b>: Copy constructs a flat_multiset using the specified allocator. - //! - //! <b>Complexity</b>: Linear in x.size(). + //! @copydoc ::boost::container::flat_set(const flat_set &, const allocator_type &) flat_multiset(const flat_multiset& x, const allocator_type &a) - : m_flat_tree(x.m_flat_tree, a) + : base_t(static_cast<const base_t&>(x), a) {} - //! <b>Effects</b>: Move constructs a flat_multiset using the specified allocator. - //! Constructs *this using x's resources. - //! - //! <b>Complexity</b>: Constant if a == mx.get_allocator(), linear otherwise + //! @copydoc ::boost::container::flat_set(flat_set &&, const allocator_type &) flat_multiset(BOOST_RV_REF(flat_multiset) mx, const allocator_type &a) - : m_flat_tree(boost::move(mx.m_flat_tree), a) + : base_t(boost::move(static_cast<base_t&>(mx)), a) {} - //! <b>Effects</b>: Makes *this a copy of x. - //! - //! <b>Complexity</b>: Linear in x.size(). + //! @copydoc ::boost::container::flat_set::operator=(const flat_set &) flat_multiset& operator=(BOOST_COPY_ASSIGN_REF(flat_multiset) x) - { m_flat_tree = x.m_flat_tree; return *this; } + { return static_cast<flat_multiset&>(this->base_t::operator=(static_cast<const base_t&>(x))); } - //! <b>Effects</b>: Makes *this a copy of x. - //! - //! <b>Complexity</b>: Linear in x.size(). + //! @copydoc ::boost::container::flat_set::operator=(flat_set &&) flat_multiset& operator=(BOOST_RV_REF(flat_multiset) mx) - { m_flat_tree = boost::move(mx.m_flat_tree); return *this; } + BOOST_CONTAINER_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value) + { return static_cast<flat_multiset&>(this->base_t::operator=(boost::move(static_cast<base_t&>(mx)))); } + +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! @copydoc ::boost::container::flat_set::operator=(std::initializer_list<value_type>) + flat_multiset& operator=(std::initializer_list<value_type> il) + { + this->clear(); + this->insert(il.begin(), il.end()); + return *this; + } +#endif - //! <b>Effects</b>: Returns the comparison object out - //! of which a was constructed. - //! - //! <b>Complexity</b>: Constant. - key_compare key_comp() const - { return m_flat_tree.key_comp(); } + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - //! <b>Effects</b>: Returns an object of value_compare constructed out - //! of the comparison object. - //! - //! <b>Complexity</b>: Constant. - value_compare value_comp() const - { return m_flat_tree.key_comp(); } + //! @copydoc ::boost::container::flat_set::get_allocator() + allocator_type get_allocator() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a copy of the Allocator that - //! was passed to the object's constructor. - //! - //! <b>Complexity</b>: Constant. - allocator_type get_allocator() const - { return m_flat_tree.get_allocator(); } + //! @copydoc ::boost::container::flat_set::get_stored_allocator() + stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT; - const stored_allocator_type &get_stored_allocator() const - { return m_flat_tree.get_stored_allocator(); } + //! @copydoc ::boost::container::flat_set::get_stored_allocator() const + const stored_allocator_type &get_stored_allocator() const BOOST_CONTAINER_NOEXCEPT; - stored_allocator_type &get_stored_allocator() - { return m_flat_tree.get_stored_allocator(); } + //! @copydoc ::boost::container::flat_set::begin() + iterator begin() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns an iterator to the first element contained in the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - iterator begin() - { return m_flat_tree.begin(); } + //! @copydoc ::boost::container::flat_set::begin() const + const_iterator begin() const; - //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator begin() const - { return m_flat_tree.begin(); } + //! @copydoc ::boost::container::flat_set::cbegin() const + const_iterator cbegin() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_iterator to the first element contained in the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator cbegin() const - { return m_flat_tree.cbegin(); } + //! @copydoc ::boost::container::flat_set::end() + iterator end() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns an iterator to the end of the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - iterator end() - { return m_flat_tree.end(); } + //! @copydoc ::boost::container::flat_set::end() const + const_iterator end() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_iterator to the end of the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator end() const - { return m_flat_tree.end(); } + //! @copydoc ::boost::container::flat_set::cend() const + const_iterator cend() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_iterator to the end of the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_iterator cend() const - { return m_flat_tree.cend(); } + //! @copydoc ::boost::container::flat_set::rbegin() + reverse_iterator rbegin() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning - //! of the reversed container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - reverse_iterator rbegin() - { return m_flat_tree.rbegin(); } + //! @copydoc ::boost::container::flat_set::rbegin() const + const_reverse_iterator rbegin() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reverse_iterator rbegin() const - { return m_flat_tree.rbegin(); } + //! @copydoc ::boost::container::flat_set::crbegin() const + const_reverse_iterator crbegin() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning - //! of the reversed container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reverse_iterator crbegin() const - { return m_flat_tree.crbegin(); } + //! @copydoc ::boost::container::flat_set::rend() + reverse_iterator rend() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a reverse_iterator pointing to the end - //! of the reversed container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - reverse_iterator rend() - { return m_flat_tree.rend(); } + //! @copydoc ::boost::container::flat_set::rend() const + const_reverse_iterator rend() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reverse_iterator rend() const - { return m_flat_tree.rend(); } + //! @copydoc ::boost::container::flat_set::crend() const + const_reverse_iterator crend() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end - //! of the reversed container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - const_reverse_iterator crend() const - { return m_flat_tree.crend(); } + //! @copydoc ::boost::container::flat_set::empty() const + bool empty() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns true if the container contains no elements. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - bool empty() const - { return m_flat_tree.empty(); } + //! @copydoc ::boost::container::flat_set::size() const + size_type size() const BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Returns the number of the elements contained in the container. + //! @copydoc ::boost::container::flat_set::max_size() const + size_type max_size() const BOOST_CONTAINER_NOEXCEPT; + + //! @copydoc ::boost::container::flat_set::capacity() const + size_type capacity() const BOOST_CONTAINER_NOEXCEPT; + + //! @copydoc ::boost::container::flat_set::reserve(size_type) + void reserve(size_type cnt); + + //! @copydoc ::boost::container::flat_set::shrink_to_fit() + void shrink_to_fit(); + + #endif // #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + ////////////////////////////////////////////// + // + // modifiers + // + ////////////////////////////////////////////// + + #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + //! <b>Effects</b>: Inserts an object of type Key constructed with + //! std::forward<Args>(args)... and returns the iterator pointing to the + //! newly inserted element. //! - //! <b>Throws</b>: Nothing. + //! <b>Complexity</b>: Logarithmic search time plus linear insertion + //! to the elements with bigger keys than x. //! - //! <b>Complexity</b>: Constant. - size_type size() const - { return m_flat_tree.size(); } + //! <b>Note</b>: If an element is inserted it might invalidate elements. + template <class... Args> + iterator emplace(Args&&... args) + { return this->base_t::emplace_equal(boost::forward<Args>(args)...); } - //! <b>Effects</b>: Returns the largest possible size of the container. + //! <b>Effects</b>: Inserts an object of type Key constructed with + //! std::forward<Args>(args)... in the container. + //! p is a hint pointing to where the insert should start to search. //! - //! <b>Throws</b>: Nothing. + //! <b>Returns</b>: An iterator pointing to the element with key equivalent + //! to the key of x. //! - //! <b>Complexity</b>: Constant. - size_type max_size() const - { return m_flat_tree.max_size(); } - - //! <b>Effects</b>: Swaps the contents of *this and x. + //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted + //! right before p) plus insertion linear to the elements with bigger keys than x. //! - //! <b>Throws</b>: Nothing. + //! <b>Note</b>: If an element is inserted it might invalidate elements. + template <class... Args> + iterator emplace_hint(const_iterator p, Args&&... args) + { return this->base_t::emplace_hint_equal(p, boost::forward<Args>(args)...); } + + #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + + #define BOOST_PP_LOCAL_MACRO(n) \ + BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ + iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ + { return this->base_t::emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \ + \ + BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ + iterator emplace_hint(const_iterator p \ + BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ + { return this->base_t::emplace_hint_equal \ + (p BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \ //! - //! <b>Complexity</b>: Constant. - void swap(flat_multiset& x) - { m_flat_tree.swap(x.m_flat_tree); } + #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS) + #include BOOST_PP_LOCAL_ITERATE() + #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Effects</b>: Inserts x and returns the iterator pointing to the //! newly inserted element. //! @@ -1007,17 +1037,7 @@ class flat_multiset //! to the elements with bigger keys than x. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - iterator insert(insert_const_ref_type x) - { return priv_insert(x); } - - #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - iterator insert(T &x) - { return this->insert(const_cast<const T &>(x)); } - - template<class U> - iterator insert(const U &u, typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0) - { return priv_insert(u); } - #endif + iterator insert(const value_type &x); //! <b>Effects</b>: Inserts a new value_type move constructed from x //! and returns the iterator pointing to the newly inserted element. @@ -1026,9 +1046,12 @@ class flat_multiset //! to the elements with bigger keys than x. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - iterator insert(BOOST_RV_REF(value_type) x) - { return m_flat_tree.insert_equal(boost::move(x)); } + iterator insert(value_type &&x); + #else + BOOST_MOVE_CONVERSION_AWARE_CATCH(insert, value_type, iterator, this->priv_insert) + #endif + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! <b>Effects</b>: Inserts a copy of x in the container. //! p is a hint pointing to where the insert should start to search. //! @@ -1039,18 +1062,7 @@ class flat_multiset //! right before p) plus insertion linear to the elements with bigger keys than x. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - iterator insert(const_iterator p, insert_const_ref_type x) - { return priv_insert(p, x); } - - #if defined(BOOST_NO_RVALUE_REFERENCES) && !defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - iterator insert(const_iterator position, T &x) - { return this->insert(position, const_cast<const T &>(x)); } - - template<class U> - iterator insert( const_iterator position, const U &u - , typename container_detail::enable_if_c<container_detail::is_same<T, U>::value && !::boost::has_move_emulation_enabled<U>::value >::type* =0) - { return priv_insert(position, u); } - #endif + iterator insert(const_iterator p, const value_type &x); //! <b>Effects</b>: Inserts a new value move constructed from x in the container. //! p is a hint pointing to where the insert should start to search. @@ -1062,8 +1074,10 @@ class flat_multiset //! right before p) plus insertion linear to the elements with bigger keys than x. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - iterator insert(const_iterator position, BOOST_RV_REF(value_type) x) - { return m_flat_tree.insert_equal(position, boost::move(x)); } + iterator insert(const_iterator p, value_type &&x); + #else + BOOST_MOVE_CONVERSION_AWARE_CATCH_1ARG(insert, value_type, iterator, this->priv_insert, const_iterator, const_iterator) + #endif //! <b>Requires</b>: first, last are not iterators into *this. //! @@ -1075,7 +1089,7 @@ class flat_multiset //! <b>Note</b>: If an element is inserted it might invalidate elements. template <class InputIterator> void insert(InputIterator first, InputIterator last) - { m_flat_tree.insert_equal(first, last); } + { this->base_t::insert_equal(first, last); } //! <b>Requires</b>: first, last are not iterators into *this and //! must be ordered according to the predicate. @@ -1089,253 +1103,145 @@ class flat_multiset //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements. template <class InputIterator> void insert(ordered_range_t, InputIterator first, InputIterator last) - { m_flat_tree.insert_equal(ordered_range, first, last); } - - #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + { this->base_t::insert_equal(ordered_range, first, last); } - //! <b>Effects</b>: Inserts an object of type T constructed with - //! std::forward<Args>(args)... and returns the iterator pointing to the - //! newly inserted element. +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()). //! - //! <b>Complexity</b>: Logarithmic search time plus linear insertion - //! to the elements with bigger keys than x. + //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last) + //! search time plus N*size() insertion time. //! //! <b>Note</b>: If an element is inserted it might invalidate elements. - template <class... Args> - iterator emplace(Args&&... args) - { return m_flat_tree.emplace_equal(boost::forward<Args>(args)...); } + void insert(std::initializer_list<value_type> il) + { this->base_t::insert_equal(il.begin(), il.end()); } - //! <b>Effects</b>: Inserts an object of type T constructed with - //! std::forward<Args>(args)... in the container. - //! p is a hint pointing to where the insert should start to search. + //! <b>Requires</b>: Range [il.begin(), il.end()) must be ordered according to the predicate. //! - //! <b>Returns</b>: An iterator pointing to the element with key equivalent - //! to the key of x. + //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end()). This function + //! is more efficient than the normal range creation for ordered ranges. //! - //! <b>Complexity</b>: Logarithmic search time (constant if x is inserted - //! right before p) plus insertion linear to the elements with bigger keys than x. + //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from il.begin() to il.end()) + //! search time plus N*size() insertion time. //! - //! <b>Note</b>: If an element is inserted it might invalidate elements. - template <class... Args> - iterator emplace_hint(const_iterator hint, Args&&... args) - { return m_flat_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); } + //! <b>Note</b>: Non-standard extension. If an element is inserted it might invalidate elements. + void insert(ordered_range_t, std::initializer_list<value_type> il) + { this->base_t::insert_equal(ordered_range, il.begin(), il.end()); } +#endif - #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - #define BOOST_PP_LOCAL_MACRO(n) \ - BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ - iterator emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ - { return m_flat_tree.emplace_equal(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \ - \ - BOOST_PP_EXPR_IF(n, template<) BOOST_PP_ENUM_PARAMS(n, class P) BOOST_PP_EXPR_IF(n, >) \ - iterator emplace_hint(const_iterator hint \ - BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ - { return m_flat_tree.emplace_hint_equal \ - (hint BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \ - //! - #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS) - #include BOOST_PP_LOCAL_ITERATE() + //! @copydoc ::boost::container::flat_set::erase(const_iterator) + iterator erase(const_iterator p); - #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + //! @copydoc ::boost::container::flat_set::erase(const key_type&) + size_type erase(const key_type& x); - //! <b>Effects</b>: Erases the element pointed to by position. - //! - //! <b>Returns</b>: Returns an iterator pointing to the element immediately - //! following q prior to the element being erased. If no such element exists, - //! returns end(). - //! - //! <b>Complexity</b>: Linear to the elements with keys bigger than position - //! - //! <b>Note</b>: Invalidates elements with keys - //! not less than the erased element. - iterator erase(const_iterator position) - { return m_flat_tree.erase(position); } + //! @copydoc ::boost::container::flat_set::erase(const_iterator,const_iterator) + iterator erase(const_iterator first, const_iterator last); - //! <b>Effects</b>: Erases all elements in the container with key equivalent to x. - //! - //! <b>Returns</b>: Returns the number of erased elements. - //! - //! <b>Complexity</b>: Logarithmic search time plus erasure time - //! linear to the elements with bigger keys. - size_type erase(const key_type& x) - { return m_flat_tree.erase(x); } + //! @copydoc ::boost::container::flat_set::swap + void swap(flat_multiset& x); - //! <b>Effects</b>: Erases all the elements in the range [first, last). - //! - //! <b>Returns</b>: Returns last. - //! - //! <b>Complexity</b>: size()*N where N is the distance from first to last. - //! - //! <b>Complexity</b>: Logarithmic search time plus erasure time - //! linear to the elements with bigger keys. - iterator erase(const_iterator first, const_iterator last) - { return m_flat_tree.erase(first, last); } + //! @copydoc ::boost::container::flat_set::clear + void clear() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: erase(a.begin(),a.end()). - //! - //! <b>Postcondition</b>: size() == 0. - //! - //! <b>Complexity</b>: linear in size(). - void clear() - { m_flat_tree.clear(); } + //! @copydoc ::boost::container::flat_set::key_comp + key_compare key_comp() const; - //! <b>Effects</b>: Tries to deallocate the excess of memory created - // with previous allocations. The size of the vector is unchanged - //! - //! <b>Throws</b>: If memory allocation throws, or T's copy constructor throws. - //! - //! <b>Complexity</b>: Linear to size(). - void shrink_to_fit() - { m_flat_tree.shrink_to_fit(); } + //! @copydoc ::boost::container::flat_set::value_comp + value_compare value_comp() const; - //! <b>Returns</b>: An iterator pointing to an element with the key - //! equivalent to x, or end() if such an element is not found. - //! - //! <b>Complexity</b>: Logarithmic. - iterator find(const key_type& x) - { return m_flat_tree.find(x); } + //! @copydoc ::boost::container::flat_set::find(const key_type& ) + iterator find(const key_type& x); - //! <b>Returns</b>: A const_iterator pointing to an element with the key - //! equivalent to x, or end() if such an element is not found. - //! - //! <b>Complexity</b>: Logarithmic.s - const_iterator find(const key_type& x) const - { return m_flat_tree.find(x); } + //! @copydoc ::boost::container::flat_set::find(const key_type& ) const + const_iterator find(const key_type& x) const; - //! <b>Returns</b>: The number of elements with key equivalent to x. - //! - //! <b>Complexity</b>: log(size())+count(k) - size_type count(const key_type& x) const - { return m_flat_tree.count(x); } + //! @copydoc ::boost::container::flat_set::count(const key_type& ) const + size_type count(const key_type& x) const; - //! <b>Returns</b>: An iterator pointing to the first element with key not less - //! than k, or a.end() if such an element is not found. - //! - //! <b>Complexity</b>: Logarithmic - iterator lower_bound(const key_type& x) - { return m_flat_tree.lower_bound(x); } + //! @copydoc ::boost::container::flat_set::lower_bound(const key_type& ) + iterator lower_bound(const key_type& x); - //! <b>Returns</b>: A const iterator pointing to the first element with key not - //! less than k, or a.end() if such an element is not found. + //! @copydoc ::boost::container::flat_set::lower_bound(const key_type& ) const + const_iterator lower_bound(const key_type& x) const; + + //! @copydoc ::boost::container::flat_set::upper_bound(const key_type& ) + iterator upper_bound(const key_type& x); + + //! @copydoc ::boost::container::flat_set::upper_bound(const key_type& ) const + const_iterator upper_bound(const key_type& x) const; + + //! @copydoc ::boost::container::flat_set::equal_range(const key_type& ) const + std::pair<const_iterator, const_iterator> equal_range(const key_type& x) const; + + //! @copydoc ::boost::container::flat_set::equal_range(const key_type& ) + std::pair<iterator,iterator> equal_range(const key_type& x); + + //! <b>Effects</b>: Returns true if x and y are equal //! - //! <b>Complexity</b>: Logarithmic - const_iterator lower_bound(const key_type& x) const - { return m_flat_tree.lower_bound(x); } + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator==(const flat_multiset& x, const flat_multiset& y); - //! <b>Returns</b>: An iterator pointing to the first element with key not less - //! than x, or end() if such an element is not found. + //! <b>Effects</b>: Returns true if x and y are unequal //! - //! <b>Complexity</b>: Logarithmic - iterator upper_bound(const key_type& x) - { return m_flat_tree.upper_bound(x); } + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator!=(const flat_multiset& x, const flat_multiset& y); - //! <b>Returns</b>: A const iterator pointing to the first element with key not - //! less than x, or end() if such an element is not found. + //! <b>Effects</b>: Returns true if x is less than y //! - //! <b>Complexity</b>: Logarithmic - const_iterator upper_bound(const key_type& x) const - { return m_flat_tree.upper_bound(x); } + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator<(const flat_multiset& x, const flat_multiset& y); - //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)). + //! <b>Effects</b>: Returns true if x is greater than y //! - //! <b>Complexity</b>: Logarithmic - std::pair<const_iterator, const_iterator> - equal_range(const key_type& x) const - { return m_flat_tree.equal_range(x); } + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator>(const flat_multiset& x, const flat_multiset& y); - //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)). + //! <b>Effects</b>: Returns true if x is equal or less than y //! - //! <b>Complexity</b>: Logarithmic - std::pair<iterator,iterator> - equal_range(const key_type& x) - { return m_flat_tree.equal_range(x); } + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator<=(const flat_multiset& x, const flat_multiset& y); - //! <b>Effects</b>: Number of elements for which memory has been allocated. - //! capacity() is always greater than or equal to size(). + //! <b>Effects</b>: Returns true if x is equal or greater than y //! - //! <b>Throws</b>: Nothing. + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator>=(const flat_multiset& x, const flat_multiset& y); + + //! <b>Effects</b>: x.swap(y) //! //! <b>Complexity</b>: Constant. - size_type capacity() const - { return m_flat_tree.capacity(); } + friend void swap(flat_multiset& x, flat_multiset& y); - //! <b>Effects</b>: If n is less than or equal to capacity(), this call has no - //! effect. Otherwise, it is a request for allocation of additional memory. - //! If the request is successful, then capacity() is greater than or equal to - //! n; otherwise, capacity() is unchanged. In either case, size() is unchanged. - //! - //! <b>Throws</b>: If memory allocation allocation throws or T's copy constructor throws. - //! - //! <b>Note</b>: If capacity() is less than "count", iterators and references to - //! to values might be invalidated. - void reserve(size_type count) - { m_flat_tree.reserve(count); } - - /// @cond - template <class K1, class C1, class A1> - friend bool operator== (const flat_multiset<K1,C1,A1>&, - const flat_multiset<K1,C1,A1>&); - template <class K1, class C1, class A1> - friend bool operator< (const flat_multiset<K1,C1,A1>&, - const flat_multiset<K1,C1,A1>&); - private: - iterator priv_insert(const T &x) - { return m_flat_tree.insert_equal(x); } + #endif //#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED - iterator priv_insert(const_iterator p, const T &x) - { return m_flat_tree.insert_equal(p, x); } - /// @endcond + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED + private: + template <class KeyType> + iterator priv_insert(BOOST_FWD_REF(KeyType) x) + { return this->base_t::insert_equal(::boost::forward<KeyType>(x)); } + + template <class KeyType> + iterator priv_insert(const_iterator p, BOOST_FWD_REF(KeyType) x) + { return this->base_t::insert_equal(p, ::boost::forward<KeyType>(x)); } + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED }; -template <class T, class Pred, class A> -inline bool operator==(const flat_multiset<T,Pred,A>& x, - const flat_multiset<T,Pred,A>& y) - { return x.m_flat_tree == y.m_flat_tree; } - -template <class T, class Pred, class A> -inline bool operator<(const flat_multiset<T,Pred,A>& x, - const flat_multiset<T,Pred,A>& y) - { return x.m_flat_tree < y.m_flat_tree; } - -template <class T, class Pred, class A> -inline bool operator!=(const flat_multiset<T,Pred,A>& x, - const flat_multiset<T,Pred,A>& y) - { return !(x == y); } - -template <class T, class Pred, class A> -inline bool operator>(const flat_multiset<T,Pred,A>& x, - const flat_multiset<T,Pred,A>& y) - { return y < x; } - -template <class T, class Pred, class A> -inline bool operator<=(const flat_multiset<T,Pred,A>& x, - const flat_multiset<T,Pred,A>& y) - { return !(y < x); } - -template <class T, class Pred, class A> -inline bool operator>=(const flat_multiset<T,Pred,A>& x, - const flat_multiset<T,Pred,A>& y) -{ return !(x < y); } - -template <class T, class Pred, class A> -inline void swap(flat_multiset<T,Pred,A>& x, flat_multiset<T,Pred,A>& y) - { x.swap(y); } - -/// @cond +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED } //namespace container { -/* + //!has_trivial_destructor_after_move<> == true_type //!specialization for optimizations -template <class T, class C, class A> -struct has_trivial_destructor_after_move<boost::container::flat_multiset<T, C, A> > +template <class Key, class C, class Allocator> +struct has_trivial_destructor_after_move<boost::container::flat_multiset<Key, C, Allocator> > { - static const bool value = has_trivial_destructor<A>::value && has_trivial_destructor<C>::value; + static const bool value = has_trivial_destructor_after_move<Allocator>::value && has_trivial_destructor_after_move<C>::value; }; -*/ + namespace container { -/// @endcond +#endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED }} |