A flat_multimap is a kind of associative container that supports equivalent keys (possibly containing multiple copies of the same key value) and provides for fast retrieval of values of another type T based on the keys. More...

#include <flat_map.hpp>

Public Types
typedef Key	key_type

typedef T	mapped_type

typedef std::pair< Key, T >	value_type

typedef ::boost::container::allocator_traits < Allocator >	allocator_traits_type

typedef boost::container::allocator_traits < Allocator >::pointer	pointer

typedef boost::container::allocator_traits < Allocator >::const_pointer	const_pointer

typedef boost::container::allocator_traits < Allocator >::reference	reference

typedef boost::container::allocator_traits < Allocator >::const_reference	const_reference

typedef boost::container::allocator_traits < Allocator >::size_type	size_type

typedef boost::container::allocator_traits < Allocator >::difference_type	difference_type

typedef Allocator	allocator_type

typedef Compare	key_compare

Public Member Functions
typedef	BOOST_CONTAINER_IMPDEF (Allocator) stored_allocator_type

typedef	BOOST_CONTAINER_IMPDEF (value_compare_impl) value_compare

typedef	BOOST_CONTAINER_IMPDEF (iterator_impl) iterator

typedef	BOOST_CONTAINER_IMPDEF (const_iterator_impl) const _iterator

typedef	BOOST_CONTAINER_IMPDEF (reverse_iterator_impl) reverse_iterator

typedef	BOOST_CONTAINER_IMPDEF (const_reverse_iterator_impl) const _reverse_iterator

typedef	BOOST_CONTAINER_IMPDEF (impl_value_type) movable_value_type

	flat_multimap ()
	Effects: Default constructs an empty flat_map. More...

	flat_multimap (const Compare &comp, const allocator_type &a=allocator_type())
	Effects: Constructs an empty flat_multimap using the specified comparison object and allocator. More...

	flat_multimap (const allocator_type &a)
	Effects: Constructs an empty flat_multimap using the specified allocator. More...

template<class InputIterator >
	flat_multimap (InputIterator first, InputIterator last, const Compare &comp=Compare(), const allocator_type &a=allocator_type())
	Effects: Constructs an empty flat_multimap using the specified comparison object and allocator, and inserts elements from the range [first ,last ). More...

template<class InputIterator >
	flat_multimap (ordered_range_t, InputIterator first, InputIterator last, const Compare &comp=Compare(), const allocator_type &a=allocator_type())
	Effects: Constructs an empty flat_multimap using the specified comparison object and allocator, and inserts elements from the ordered range [first ,last). More...

	flat_multimap (std::initializer_list< value_type > il, const Compare &comp=Compare(), const allocator_type &a=allocator_type())
	Effects: Constructs an empty flat_map using the specified comparison object and allocator, and inserts elements from the range [il.begin(), il.end()). More...

	flat_multimap (ordered_range_t, std::initializer_list< value_type > il, const Compare &comp=Compare(), const allocator_type &a=allocator_type())
	Effects: Constructs an empty flat_multimap using the specified comparison object and allocator, and inserts elements from the ordered range [il.begin(), il.end()). More...

	flat_multimap (const flat_multimap &x)
	Effects: Copy constructs a flat_multimap. More...

	flat_multimap (BOOST_RV_REF(flat_multimap) x)
	Effects: Move constructs a flat_multimap. More...

	flat_multimap (const flat_multimap &x, const allocator_type &a)
	Effects: Copy constructs a flat_multimap using the specified allocator. More...

	flat_multimap (BOOST_RV_REF(flat_multimap) x, const allocator_type &a)
	Effects: Move constructs a flat_multimap using the specified allocator. More...

flat_multimap &	operator= (BOOST_COPY_ASSIGN_REF(flat_multimap) x)
	Effects: Makes *this a copy of x. More...

flat_multimap &	operator= (BOOST_RV_REF(flat_multimap) x) BOOST_CONTAINER_NOEXCEPT_IF(allocator_traits_type
	Effects: this->swap(x.get()). More...

flat_multimap &	operator= (std::initializer_list< value_type > il)
	Effects: Assign content of il to *this More...

allocator_type	get_allocator () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a copy of the Allocator that was passed to the object's constructor. More...

stored_allocator_type &	get_stored_allocator () BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a reference to the internal allocator. More...

const stored_allocator_type &	get_stored_allocator () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a reference to the internal allocator. More...

iterator	begin () BOOST_CONTAINER_NOEXCEPT
	Effects: Returns an iterator to the first element contained in the container. More...

const_iterator	begin () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a const_iterator to the first element contained in the container. More...

iterator	end () BOOST_CONTAINER_NOEXCEPT
	Effects: Returns an iterator to the end of the container. More...

const_iterator	end () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a const_iterator to the end of the container. More...

reverse_iterator	rbegin () BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a reverse_iterator pointing to the beginning of the reversed container. More...

const_reverse_iterator	rbegin () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container. More...

reverse_iterator	rend () BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a reverse_iterator pointing to the end of the reversed container. More...

const_reverse_iterator	rend () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a const_reverse_iterator pointing to the end of the reversed container. More...

const_iterator	cbegin () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a const_iterator to the first element contained in the container. More...

const_iterator	cend () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a const_iterator to the end of the container. More...

const_reverse_iterator	crbegin () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed container. More...

const_reverse_iterator	crend () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns a const_reverse_iterator pointing to the end of the reversed container. More...

bool	empty () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns true if the container contains no elements. More...

size_type	size () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns the number of the elements contained in the container. More...

size_type	max_size () const BOOST_CONTAINER_NOEXCEPT
	Effects: Returns the largest possible size of the container. More...

size_type	capacity () const BOOST_CONTAINER_NOEXCEPT
	Effects: Number of elements for which memory has been allocated. More...

void	reserve (size_type cnt)
	Effects: If n is less than or equal to capacity(), this call has no effect. More...

void	shrink_to_fit ()
	Effects: Tries to deallocate the excess of memory created More...

iterator	insert (const value_type &x)
	Effects: Inserts x and returns the iterator pointing to the newly inserted element. More...

iterator	insert (BOOST_RV_REF(value_type) x)
	Effects: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element. More...

iterator	insert (BOOST_RV_REF(impl_value_type) x)
	Effects: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element. More...

iterator	insert (const_iterator p, const value_type &x)
	Effects: Inserts a copy of x in the container. More...

iterator	insert (const_iterator p, BOOST_RV_REF(value_type) x)
	Effects: Inserts a value move constructed from x in the container. More...

iterator	insert (const_iterator p, BOOST_RV_REF(impl_value_type) x)
	Effects: Inserts a value move constructed from x in the container. More...

template<class InputIterator >
void	insert (InputIterator first, InputIterator last)
	Requires: first, last are not iterators into *this. More...

template<class InputIterator >
void	insert (ordered_range_t, InputIterator first, InputIterator last)
	Requires: first, last are not iterators into *this. More...

void	insert (std::initializer_list< value_type > il)
	Effects: inserts each element from the range [il.begin(), il.end()) . More...

void	insert (ordered_range_t, std::initializer_list< value_type > il)
	Requires: [il.begin(), il.end()) must be ordered according to the predicate. More...

iterator	erase (const_iterator p)
	Effects: Erases the element pointed to by p. More...

size_type	erase (const key_type &x)
	Effects: Erases all elements in the container with key equivalent to x. More...

iterator	erase (const_iterator first, const_iterator last)
	Effects: Erases all the elements in the range [first, last). More...

void	swap (flat_multimap &x)
	Effects: Swaps the contents of *this and x. More...

void	clear () BOOST_CONTAINER_NOEXCEPT
	Effects: erase(a.begin(),a.end()). More...

key_compare	key_comp () const
	Effects: Returns the comparison object out of which a was constructed. More...

value_compare	value_comp () const
	Effects: Returns an object of value_compare constructed out of the comparison object. More...

iterator	find (const key_type &x)
	Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found. More...

const_iterator	find (const key_type &x) const
	Returns: An const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found. More...

size_type	count (const key_type &x) const
	Returns: The number of elements with key equivalent to x. More...

iterator	lower_bound (const key_type &x)
	Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found. More...

const_iterator	lower_bound (const key_type &x) const
	Returns: Allocator const iterator pointing to the first element with key not less than k, or a.end() if such an element is not found. More...

iterator	upper_bound (const key_type &x)
	Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found. More...

const_iterator	upper_bound (const key_type &x) const
	Returns: Allocator const iterator pointing to the first element with key not less than x, or end() if such an element is not found. More...

std::pair< iterator, iterator >	equal_range (const key_type &x)
	Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)). More...

std::pair< const_iterator, const_iterator >	equal_range (const key_type &x) const
	Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)). More...

Friends
bool	operator== (const flat_multimap &x, const flat_multimap &y)
	Effects: Returns true if x and y are equal More...

bool	operator!= (const flat_multimap &x, const flat_multimap &y)
	Effects: Returns true if x and y are unequal More...

bool	operator< (const flat_multimap &x, const flat_multimap &y)
	Effects: Returns true if x is less than y More...

bool	operator> (const flat_multimap &x, const flat_multimap &y)
	Effects: Returns true if x is greater than y More...

bool	operator<= (const flat_multimap &x, const flat_multimap &y)
	Effects: Returns true if x is equal or less than y More...

bool	operator>= (const flat_multimap &x, const flat_multimap &y)
	Effects: Returns true if x is equal or greater than y More...

void	swap (flat_multimap &x, flat_multimap &y)
	Effects: x.swap(y) More...

Detailed Description

template<class Key, class T, class Compare, class Allocator>
class boost::container::flat_multimap< Key, T, Compare, Allocator >

A flat_multimap is a kind of associative container that supports equivalent keys (possibly containing multiple copies of the same key value) and provides for fast retrieval of values of another type T based on the keys.

The flat_multimap class supports random-access iterators.

A flat_multimap satisfies all of the requirements of a container and of a reversible container and of an associative container. For a flat_multimap<Key,T> the key_type is Key and the value_type is std::pair<Key,T> (unlike std::multimap<Key, T> which value_type is std::pair<const Key, T>).

Compare is the ordering function for Keys (e.g. std::less<Key>).

Allocator is the allocator to allocate the value_types (e.g. allocator< std::pair<Key, T> >).

flat_multimap is similar to std::multimap but it's implemented like an ordered vector. This means that inserting a new element into a flat_map invalidates previous iterators and references

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.

Template Parameters

Key	is the key_type of the map
Value	is the `mapped_type`
Compare	is the ordering function for Keys (e.g. std::less<Key>).
Allocator	is the allocator to allocate the `value_type`s (e.g. allocator< std::pair<Key, T> > ).

Member Typedef Documentation

template<class Key , class T , class Compare , class Allocator >

typedef ::boost::container::allocator_traits<Allocator> boost::container::flat_multimap< Key, T, Compare, Allocator >::allocator_traits_type

template<class Key , class T , class Compare , class Allocator >

typedef Allocator boost::container::flat_multimap< Key, T, Compare, Allocator >::allocator_type

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::allocator_traits<Allocator>::const_pointer boost::container::flat_multimap< Key, T, Compare, Allocator >::const_pointer

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::allocator_traits<Allocator>::const_reference boost::container::flat_multimap< Key, T, Compare, Allocator >::const_reference

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::allocator_traits<Allocator>::difference_type boost::container::flat_multimap< Key, T, Compare, Allocator >::difference_type

template<class Key , class T , class Compare , class Allocator >

typedef Compare boost::container::flat_multimap< Key, T, Compare, Allocator >::key_compare

template<class Key , class T , class Compare , class Allocator >

typedef Key boost::container::flat_multimap< Key, T, Compare, Allocator >::key_type

template<class Key , class T , class Compare , class Allocator >

typedef T boost::container::flat_multimap< Key, T, Compare, Allocator >::mapped_type

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::allocator_traits<Allocator>::pointer boost::container::flat_multimap< Key, T, Compare, Allocator >::pointer

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::allocator_traits<Allocator>::reference boost::container::flat_multimap< Key, T, Compare, Allocator >::reference

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::allocator_traits<Allocator>::size_type boost::container::flat_multimap< Key, T, Compare, Allocator >::size_type

template<class Key , class T , class Compare , class Allocator >

typedef std::pair<Key, T> boost::container::flat_multimap< Key, T, Compare, Allocator >::value_type

Constructor & Destructor Documentation

template<class Key , class T , class Compare , class Allocator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap ( )

inline

Effects: Default constructs an empty flat_map.

Complexity: Constant.

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

template<class Key , class T , class Compare , class Allocator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap	(	const Compare &	comp,
		const allocator_type &	a = `allocator_type()`
	)

inlineexplicit

Effects: Constructs an empty flat_multimap using the specified comparison object and allocator.

Complexity: Constant.

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

template<class Key , class T , class Compare , class Allocator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap ( const allocator_type & a )

inlineexplicit

Effects: Constructs an empty flat_multimap using the specified allocator.

Complexity: Constant.

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

template<class Key , class T , class Compare , class Allocator >

template<class InputIterator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap	(	InputIterator	first,
		InputIterator	last,
		const Compare &	comp = `Compare()`,
		const allocator_type &	a = `allocator_type()`
	)

inline

Effects: Constructs an empty flat_multimap using the specified comparison object and allocator, and inserts elements from the range [first ,last ).

Complexity: Linear in N if the range [first ,last ) is already sorted using comp and otherwise N logN, where N is last - first.

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

template<class Key , class T , class Compare , class Allocator >

template<class InputIterator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap	(	ordered_range_t	,
		InputIterator	first,
		InputIterator	last,
		const Compare &	comp = `Compare()`,
		const allocator_type &	a = `allocator_type()`
	)

inline

Effects: Constructs an empty flat_multimap using the specified comparison object and allocator, and inserts elements from the ordered range [first ,last).

This function is more efficient than the normal range creation for ordered ranges.

Requires: [first ,last) must be ordered according to the predicate.

Complexity: Linear in N.

Note: Non-standard extension.

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

template<class Key , class T , class Compare , class Allocator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap	(	std::initializer_list< value_type >	il,
		const Compare &	comp = `Compare()`,
		const allocator_type &	a = `allocator_type()`
	)

inline

Effects: Constructs an empty flat_map using the specified comparison object and allocator, and inserts elements from the range [il.begin(), il.end()).

Complexity: Linear in N if the range [il.begin(), il.end()) is already sorted using comp and otherwise N logN, where N is last - first.

template<class Key , class T , class Compare , class Allocator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap	(	ordered_range_t	,
		std::initializer_list< value_type >	il,
		const Compare &	comp = `Compare()`,
		const allocator_type &	a = `allocator_type()`
	)

inline

Effects: Constructs an empty flat_multimap using the specified comparison object and allocator, and inserts elements from the ordered range [il.begin(), il.end()).

This function is more efficient than the normal range creation for ordered ranges.

Requires: [il.begin(), il.end()) must be ordered according to the predicate.

Complexity: Linear in N.

Note: Non-standard extension.

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

template<class Key , class T , class Compare , class Allocator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap ( const flat_multimap< Key, T, Compare, Allocator > & x )

inline

Effects: Copy constructs a flat_multimap.

Complexity: Linear in x.size().

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

template<class Key , class T , class Compare , class Allocator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap ( BOOST_RV_REF(flat_multimap< Key, T, Compare, Allocator >) x )

inline

Effects: Move constructs a flat_multimap.

Constructs *this using x's resources.

Complexity: Constant.

Postcondition: x is emptied.

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

template<class Key , class T , class Compare , class Allocator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap	(	const flat_multimap< Key, T, Compare, Allocator > &	x,
		const allocator_type &	a
	)

inline

Effects: Copy constructs a flat_multimap using the specified allocator.

Complexity: Linear in x.size().

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

template<class Key , class T , class Compare , class Allocator >

boost::container::flat_multimap< Key, T, Compare, Allocator >::flat_multimap	(	BOOST_RV_REF(flat_multimap< Key, T, Compare, Allocator >)	x,
		const allocator_type &	a
	)

inline

Effects: Move constructs a flat_multimap using the specified allocator.

Constructs *this using x's resources.

Complexity: Constant if a == x.get_allocator(), linear otherwise.

References boost::BOOST_STATIC_ASSERT(), and boost::program_options::value().

Member Function Documentation

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::begin ( )

inline

Effects: Returns an iterator to the first element contained in the container.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

const_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::begin ( ) const

inline

Effects: Returns a const_iterator to the first element contained in the container.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::flat_multimap< Key, T, Compare, Allocator >::BOOST_CONTAINER_IMPDEF ( Allocator )

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::flat_multimap< Key, T, Compare, Allocator >::BOOST_CONTAINER_IMPDEF ( value_compare_impl )

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::flat_multimap< Key, T, Compare, Allocator >::BOOST_CONTAINER_IMPDEF ( iterator_impl )

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::flat_multimap< Key, T, Compare, Allocator >::BOOST_CONTAINER_IMPDEF ( const_iterator_impl ) const

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::flat_multimap< Key, T, Compare, Allocator >::BOOST_CONTAINER_IMPDEF ( reverse_iterator_impl )

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::flat_multimap< Key, T, Compare, Allocator >::BOOST_CONTAINER_IMPDEF ( const_reverse_iterator_impl ) const

template<class Key , class T , class Compare , class Allocator >

typedef boost::container::flat_multimap< Key, T, Compare, Allocator >::BOOST_CONTAINER_IMPDEF ( impl_value_type )

template<class Key , class T , class Compare , class Allocator >

size_type boost::container::flat_multimap< Key, T, Compare, Allocator >::capacity ( ) const

inline

Effects: Number of elements for which memory has been allocated.

capacity() is always greater than or equal to size().

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

const_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::cbegin ( ) const

inline

Effects: Returns a const_iterator to the first element contained in the container.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

const_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::cend ( ) const

inline

Effects: Returns a const_iterator to the end of the container.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

void boost::container::flat_multimap< Key, T, Compare, Allocator >::clear ( )

inline

Effects: erase(a.begin(),a.end()).

Postcondition: size() == 0.

Complexity: linear in size().

template<class Key , class T , class Compare , class Allocator >

size_type boost::container::flat_multimap< Key, T, Compare, Allocator >::count ( const key_type & x ) const

inline

Returns: The number of elements with key equivalent to x.

Complexity: log(size())+count(k)

template<class Key , class T , class Compare , class Allocator >

const_reverse_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::crbegin ( ) const

inline

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

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

const_reverse_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::crend ( ) const

inline

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

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

bool boost::container::flat_multimap< Key, T, Compare, Allocator >::empty ( ) const

inline

Effects: Returns true if the container contains no elements.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::end ( )

inline

Effects: Returns an iterator to the end of the container.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

const_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::end ( ) const

inline

Effects: Returns a const_iterator to the end of the container.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

std::pair<iterator,iterator> boost::container::flat_multimap< Key, T, Compare, Allocator >::equal_range ( const key_type & x )

inline

Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).

Complexity: Logarithmic

template<class Key , class T , class Compare , class Allocator >

std::pair<const_iterator,const_iterator> boost::container::flat_multimap< Key, T, Compare, Allocator >::equal_range ( const key_type & x ) const

inline

Effects: Equivalent to std::make_pair(this->lower_bound(k), this->upper_bound(k)).

Complexity: Logarithmic

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::erase ( const_iterator p )

inline

Effects: Erases the element pointed to by p.

Returns: Returns an iterator pointing to the element immediately following q prior to the element being erased. If no such element exists, returns end().

Complexity: Linear to the elements with keys bigger than p

Note: Invalidates elements with keys not less than the erased element.

template<class Key , class T , class Compare , class Allocator >

size_type boost::container::flat_multimap< Key, T, Compare, Allocator >::erase ( const key_type & x )

inline

Effects: Erases all elements in the container with key equivalent to x.

Returns: Returns the number of erased elements.

Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys.

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::erase	(	const_iterator	first,
		const_iterator	last
	)

inline

Effects: Erases all the elements in the range [first, last).

Returns: Returns last.

Complexity: size()*N where N is the distance from first to last.

Complexity: Logarithmic search time plus erasure time linear to the elements with bigger keys.

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::find ( const key_type & x )

inline

Returns: An iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.

Complexity: Logarithmic.

template<class Key , class T , class Compare , class Allocator >

const_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::find ( const key_type & x ) const

inline

Returns: An const_iterator pointing to an element with the key equivalent to x, or end() if such an element is not found.

Complexity: Logarithmic.

template<class Key , class T , class Compare , class Allocator >

allocator_type boost::container::flat_multimap< Key, T, Compare, Allocator >::get_allocator ( ) const

inline

Effects: Returns a copy of the Allocator that was passed to the object's constructor.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

stored_allocator_type& boost::container::flat_multimap< Key, T, Compare, Allocator >::get_stored_allocator ( )

inline

Effects: Returns a reference to the internal allocator.

Throws: Nothing

Complexity: Constant.

Note: Non-standard extension.

template<class Key , class T , class Compare , class Allocator >

const stored_allocator_type& boost::container::flat_multimap< Key, T, Compare, Allocator >::get_stored_allocator ( ) const

inline

Effects: Returns a reference to the internal allocator.

Throws: Nothing

Complexity: Constant.

Note: Non-standard extension.

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::insert ( const value_type & x )

inline

Effects: Inserts x and returns the iterator pointing to the newly inserted element.

Complexity: Logarithmic search time plus linear insertion to the elements with bigger keys than x.

Note: If an element is inserted it might invalidate elements.

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::insert ( BOOST_RV_REF(value_type) x )

inline

Effects: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element.

Complexity: Logarithmic search time plus linear insertion to the elements with bigger keys than x.

Note: If an element is inserted it might invalidate elements.

References boost::move().

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::insert ( BOOST_RV_REF(impl_value_type) x )

inline

Effects: Inserts a new value move-constructed from x and returns the iterator pointing to the newly inserted element.

Complexity: Logarithmic search time plus linear insertion to the elements with bigger keys than x.

Note: If an element is inserted it might invalidate elements.

References boost::move().

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::insert	(	const_iterator	p,
		const value_type &	x
	)

inline

Effects: Inserts a copy of x in the container.

p is a hint pointing to where the insert should start to search.

Returns: An iterator pointing to the element with key equivalent to the key of x.

Complexity: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.

Note: If an element is inserted it might invalidate elements.

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::insert	(	const_iterator	p,
		BOOST_RV_REF(value_type)	x
	)

inline

Effects: Inserts a value move constructed from x in the container.

p is a hint pointing to where the insert should start to search.

Returns: An iterator pointing to the element with key equivalent to the key of x.

Complexity: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.

Note: If an element is inserted it might invalidate elements.

References boost::move().

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::insert	(	const_iterator	p,
		BOOST_RV_REF(impl_value_type)	x
	)

inline

Effects: Inserts a value move constructed from x in the container.

p is a hint pointing to where the insert should start to search.

Returns: An iterator pointing to the element with key equivalent to the key of x.

Complexity: Logarithmic search time (constant time if the value is to be inserted before p) plus linear insertion to the elements with bigger keys than x.

Note: If an element is inserted it might invalidate elements.

References boost::move().

template<class Key , class T , class Compare , class Allocator >

template<class InputIterator >

void boost::container::flat_multimap< Key, T, Compare, Allocator >::insert	(	InputIterator	first,
		InputIterator	last
	)

inline

Requires: first, last are not iterators into *this.

Effects: inserts each element from the range [first,last) .

Complexity: At most N log(size()+N) (N is the distance from first to last) search time plus N*size() insertion time.

Note: If an element is inserted it might invalidate elements.

template<class Key , class T , class Compare , class Allocator >

template<class InputIterator >

void boost::container::flat_multimap< Key, T, Compare, Allocator >::insert	(	ordered_range_t	,
		InputIterator	first,
		InputIterator	last
	)

inline

Requires: first, last are not iterators into *this.

Requires: [first ,last) must be ordered according to the predicate.

Effects: inserts each element from the range [first,last) if and only if there is no element with key equivalent to the key of that element. This function is more efficient than the normal range creation for ordered ranges.

Complexity: At most N log(size()+N) (N is the distance from first to last) search time plus N*size() insertion time.

Note: If an element is inserted it might invalidate elements.

Note: Non-standard extension.

template<class Key , class T , class Compare , class Allocator >

void boost::container::flat_multimap< Key, T, Compare, Allocator >::insert ( std::initializer_list< value_type > il )

inline

Effects: inserts each element from the range [il.begin(), il.end()) .

Complexity: At most N log(size()+N) (N is the distance from first to last) search time plus N*size() insertion time.

Note: If an element is inserted it might invalidate elements.

template<class Key , class T , class Compare , class Allocator >

void boost::container::flat_multimap< Key, T, Compare, Allocator >::insert	(	ordered_range_t	,
		std::initializer_list< value_type >	il
	)

inline

Requires: [il.begin(), il.end()) must be ordered according to the predicate.

Effects: 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. This function is more efficient than the normal range creation for ordered ranges.

Complexity: At most N log(size()+N) (N is the distance from first to last) search time plus N*size() insertion time.

Note: If an element is inserted it might invalidate elements.

Note: Non-standard extension.

template<class Key , class T , class Compare , class Allocator >

key_compare boost::container::flat_multimap< Key, T, Compare, Allocator >::key_comp ( ) const

inline

Effects: Returns the comparison object out of which a was constructed.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::lower_bound ( const key_type & x )

inline

Returns: An iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.

Complexity: Logarithmic

template<class Key , class T , class Compare , class Allocator >

const_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::lower_bound ( const key_type & x ) const

inline

Returns: Allocator const iterator pointing to the first element with key not less than k, or a.end() if such an element is not found.

Complexity: Logarithmic

template<class Key , class T , class Compare , class Allocator >

size_type boost::container::flat_multimap< Key, T, Compare, Allocator >::max_size ( ) const

inline

Effects: Returns the largest possible size of the container.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

flat_multimap& boost::container::flat_multimap< Key, T, Compare, Allocator >::operator= ( BOOST_COPY_ASSIGN_REF(flat_multimap< Key, T, Compare, Allocator >) x )

inline

Effects: Makes *this a copy of x.

Complexity: Linear in x.size().

template<class Key , class T , class Compare , class Allocator >

flat_multimap& boost::container::flat_multimap< Key, T, Compare, Allocator >::operator= ( BOOST_RV_REF(flat_multimap< Key, T, Compare, Allocator >) x )

inline

Effects: this->swap(x.get()).

Complexity: Constant.

References boost::move(), and boost::flyweights::x.

template<class Key , class T , class Compare , class Allocator >

flat_multimap& boost::container::flat_multimap< Key, T, Compare, Allocator >::operator= ( std::initializer_list< value_type > il )

inline

Effects: Assign content of il to *this

Complexity: Linear in il.size().

template<class Key , class T , class Compare , class Allocator >

reverse_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::rbegin ( )

inline

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

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

const_reverse_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::rbegin ( ) const

inline

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

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

reverse_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::rend ( )

inline

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

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

const_reverse_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::rend ( ) const

inline

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

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

void boost::container::flat_multimap< Key, T, Compare, Allocator >::reserve ( size_type cnt )

inline

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

Throws: If memory allocation allocation throws or T's copy constructor throws.

Note: If capacity() is less than "cnt", iterators and references to to values might be invalidated.

template<class Key , class T , class Compare , class Allocator >

void boost::container::flat_multimap< Key, T, Compare, Allocator >::shrink_to_fit ( )

inline

Effects: Tries to deallocate the excess of memory created

Throws: If memory allocation throws, or T's copy constructor throws.

Complexity: Linear to size().

template<class Key , class T , class Compare , class Allocator >

size_type boost::container::flat_multimap< Key, T, Compare, Allocator >::size ( ) const

inline

Effects: Returns the number of the elements contained in the container.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

void boost::container::flat_multimap< Key, T, Compare, Allocator >::swap ( flat_multimap< Key, T, Compare, Allocator > & x )

inline

Effects: Swaps the contents of *this and x.

Throws: Nothing.

Complexity: Constant.

template<class Key , class T , class Compare , class Allocator >

iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::upper_bound ( const key_type & x )

inline

Returns: An iterator pointing to the first element with key not less than x, or end() if such an element is not found.

Complexity: Logarithmic

template<class Key , class T , class Compare , class Allocator >

const_iterator boost::container::flat_multimap< Key, T, Compare, Allocator >::upper_bound ( const key_type & x ) const

inline

Returns: Allocator const iterator pointing to the first element with key not less than x, or end() if such an element is not found.

Complexity: Logarithmic

template<class Key , class T , class Compare , class Allocator >

value_compare boost::container::flat_multimap< Key, T, Compare, Allocator >::value_comp ( ) const

inline

Effects: Returns an object of value_compare constructed out of the comparison object.

Complexity: Constant.

Friends And Related Function Documentation

template<class Key , class T , class Compare , class Allocator >

bool operator!=	(	const flat_multimap< Key, T, Compare, Allocator > &	x,
		const flat_multimap< Key, T, Compare, Allocator > &	y
	)

friend

Effects: Returns true if x and y are unequal

Complexity: Linear to the number of elements in the container.

template<class Key , class T , class Compare , class Allocator >

bool operator<	(	const flat_multimap< Key, T, Compare, Allocator > &	x,
		const flat_multimap< Key, T, Compare, Allocator > &	y
	)

friend

Effects: Returns true if x is less than y

Complexity: Linear to the number of elements in the container.

template<class Key , class T , class Compare , class Allocator >

bool operator<=	(	const flat_multimap< Key, T, Compare, Allocator > &	x,
		const flat_multimap< Key, T, Compare, Allocator > &	y
	)

friend

Effects: Returns true if x is equal or less than y

Complexity: Linear to the number of elements in the container.

template<class Key , class T , class Compare , class Allocator >

bool operator==	(	const flat_multimap< Key, T, Compare, Allocator > &	x,
		const flat_multimap< Key, T, Compare, Allocator > &	y
	)

friend

Effects: Returns true if x and y are equal

Complexity: Linear to the number of elements in the container.

template<class Key , class T , class Compare , class Allocator >

bool operator>	(	const flat_multimap< Key, T, Compare, Allocator > &	x,
		const flat_multimap< Key, T, Compare, Allocator > &	y
	)

friend

Effects: Returns true if x is greater than y

Complexity: Linear to the number of elements in the container.

template<class Key , class T , class Compare , class Allocator >

bool operator>=	(	const flat_multimap< Key, T, Compare, Allocator > &	x,
		const flat_multimap< Key, T, Compare, Allocator > &	y
	)

friend

Effects: Returns true if x is equal or greater than y

Complexity: Linear to the number of elements in the container.

template<class Key , class T , class Compare , class Allocator >

void swap	(	flat_multimap< Key, T, Compare, Allocator > &	x,
		flat_multimap< Key, T, Compare, Allocator > &	y
	)

friend

Effects: x.swap(y)

Complexity: Constant.

The documentation for this class was generated from the following files:

boost_1_57_0/boost/container/container_fwd.hpp
boost_1_57_0/boost/container/flat_map.hpp

Public Types

Public Member Functions

Friends

Detailed Description

template<class Key, class T, class Compare, class Allocator> class boost::container::flat_multimap< Key, T, Compare, Allocator >

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

template<class Key, class T, class Compare, class Allocator>
class boost::container::flat_multimap< Key, T, Compare, Allocator >