diff options
Diffstat (limited to 'boost/container/map.hpp')
-rw-r--r-- | boost/container/map.hpp | 1251 |
1 files changed, 614 insertions, 637 deletions
diff --git a/boost/container/map.hpp b/boost/container/map.hpp index 91cbd35429..6abfa1a346 100644 --- a/boost/container/map.hpp +++ b/boost/container/map.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_MAP_HPP #define BOOST_CONTAINER_MAP_HPP -#if (defined _MSC_VER) && (_MSC_VER >= 1200) +#if defined(_MSC_VER) # pragma once #endif @@ -22,7 +22,6 @@ #include <utility> #include <functional> #include <memory> -#include <stdexcept> #include <boost/container/detail/tree.hpp> #include <boost/container/detail/value_init.hpp> #include <boost/type_traits/has_trivial_destructor.hpp> @@ -30,121 +29,127 @@ #include <boost/container/detail/utilities.hpp> #include <boost/container/detail/pair.hpp> #include <boost/container/detail/type_traits.hpp> -#include <boost/move/move.hpp> -#include <boost/move/move_helpers.hpp> +#include <boost/container/throw_exception.hpp> +#include <boost/move/utility_core.hpp> +#include <boost/move/detail/move_helpers.hpp> +#include <boost/move/traits.hpp> #include <boost/static_assert.hpp> #include <boost/container/detail/value_init.hpp> +#include <boost/core/no_exceptions_support.hpp> +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) +#include <initializer_list> +#endif -#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -namespace boost { -namespace container { -#else namespace boost { namespace container { -#endif -/// @cond -// Forward declarations of operators == and <, needed for friend declarations. -template <class Key, class T, class Pred, class A> -inline bool operator==(const map<Key,T,Pred,A>& x, - const map<Key,T,Pred,A>& y); - -template <class Key, class T, class Pred, class A> -inline bool operator<(const map<Key,T,Pred,A>& x, - const map<Key,T,Pred,A>& y); -/// @endcond +#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED //! A map is a kind of associative container that supports unique keys (contains at //! most one of each key value) and provides for fast retrieval of values of another //! type T based on the keys. The map class supports bidirectional iterators. //! //! A map satisfies all of the requirements of a container and of a reversible -//! container and of an associative container. For a -//! map<Key,T> the key_type is Key and the value_type is std::pair<const Key,T>. -//! -//! Pred is the ordering function for Keys (e.g. <i>std::less<Key></i>). +//! container and of an associative container. The <code>value_type</code> stored +//! by this container is the value_type is std::pair<const Key, T>. //! -//! A is the allocator to allocate the value_types -//! (e.g. <i>allocator< std::pair<const Key, T> > </i>). -#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -template <class Key, class T, class Pred = std::less< std::pair< const Key, T> >, class A = std::allocator<T> > +//! \tparam Key is the key_type of the map +//! \tparam Value is the <code>mapped_type</code> +//! \tparam Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>). +//! \tparam Allocator is the allocator to allocate the <code>value_type</code>s +//! (e.g. <i>allocator< std::pair<const Key, T> > </i>). +//! \tparam MapOptions is an packed option type generated using using boost::container::tree_assoc_options. +template < class Key, class T, class Compare = std::less<Key> + , class Allocator = std::allocator< std::pair< const Key, T> >, class MapOptions = tree_assoc_defaults > #else -template <class Key, class T, class Pred, class A> +template <class Key, class T, class Compare, class Allocator, class MapOptions> #endif class map + ///@cond + : public container_detail::tree + < Key, std::pair<const Key, T> + , container_detail::select1st< std::pair<const Key, T> > + , Compare, Allocator, MapOptions> + ///@endcond { - /// @cond + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: BOOST_COPYABLE_AND_MOVABLE(map) - typedef container_detail::rbtree<Key, - std::pair<const Key, T>, - container_detail::select1st< std::pair<const Key, T> >, - Pred, - A> tree_t; - tree_t m_tree; // red-black tree representing map - /// @endcond + typedef std::pair<const Key, T> value_type_impl; + typedef container_detail::tree + <Key, value_type_impl, container_detail::select1st<value_type_impl>, Compare, Allocator, MapOptions> base_t; + typedef container_detail::pair <Key, T> movable_value_type_impl; + typedef container_detail::tree_value_compare + < Key, value_type_impl, Compare, container_detail::select1st<value_type_impl> + > value_compare_impl; + #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 T mapped_type; - typedef Pred key_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; - typedef std::pair<key_type, mapped_type> nonconst_value_type; - typedef container_detail::pair - <key_type, mapped_type> nonconst_impl_value_type; - - /// @cond - class value_compare_impl - : public Pred, - public std::binary_function<value_type, value_type, bool> - { - friend class map<Key,T,Pred,A>; - protected : - value_compare_impl(const Pred &c) : Pred(c) {} - public: - bool operator()(const value_type& x, const value_type& y) const { - return Pred::operator()(x.first, y.first); - } - }; - /// @endcond - typedef value_compare_impl value_compare; + ////////////////////////////////////////////// + // + // types + // + ////////////////////////////////////////////// + + typedef Key key_type; + typedef ::boost::container::allocator_traits<Allocator> allocator_traits_type; + typedef T mapped_type; + typedef std::pair<const Key, T> value_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 BOOST_CONTAINER_IMPDEF(value_compare_impl) value_compare; + typedef Compare key_compare; + 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; + typedef std::pair<key_type, mapped_type> nonconst_value_type; + typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl) movable_value_type; + + ////////////////////////////////////////////// + // + // construct/copy/destroy + // + ////////////////////////////////////////////// //! <b>Effects</b>: Default constructs an empty map. //! //! <b>Complexity</b>: Constant. map() - : m_tree() + : base_t() { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Constructs an empty map using the specified comparison object //! and allocator. //! //! <b>Complexity</b>: Constant. - explicit map(const Pred& comp, + explicit map(const Compare& comp, const allocator_type& a = allocator_type()) - : m_tree(comp, a) + : base_t(comp, a) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); + } + + //! <b>Effects</b>: Constructs an empty map using the specified allocator. + //! + //! <b>Complexity</b>: Constant. + explicit map(const allocator_type& a) + : base_t(a) + { + //Allocator type must be std::pair<CONST Key, T> + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Constructs an empty map using the specified comparison object and @@ -153,12 +158,12 @@ class map //! <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> - map(InputIterator first, InputIterator last, const Pred& comp = Pred(), + map(InputIterator first, InputIterator last, const Compare& comp = Compare(), const allocator_type& a = allocator_type()) - : m_tree(first, last, comp, a, true) + : base_t(true, first, last, comp, a) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Constructs an empty map using the specified comparison object and @@ -169,23 +174,47 @@ class map //! unique values. //! //! <b>Complexity</b>: Linear in N. + //! + //! <b>Note</b>: Non-standard extension. template <class InputIterator> map( ordered_unique_range_t, InputIterator first, InputIterator last - , const Pred& comp = Pred(), const allocator_type& a = allocator_type()) - : m_tree(ordered_range, first, last, comp, a) + , const Compare& comp = Compare(), const allocator_type& a = allocator_type()) + : base_t(ordered_range, first, last, comp, a) + { + //Allocator type must be std::pair<CONST Key, T> + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); + } + +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: Constructs an empty map 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 [first ,last ) is already sorted using + //! comp and otherwise N logN, where N is il.first() - il.end(). + map(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) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } + map(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) + { + //Allocator type must be std::pair<CONST Key, T> + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); + } +#endif + //! <b>Effects</b>: Copy constructs a map. //! //! <b>Complexity</b>: Linear in x.size(). map(const map& x) - : m_tree(x.m_tree) + : base_t(static_cast<const base_t&>(x)) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Move constructs a map. Constructs *this using x's resources. @@ -194,20 +223,20 @@ class map //! //! <b>Postcondition</b>: x is emptied. map(BOOST_RV_REF(map) x) - : m_tree(boost::move(x.m_tree)) + : base_t(boost::move(static_cast<base_t&>(x))) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Copy constructs a map using the specified allocator. //! //! <b>Complexity</b>: Linear in x.size(). map(const map& x, const allocator_type &a) - : m_tree(x.m_tree, a) + : base_t(static_cast<const base_t&>(x), a) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Move constructs a map using the specified allocator. @@ -217,98 +246,108 @@ class map //! //! <b>Postcondition</b>: x is emptied. map(BOOST_RV_REF(map) x, const allocator_type &a) - : m_tree(boost::move(x.m_tree), a) + : base_t(boost::move(static_cast<base_t&>(x)), a) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Makes *this a copy of x. //! //! <b>Complexity</b>: Linear in x.size(). map& operator=(BOOST_COPY_ASSIGN_REF(map) x) - { m_tree = x.m_tree; return *this; } + { return static_cast<map&>(this->base_t::operator=(static_cast<const base_t&>(x))); } //! <b>Effects</b>: this->swap(x.get()). //! - //! <b>Complexity</b>: Constant. + //! <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. map& operator=(BOOST_RV_REF(map) x) - { m_tree = boost::move(x.m_tree); return *this; } + BOOST_CONTAINER_NOEXCEPT_IF(allocator_traits_type::propagate_on_container_move_assignment::value) + { return static_cast<map&>(this->base_t::operator=(boost::move(static_cast<base_t&>(x)))); } - //! <b>Effects</b>: Returns the comparison object out - //! of which a was constructed. +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: Assign content of il to *this. //! - //! <b>Complexity</b>: Constant. - key_compare key_comp() const - { return m_tree.key_comp(); } + map& operator=(std::initializer_list<value_type> il) + { + this->clear(); + insert(il.begin(), il.end()); + return *this; + } +#endif - //! <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 value_compare(m_tree.key_comp()); } + #if defined(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. - allocator_type get_allocator() const - { return m_tree.get_allocator(); } + allocator_type get_allocator() const; - const stored_allocator_type &get_stored_allocator() const - { return m_tree.get_stored_allocator(); } + //! <b>Effects</b>: Returns a reference to the internal allocator. + //! + //! <b>Throws</b>: Nothing + //! + //! <b>Complexity</b>: Constant. + //! + //! <b>Note</b>: Non-standard extension. + stored_allocator_type &get_stored_allocator() BOOST_CONTAINER_NOEXCEPT; - stored_allocator_type &get_stored_allocator() - { return m_tree.get_stored_allocator(); } + //! <b>Effects</b>: Returns a reference to the internal allocator. + //! + //! <b>Throws</b>: Nothing + //! + //! <b>Complexity</b>: Constant. + //! + //! <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_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 this->cbegin(); } + const_iterator begin() 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_tree.begin(); } + const_iterator cbegin() const 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_tree.end(); } + iterator end() 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 this->cend(); } + 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 cend() const - { return m_tree.end(); } + const_iterator cend() const BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns a reverse_iterator pointing to the beginning //! of the reversed container. @@ -316,8 +355,7 @@ class map //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - reverse_iterator rbegin() - { return m_tree.rbegin(); } + reverse_iterator rbegin() BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning //! of the reversed container. @@ -325,8 +363,7 @@ class map //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator rbegin() const - { return this->crbegin(); } + const_reverse_iterator rbegin() const BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the beginning //! of the reversed container. @@ -334,8 +371,7 @@ class map //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator crbegin() const - { return m_tree.rbegin(); } + const_reverse_iterator crbegin() const BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns a reverse_iterator pointing to the end //! of the reversed container. @@ -343,8 +379,7 @@ class map //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - reverse_iterator rend() - { return m_tree.rend(); } + reverse_iterator rend() BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end //! of the reversed container. @@ -352,8 +387,7 @@ class map //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator rend() const - { return this->crend(); } + const_reverse_iterator rend() const BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Returns a const_reverse_iterator pointing to the end //! of the reversed container. @@ -361,38 +395,36 @@ class map //! <b>Throws</b>: Nothing. //! //! <b>Complexity</b>: Constant. - const_reverse_iterator crend() const - { return m_tree.rend(); } + 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_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_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_tree.max_size(); } + size_type max_size() const BOOST_CONTAINER_NOEXCEPT; + + #endif //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) //! Effects: If there is no key equivalent to x in the map, inserts //! value_type(x, T()) into the map. //! - //! Returns: A reference to the mapped_type corresponding to x in *this. + //! Returns: Allocator reference to the mapped_type corresponding to x in *this. //! //! Complexity: Logarithmic. mapped_type& operator[](const key_type &k); @@ -400,45 +432,43 @@ class map //! Effects: If there is no key equivalent to x in the map, inserts //! value_type(boost::move(x), T()) into the map (the key is move-constructed) //! - //! Returns: A reference to the mapped_type corresponding to x in *this. + //! Returns: Allocator reference to the mapped_type corresponding to x in *this. //! //! Complexity: Logarithmic. mapped_type& operator[](key_type &&k); #else - BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, priv_subscript) + BOOST_MOVE_CONVERSION_AWARE_CATCH( operator[] , key_type, mapped_type&, this->priv_subscript) #endif - //! Returns: A reference to the element whose key is equivalent to x. + //! Returns: Allocator reference to the element whose key is equivalent to x. //! Throws: An exception object of type out_of_range if no such element is present. //! Complexity: logarithmic. T& at(const key_type& k) { iterator i = this->find(k); if(i == this->end()){ - throw std::out_of_range("key not found"); + throw_out_of_range("map::at key not found"); } return i->second; } - //! Returns: A reference to the element whose key is equivalent to x. + //! Returns: Allocator reference to the element whose key is equivalent to x. //! Throws: An exception object of type out_of_range if no such element is present. //! Complexity: logarithmic. const T& at(const key_type& k) const { const_iterator i = this->find(k); if(i == this->end()){ - throw std::out_of_range("key not found"); + throw_out_of_range("map::at key not found"); } return i->second; } - //! <b>Effects</b>: Swaps the contents of *this and x. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - void swap(map& x) - { m_tree.swap(x.m_tree); } + ////////////////////////////////////////////// + // + // modifiers + // + ////////////////////////////////////////////// //! <b>Effects</b>: Inserts x if and only if there is no element in the container //! with key equivalent to the key of x. @@ -449,7 +479,7 @@ class map //! //! <b>Complexity</b>: Logarithmic. std::pair<iterator,bool> insert(const value_type& x) - { return m_tree.insert_unique(x); } + { return this->base_t::insert_unique(x); } //! <b>Effects</b>: Inserts a new value_type created from the pair if and only if //! there is no element in the container with key equivalent to the key of x. @@ -460,7 +490,7 @@ class map //! //! <b>Complexity</b>: Logarithmic. std::pair<iterator,bool> insert(const nonconst_value_type& x) - { return m_tree.insert_unique(x); } + { return this->base_t::insert_unique(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. @@ -471,7 +501,7 @@ class map //! //! <b>Complexity</b>: Logarithmic. std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_value_type) x) - { return m_tree.insert_unique(boost::move(x)); } + { return this->base_t::insert_unique(boost::move(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. @@ -481,8 +511,8 @@ class map //! points to the element with key equivalent to the key of x. //! //! <b>Complexity</b>: Logarithmic. - std::pair<iterator,bool> insert(BOOST_RV_REF(nonconst_impl_value_type) x) - { return m_tree.insert_unique(boost::move(x)); } + std::pair<iterator,bool> insert(BOOST_RV_REF(movable_value_type) x) + { return this->base_t::insert_unique(boost::move(x)); } //! <b>Effects</b>: Move constructs a new value from x if and only if there is //! no element in the container with key equivalent to the key of x. @@ -493,7 +523,7 @@ class map //! //! <b>Complexity</b>: Logarithmic. std::pair<iterator,bool> insert(BOOST_RV_REF(value_type) x) - { return m_tree.insert_unique(boost::move(x)); } + { return this->base_t::insert_unique(boost::move(x)); } //! <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. @@ -504,8 +534,8 @@ class map //! //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t //! is inserted right before p. - iterator insert(iterator position, const value_type& x) - { return m_tree.insert_unique(position, x); } + iterator insert(const_iterator p, const value_type& x) + { return this->base_t::insert_unique(p, x); } //! <b>Effects</b>: Move constructs a new value from x if and only if there is //! no element in the container with key equivalent to the key of x. @@ -516,8 +546,8 @@ class map //! //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t //! is inserted right before p. - iterator insert(iterator position, BOOST_RV_REF(nonconst_value_type) x) - { return m_tree.insert_unique(position, boost::move(x)); } + iterator insert(const_iterator p, BOOST_RV_REF(nonconst_value_type) x) + { return this->base_t::insert_unique(p, boost::move(x)); } //! <b>Effects</b>: Move constructs a new value from x if and only if there is //! no element in the container with key equivalent to the key of x. @@ -528,8 +558,8 @@ class map //! //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t //! is inserted right before p. - iterator insert(iterator position, BOOST_RV_REF(nonconst_impl_value_type) x) - { return m_tree.insert_unique(position, boost::move(x)); } + iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x) + { return this->base_t::insert_unique(p, boost::move(x)); } //! <b>Effects</b>: Inserts a copy of x in the container. //! p is a hint pointing to where the insert should start to search. @@ -537,8 +567,8 @@ class map //! <b>Returns</b>: An iterator pointing to the element with key equivalent to the key of x. //! //! <b>Complexity</b>: Logarithmic. - iterator insert(iterator position, const nonconst_value_type& x) - { return m_tree.insert_unique(position, x); } + iterator insert(const_iterator p, const nonconst_value_type& x) + { return this->base_t::insert_unique(p, 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. @@ -546,8 +576,8 @@ class map //! <b>Returns</b>: An iterator pointing to the element with key equivalent to the key of x. //! //! <b>Complexity</b>: Logarithmic. - iterator insert(iterator position, BOOST_RV_REF(value_type) x) - { return m_tree.insert_unique(position, boost::move(x)); } + iterator insert(const_iterator p, BOOST_RV_REF(value_type) x) + { return this->base_t::insert_unique(p, boost::move(x)); } //! <b>Requires</b>: first, last are not iterators into *this. //! @@ -557,7 +587,16 @@ class map //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last) template <class InputIterator> void insert(InputIterator first, InputIterator last) - { m_tree.insert_unique(first, last); } + { this->base_t::insert_unique(first, last); } + +#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>: At most N log(size()+N) (N is the distance from il.begin() to il.end()) + void insert(std::initializer_list<value_type> il) + { this->base_t::insert_unique(il.begin(), il.end()); } +#endif #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) @@ -574,7 +613,7 @@ class map //! is inserted right before p. template <class... Args> std::pair<iterator,bool> emplace(Args&&... args) - { return m_tree.emplace_unique(boost::forward<Args>(args)...); } + { return this->base_t::emplace_unique(boost::forward<Args>(args)...); } //! <b>Effects</b>: Inserts an object of type T constructed with //! std::forward<Args>(args)... in the container if and only if there is @@ -587,20 +626,20 @@ class map //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t //! is inserted right before p. template <class... Args> - iterator emplace_hint(const_iterator hint, Args&&... args) - { return m_tree.emplace_hint_unique(hint, boost::forward<Args>(args)...); } + iterator emplace_hint(const_iterator p, Args&&... args) + { return this->base_t::emplace_hint_unique(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, >) \ std::pair<iterator,bool> emplace(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ - { return m_tree.emplace_unique(BOOST_PP_ENUM(n, BOOST_CONTAINER_PP_PARAM_FORWARD, _)); } \ + { 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 hint \ + iterator emplace_hint(const_iterator p \ BOOST_PP_ENUM_TRAILING(n, BOOST_CONTAINER_PP_PARAM_LIST, _)) \ - { return m_tree.emplace_hint_unique(hint \ + { 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) @@ -608,116 +647,165 @@ class map #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING - //! <b>Effects</b>: Erases the element pointed to by position. + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + //! <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>: Amortized constant time - iterator erase(const_iterator position) - { return m_tree.erase(position); } + iterator erase(const_iterator p) BOOST_CONTAINER_NOEXCEPT; //! <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>: log(size()) + count(k) - size_type erase(const key_type& x) - { return m_tree.erase(x); } + size_type erase(const key_type& x) BOOST_CONTAINER_NOEXCEPT; //! <b>Effects</b>: Erases all the elements in the range [first, last). //! //! <b>Returns</b>: Returns last. //! //! <b>Complexity</b>: log(size())+N where N is the distance from first to last. - iterator erase(const_iterator first, const_iterator last) - { return m_tree.erase(first, last); } + iterator erase(const_iterator first, const_iterator last) BOOST_CONTAINER_NOEXCEPT; + + //! <b>Effects</b>: Swaps the contents of *this and x. + //! + //! <b>Throws</b>: Nothing. + //! + //! <b>Complexity</b>: Constant. + void swap(map& x); //! <b>Effects</b>: erase(a.begin(),a.end()). //! //! <b>Postcondition</b>: size() == 0. //! //! <b>Complexity</b>: linear in size(). - void clear() - { m_tree.clear(); } + void clear() BOOST_CONTAINER_NOEXCEPT; + + //! <b>Effects</b>: Returns the comparison object out + //! of which a was constructed. + //! + //! <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>: 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_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. - const_iterator find(const key_type& x) const - { return m_tree.find(x); } + 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_tree.find(x) == m_tree.end() ? 0 : 1; } + { return static_cast<size_type>(this->find(x) != this->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_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_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_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_tree.upper_bound(x); } + const_iterator upper_bound(const key_type& x) const; //! <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_tree.equal_range(x); } + std::pair<iterator,iterator> equal_range(const key_type& x); //! <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_tree.equal_range(x); } - - /// @cond - template <class K1, class T1, class C1, class A1> - friend bool operator== (const map<K1, T1, C1, A1>&, - const map<K1, T1, C1, A1>&); - template <class K1, class T1, class C1, class A1> - friend bool operator< (const map<K1, T1, C1, A1>&, - const map<K1, T1, C1, A1>&); + std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const; + + //! <b>Effects</b>: Rebalances the tree. It's a no-op for Red-Black and AVL trees. + //! + //! <b>Complexity</b>: Linear + void rebalance(); + + //! <b>Effects</b>: Returns true if x and y are equal + //! + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator==(const map& x, const map& y); + + //! <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 map& x, const map& y); + + //! <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 map& x, const map& y); + + //! <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 map& x, const map& 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 map& x, const map& y); + + //! <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 map& x, const map& y); + + //! <b>Effects</b>: x.swap(y) + //! + //! <b>Complexity</b>: Constant. + friend void swap(map& x, map& y); + + #endif //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: mapped_type& priv_subscript(const key_type &k) { //we can optimize this - iterator i = lower_bound(k); + iterator i = this->lower_bound(k); // i->first is greater than or equivalent to k. - if (i == end() || key_comp()(k, (*i).first)){ + if (i == this->end() || this->key_comp()(k, (*i).first)){ container_detail::value_init<mapped_type> m; - nonconst_impl_value_type val(k, boost::move(m.m_t)); + movable_value_type val(k, boost::move(m.m_t)); i = insert(i, boost::move(val)); } return (*i).second; @@ -727,78 +815,37 @@ class map { key_type &k = mk; //we can optimize this - iterator i = lower_bound(k); + iterator i = this->lower_bound(k); // i->first is greater than or equivalent to k. - if (i == end() || key_comp()(k, (*i).first)){ + if (i == this->end() || this->key_comp()(k, (*i).first)){ container_detail::value_init<mapped_type> m; - nonconst_impl_value_type val(boost::move(k), boost::move(m.m_t)); + movable_value_type val(boost::move(k), boost::move(m.m_t)); i = insert(i, boost::move(val)); } return (*i).second; } - /// @endcond + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED }; -template <class Key, class T, class Pred, class A> -inline bool operator==(const map<Key,T,Pred,A>& x, - const map<Key,T,Pred,A>& y) - { return x.m_tree == y.m_tree; } - -template <class Key, class T, class Pred, class A> -inline bool operator<(const map<Key,T,Pred,A>& x, - const map<Key,T,Pred,A>& y) - { return x.m_tree < y.m_tree; } - -template <class Key, class T, class Pred, class A> -inline bool operator!=(const map<Key,T,Pred,A>& x, - const map<Key,T,Pred,A>& y) - { return !(x == y); } - -template <class Key, class T, class Pred, class A> -inline bool operator>(const map<Key,T,Pred,A>& x, - const map<Key,T,Pred,A>& y) - { return y < x; } - -template <class Key, class T, class Pred, class A> -inline bool operator<=(const map<Key,T,Pred,A>& x, - const map<Key,T,Pred,A>& y) - { return !(y < x); } - -template <class Key, class T, class Pred, class A> -inline bool operator>=(const map<Key,T,Pred,A>& x, - const map<Key,T,Pred,A>& y) - { return !(x < y); } - -template <class Key, class T, class Pred, class A> -inline void swap(map<Key,T,Pred,A>& x, map<Key,T,Pred,A>& y) - { x.swap(y); } - -/// @cond -// Forward declaration of operators < and ==, needed for friend declaration. - -template <class Key, class T, class Pred, class A> -inline bool operator==(const multimap<Key,T,Pred,A>& x, - const multimap<Key,T,Pred,A>& y); - -template <class Key, class T, class Pred, class A> -inline bool operator<(const multimap<Key,T,Pred,A>& x, - const multimap<Key,T,Pred,A>& y); +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED } //namespace container { -/* + //!has_trivial_destructor_after_move<> == true_type //!specialization for optimizations -template <class K, class T, class C, class A> -struct has_trivial_destructor_after_move<boost::container::map<K, T, C, A> > +template <class K, class T, class C, class Allocator> +struct has_trivial_destructor_after_move<boost::container::map<K, T, 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 + +#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED //! A multimap is a kind of associative container that supports equivalent keys //! (possibly containing multiple copies of the same key value) and provides for @@ -806,91 +853,103 @@ namespace container { //! supports bidirectional iterators. //! //! A multimap satisfies all of the requirements of a container and of a reversible -//! container and of an associative container. For a -//! map<Key,T> the key_type is Key and the value_type is std::pair<const Key,T>. +//! container and of an associative container. The <code>value_type</code> stored +//! by this container is the value_type is std::pair<const Key, T>. //! -//! Pred is the ordering function for Keys (e.g. <i>std::less<Key></i>). -//! -//! A is the allocator to allocate the value_types -//!(e.g. <i>allocator< std::pair<<b>const</b> Key, T> ></i>). -#ifdef BOOST_CONTAINER_DOXYGEN_INVOKED -template <class Key, class T, class Pred = std::less< std::pair< const Key, T> >, class A = std::allocator<T> > +//! \tparam Key is the key_type of the map +//! \tparam Value is the <code>mapped_type</code> +//! \tparam Compare is the ordering function for Keys (e.g. <i>std::less<Key></i>). +//! \tparam Allocator is the allocator to allocate the <code>value_type</code>s +//! (e.g. <i>allocator< std::pair<const Key, T> > </i>). +//! \tparam MultiMapOptions is an packed option type generated using using boost::container::tree_assoc_options. +template < class Key, class T, class Compare = std::less<Key> + , class Allocator = std::allocator< std::pair< const Key, T> >, class MultiMapOptions = tree_assoc_defaults> #else -template <class Key, class T, class Pred, class A> +template <class Key, class T, class Compare, class Allocator, class MultiMapOptions> #endif class multimap + ///@cond + : public container_detail::tree + < Key, std::pair<const Key, T> + , container_detail::select1st< std::pair<const Key, T> > + , Compare, Allocator, MultiMapOptions> + ///@endcond { - /// @cond + #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED private: BOOST_COPYABLE_AND_MOVABLE(multimap) - typedef container_detail::rbtree<Key, - std::pair<const Key, T>, - container_detail::select1st< std::pair<const Key, T> >, - Pred, - A> tree_t; - tree_t m_tree; // red-black tree representing map - typedef typename container_detail:: - move_const_ref_type<Key>::type insert_key_const_ref_type; - /// @endcond - public: + typedef std::pair<const Key, T> value_type_impl; + typedef container_detail::tree + <Key, value_type_impl, container_detail::select1st<value_type_impl>, Compare, Allocator, MultiMapOptions> base_t; + typedef container_detail::pair <Key, T> movable_value_type_impl; + typedef container_detail::tree_value_compare + < Key, value_type_impl, Compare, container_detail::select1st<value_type_impl> + > value_compare_impl; + #endif //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED - // 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 T mapped_type; - typedef Pred key_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; - typedef std::pair<key_type, mapped_type> nonconst_value_type; - typedef container_detail::pair - <key_type, mapped_type> nonconst_impl_value_type; - - /// @cond - class value_compare_impl - : public Pred, - public std::binary_function<value_type, value_type, bool> - { - friend class multimap<Key,T,Pred,A>; - protected : - value_compare_impl(const Pred &c) : Pred(c) {} - public: - bool operator()(const value_type& x, const value_type& y) const { - return Pred::operator()(x.first, y.first); - } - }; - /// @endcond - typedef value_compare_impl value_compare; + public: + ////////////////////////////////////////////// + // + // types + // + ////////////////////////////////////////////// + + typedef Key key_type; + typedef T mapped_type; + typedef std::pair<const Key, T> value_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 BOOST_CONTAINER_IMPDEF(value_compare_impl) value_compare; + typedef Compare key_compare; + 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; + typedef std::pair<key_type, mapped_type> nonconst_value_type; + typedef BOOST_CONTAINER_IMPDEF(movable_value_type_impl) movable_value_type; + + ////////////////////////////////////////////// + // + // construct/copy/destroy + // + ////////////////////////////////////////////// //! <b>Effects</b>: Default constructs an empty multimap. //! //! <b>Complexity</b>: Constant. multimap() - : m_tree() + : base_t() { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); + } + + //! <b>Effects</b>: Constructs an empty multimap using the specified allocator. + //! + //! <b>Complexity</b>: Constant. + explicit multimap(const Compare& comp, const allocator_type& a = allocator_type()) + : base_t(comp, a) + { + //Allocator type must be std::pair<CONST Key, T> + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Constructs an empty multimap using the specified comparison //! object and allocator. //! //! <b>Complexity</b>: Constant. - explicit multimap(const Pred& comp, const allocator_type& a = allocator_type()) - : m_tree(comp, a) + explicit multimap(const allocator_type& a) + : base_t(a) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object @@ -900,12 +959,12 @@ class multimap //! comp and otherwise N logN, where N is last - first. template <class InputIterator> multimap(InputIterator first, InputIterator last, - const Pred& comp = Pred(), + const Compare& comp = Compare(), const allocator_type& a = allocator_type()) - : m_tree(first, last, comp, a, false) + : base_t(false, first, last, comp, a) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Constructs an empty multimap using the specified comparison object and @@ -915,20 +974,45 @@ class multimap //! <b>Requires</b>: [first ,last) must be ordered according to the predicate. //! //! <b>Complexity</b>: Linear in N. + //! + //! <b>Note</b>: Non-standard extension. template <class InputIterator> - multimap(ordered_range_t ordered_range, InputIterator first, InputIterator last, const Pred& comp = Pred(), + multimap(ordered_range_t, InputIterator first, InputIterator last, const Compare& comp = Compare(), const allocator_type& a = allocator_type()) - : m_tree(ordered_range, first, last, comp, a) + : base_t(ordered_range, first, last, comp, a) {} +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: Constructs an empty multimap 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 [first ,last ) is already sorted using + //! comp and otherwise N logN, where N is il.first() - il.end(). + multimap(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) + { + //Allocator type must be std::pair<CONST Key, T> + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); + } + + multimap(ordered_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) + { + //Allocator type must be std::pair<CONST Key, T> + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); + } +#endif + //! <b>Effects</b>: Copy constructs a multimap. //! //! <b>Complexity</b>: Linear in x.size(). multimap(const multimap& x) - : m_tree(x.m_tree) + : base_t(static_cast<const base_t&>(x)) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Move constructs a multimap. Constructs *this using x's resources. @@ -937,20 +1021,20 @@ class multimap //! //! <b>Postcondition</b>: x is emptied. multimap(BOOST_RV_REF(multimap) x) - : m_tree(boost::move(x.m_tree)) + : base_t(boost::move(static_cast<base_t&>(x))) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Copy constructs a multimap. //! //! <b>Complexity</b>: Linear in x.size(). multimap(const multimap& x, const allocator_type &a) - : m_tree(x.m_tree, a) + : base_t(static_cast<const base_t&>(x), a) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Move constructs a multimap using the specified allocator. @@ -959,212 +1043,166 @@ class multimap //! //! <b>Postcondition</b>: x is emptied. multimap(BOOST_RV_REF(multimap) x, const allocator_type &a) - : m_tree(boost::move(x.m_tree), a) + : base_t(boost::move(static_cast<base_t&>(x)), a) { //Allocator type must be std::pair<CONST Key, T> - BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename A::value_type>::value)); + BOOST_STATIC_ASSERT((container_detail::is_same<std::pair<const Key, T>, typename Allocator::value_type>::value)); } //! <b>Effects</b>: Makes *this a copy of x. //! //! <b>Complexity</b>: Linear in x.size(). multimap& operator=(BOOST_COPY_ASSIGN_REF(multimap) x) - { m_tree = x.m_tree; return *this; } + { return static_cast<multimap&>(this->base_t::operator=(static_cast<const base_t&>(x))); } //! <b>Effects</b>: this->swap(x.get()). //! //! <b>Complexity</b>: Constant. multimap& operator=(BOOST_RV_REF(multimap) x) - { m_tree = boost::move(x.m_tree); return *this; } + { return static_cast<multimap&>(this->base_t::operator=(boost::move(static_cast<base_t&>(x)))); } - //! <b>Effects</b>: Returns the comparison object out - //! of which a was constructed. +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: Assign content of il to *this. //! - //! <b>Complexity</b>: Constant. - key_compare key_comp() const - { return m_tree.key_comp(); } + multimap& operator=(std::initializer_list<value_type> il) + { + this->clear(); + insert(il.begin(), il.end()); + return *this; + } +#endif - //! <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 value_compare(m_tree.key_comp()); } + #if defined(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. - allocator_type get_allocator() const - { return m_tree.get_allocator(); } + //! @copydoc ::boost::container::set::get_allocator() + allocator_type get_allocator() const; - const stored_allocator_type &get_stored_allocator() const - { return m_tree.get_stored_allocator(); } + //! @copydoc ::boost::container::set::get_stored_allocator() + stored_allocator_type &get_stored_allocator(); - stored_allocator_type &get_stored_allocator() - { return m_tree.get_stored_allocator(); } + //! @copydoc ::boost::container::set::get_stored_allocator() const + const stored_allocator_type &get_stored_allocator() const; - //! <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_tree.begin(); } + //! @copydoc ::boost::container::set::begin() + iterator begin(); - //! <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 this->cbegin(); } + //! @copydoc ::boost::container::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 cbegin() const - { return m_tree.begin(); } + //! @copydoc ::boost::container::set::cbegin() const + const_iterator cbegin() const; - //! <b>Effects</b>: Returns an iterator to the end of the container. - //! - //! <b>Throws</b>: Nothing. - //! - //! <b>Complexity</b>: Constant. - iterator end() - { return m_tree.end(); } + //! @copydoc ::boost::container::set::end() + iterator end() 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 this->cend(); } + //! @copydoc ::boost::container::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 cend() const - { return m_tree.end(); } + //! @copydoc ::boost::container::set::cend() const + const_iterator cend() const 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_tree.rbegin(); } + //! @copydoc ::boost::container::set::rbegin() + reverse_iterator rbegin() 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 this->crbegin(); } + //! @copydoc ::boost::container::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 crbegin() const - { return m_tree.rbegin(); } + //! @copydoc ::boost::container::set::crbegin() const + const_reverse_iterator crbegin() const 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_tree.rend(); } + //! @copydoc ::boost::container::set::rend() + reverse_iterator rend() 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 this->crend(); } + //! @copydoc ::boost::container::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 crend() const - { return m_tree.rend(); } + //! @copydoc ::boost::container::set::crend() const + 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_tree.empty(); } + //! @copydoc ::boost::container::set::empty() const + bool empty() const; - //! <b>Effects</b>: Returns the number of the elements contained in the container. + //! @copydoc ::boost::container::set::size() const + size_type size() const; + + //! @copydoc ::boost::container::set::max_size() const + size_type max_size() const; + + #endif //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + + //! <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>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 size() const - { return m_tree.size(); } + //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t + //! is inserted right before p. + 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 T 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_tree.max_size(); } + //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t + //! is inserted right before p. + template <class... Args> + iterator emplace_hint(const_iterator p, Args&&... args) + { return this->base_t::emplace_hint_equal(p, boost::forward<Args>(args)...); } - //! <b>Effects</b>: Swaps the contents of *this and x. - //! - //! <b>Throws</b>: Nothing. + #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(multimap& x) - { m_tree.swap(x.m_tree); } + #define BOOST_PP_LOCAL_LIMITS (0, BOOST_CONTAINER_MAX_CONSTRUCTOR_PARAMETERS) + #include BOOST_PP_LOCAL_ITERATE() + + #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING //! <b>Effects</b>: Inserts x and returns the iterator pointing to the //! newly inserted element. //! //! <b>Complexity</b>: Logarithmic. iterator insert(const value_type& x) - { return m_tree.insert_equal(x); } + { return this->base_t::insert_equal(x); } //! <b>Effects</b>: Inserts a new value constructed from x and returns //! the iterator pointing to the newly inserted element. //! //! <b>Complexity</b>: Logarithmic. iterator insert(const nonconst_value_type& x) - { return m_tree.insert_equal(x); } + { return this->base_t::insert_equal(x); } //! <b>Effects</b>: Inserts a new value move-constructed from x and returns //! the iterator pointing to the newly inserted element. //! //! <b>Complexity</b>: Logarithmic. iterator insert(BOOST_RV_REF(nonconst_value_type) x) - { return m_tree.insert_equal(boost::move(x)); } + { return this->base_t::insert_equal(boost::move(x)); } //! <b>Effects</b>: Inserts a new value move-constructed from x and returns //! the iterator pointing to the newly inserted element. //! //! <b>Complexity</b>: Logarithmic. - iterator insert(BOOST_RV_REF(nonconst_impl_value_type) x) - { return m_tree.insert_equal(boost::move(x)); } + iterator insert(BOOST_RV_REF(movable_value_type) x) + { return this->base_t::insert_equal(boost::move(x)); } //! <b>Effects</b>: Inserts a copy of x in the container. //! p is a hint pointing to where the insert should start to search. @@ -1174,8 +1212,8 @@ class multimap //! //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t //! is inserted right before p. - iterator insert(iterator position, const value_type& x) - { return m_tree.insert_equal(position, x); } + iterator insert(const_iterator p, const value_type& x) + { return this->base_t::insert_equal(p, x); } //! <b>Effects</b>: Inserts a new value constructed from x in the container. //! p is a hint pointing to where the insert should start to search. @@ -1185,8 +1223,8 @@ class multimap //! //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t //! is inserted right before p. - iterator insert(iterator position, const nonconst_value_type& x) - { return m_tree.insert_equal(position, x); } + iterator insert(const_iterator p, const nonconst_value_type& x) + { return this->base_t::insert_equal(p, 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. @@ -1196,8 +1234,8 @@ class multimap //! //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t //! is inserted right before p. - iterator insert(iterator position, BOOST_RV_REF(nonconst_value_type) x) - { return m_tree.insert_equal(position, boost::move(x)); } + iterator insert(const_iterator p, BOOST_RV_REF(nonconst_value_type) x) + { return this->base_t::insert_equal(p, boost::move(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. @@ -1207,8 +1245,8 @@ class multimap //! //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t //! is inserted right before p. - iterator insert(iterator position, BOOST_RV_REF(nonconst_impl_value_type) x) - { return m_tree.insert_equal(position, boost::move(x)); } + iterator insert(const_iterator p, BOOST_RV_REF(movable_value_type) x) + { return this->base_t::insert_equal(p, boost::move(x)); } //! <b>Requires</b>: first, last are not iterators into *this. //! @@ -1217,209 +1255,148 @@ class multimap //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from first to last) template <class InputIterator> void insert(InputIterator first, InputIterator last) - { m_tree.insert_equal(first, last); } - - #if defined(BOOST_CONTAINER_PERFECT_FORWARDING) || defined(BOOST_CONTAINER_DOXYGEN_INVOKED) + { this->base_t::insert_equal(first, last); } - //! <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. +#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST) + //! <b>Effects</b>: inserts each element from the range [il.begin(), il.end(). //! - //! <b>Returns</b>: An iterator pointing to the element with key equivalent - //! to the key of x. - //! - //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t - //! is inserted right before p. - template <class... Args> - iterator emplace(Args&&... args) - { return m_tree.emplace_equal(boost::forward<Args>(args)...); } + //! <b>Complexity</b>: At most N log(size()+N) (N is the distance from il.begin() to il.end()) + void insert(std::initializer_list<value_type> il) + { this->base_t::insert_equal(il.begin(), il.end()); } +#endif - //! <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>Returns</b>: An iterator pointing to the element with key equivalent - //! to the key of x. - //! - //! <b>Complexity</b>: Logarithmic in general, but amortized constant if t - //! is inserted right before p. - template <class... Args> - iterator emplace_hint(const_iterator hint, Args&&... args) - { return m_tree.emplace_hint_equal(hint, boost::forward<Args>(args)...); } + #if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) - #else //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + //! @copydoc ::boost::container::set::erase(const_iterator) + iterator erase(const_iterator p); - #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_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_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::set::erase(const key_type&) + size_type erase(const key_type& x); - #endif //#ifdef BOOST_CONTAINER_PERFECT_FORWARDING + //! @copydoc ::boost::container::set::erase(const_iterator,const_iterator) + iterator erase(const_iterator first, const_iterator last); - //! <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>: Amortized constant time - iterator erase(const_iterator position) - { return m_tree.erase(position); } + //! @copydoc ::boost::container::set::swap + void swap(flat_multiset& x); - //! <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>: log(size()) + count(k) - size_type erase(const key_type& x) - { return m_tree.erase(x); } + //! @copydoc ::boost::container::set::clear + void clear() BOOST_CONTAINER_NOEXCEPT; - //! <b>Effects</b>: Erases all the elements in the range [first, last). - //! - //! <b>Returns</b>: Returns last. - //! - //! <b>Complexity</b>: log(size())+N where N is the distance from first to last. - iterator erase(const_iterator first, const_iterator last) - { return m_tree.erase(first, last); } + //! @copydoc ::boost::container::set::key_comp + key_compare key_comp() const; - //! <b>Effects</b>: erase(a.begin(),a.end()). - //! - //! <b>Postcondition</b>: size() == 0. - //! - //! <b>Complexity</b>: linear in size(). - void clear() - { m_tree.clear(); } + //! @copydoc ::boost::container::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_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. - const_iterator find(const key_type& x) const - { return m_tree.find(x); } + 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_tree.count(x); } + 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_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_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_tree.upper_bound(x); } + iterator upper_bound(const key_type& x); - //! <b>Effects</b>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)). + //! <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 - std::pair<iterator,iterator> equal_range(const key_type& x) - { return m_tree.equal_range(x); } + const_iterator upper_bound(const key_type& x) const; - //! <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>: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)). //! //! <b>Complexity</b>: Logarithmic - const_iterator upper_bound(const key_type& x) const - { return m_tree.upper_bound(x); } + std::pair<iterator,iterator> equal_range(const key_type& x); //! <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_tree.equal_range(x); } - - /// @cond - template <class K1, class T1, class C1, class A1> - friend bool operator== (const multimap<K1, T1, C1, A1>& x, - const multimap<K1, T1, C1, A1>& y); - - template <class K1, class T1, class C1, class A1> - friend bool operator< (const multimap<K1, T1, C1, A1>& x, - const multimap<K1, T1, C1, A1>& y); - /// @endcond -}; + std::pair<const_iterator,const_iterator> equal_range(const key_type& x) const; -template <class Key, class T, class Pred, class A> -inline bool operator==(const multimap<Key,T,Pred,A>& x, - const multimap<Key,T,Pred,A>& y) -{ return x.m_tree == y.m_tree; } + //! <b>Effects</b>: Rebalances the tree. It's a no-op for Red-Black and AVL trees. + //! + //! <b>Complexity</b>: Linear + void rebalance(); -template <class Key, class T, class Pred, class A> -inline bool operator<(const multimap<Key,T,Pred,A>& x, - const multimap<Key,T,Pred,A>& y) -{ return x.m_tree < y.m_tree; } + //! <b>Effects</b>: Returns true if x and y are equal + //! + //! <b>Complexity</b>: Linear to the number of elements in the container. + friend bool operator==(const multimap& x, const multimap& y); -template <class Key, class T, class Pred, class A> -inline bool operator!=(const multimap<Key,T,Pred,A>& x, - const multimap<Key,T,Pred,A>& y) -{ return !(x == y); } + //! <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 multimap& x, const multimap& y); -template <class Key, class T, class Pred, class A> -inline bool operator>(const multimap<Key,T,Pred,A>& x, - const multimap<Key,T,Pred,A>& y) -{ return y < x; } + //! <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 multimap& x, const multimap& y); -template <class Key, class T, class Pred, class A> -inline bool operator<=(const multimap<Key,T,Pred,A>& x, - const multimap<Key,T,Pred,A>& y) -{ return !(y < x); } + //! <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 multimap& x, const multimap& 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 multimap& x, const multimap& y); + + //! <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 multimap& x, const multimap& y); -template <class Key, class T, class Pred, class A> -inline bool operator>=(const multimap<Key,T,Pred,A>& x, - const multimap<Key,T,Pred,A>& y) -{ return !(x < y); } + //! <b>Effects</b>: x.swap(y) + //! + //! <b>Complexity</b>: Constant. + friend void swap(multimap& x, multimap& y); -template <class Key, class T, class Pred, class A> -inline void swap(multimap<Key,T,Pred,A>& x, multimap<Key,T,Pred,A>& y) -{ x.swap(y); } + #endif //#if defined(BOOST_CONTAINER_DOXYGEN_INVOKED) +}; -/// @cond +#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED } //namespace container { -/* + //!has_trivial_destructor_after_move<> == true_type //!specialization for optimizations -template <class K, class T, class C, class A> -struct has_trivial_destructor_after_move<boost::container::multimap<K, T, C, A> > +template <class K, class T, class C, class Allocator> +struct has_trivial_destructor_after_move<boost::container::multimap<K, T, 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 }} |