A flat_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. More...

#include <flat_map.hpp>

Inheritance diagram for boost::container::flat_map< Key, T, Compare, Allocator >:

[legend]

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_map ()
	Effects: Default constructs an empty flat_map. More...

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

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

template<class InputIterator >
	flat_map (InputIterator first, InputIterator last, 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 [first ,last ). More...

template<class InputIterator >
	flat_map (ordered_unique_range_t, InputIterator first, InputIterator last, 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 ordered unique range [first ,last). More...

	flat_map (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_map (ordered_unique_range_t, 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 ordered unique range [il.begin(), il.end()). More...

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

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

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

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

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

flat_map &	operator= (BOOST_RV_REF(flat_map) x) BOOST_CONTAINER_NOEXCEPT_IF(allocator_traits_type
	Effects: Move constructs a flat_map. More...

flat_map &	operator= (std::initializer_list< value_type > il)
	Effects: Assign elements from 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...

T &	at (const key_type &k)
	Returns: Allocator reference to the element whose key is equivalent to x. More...

const T &	at (const key_type &k) const
	Returns: Allocator reference to the element whose key is equivalent to x. More...

std::pair< iterator, bool >	insert (const value_type &x)
	Effects: Inserts x if and only if there is no element in the container with key equivalent to the key of x. More...

std::pair< iterator, bool >	insert (BOOST_RV_REF(value_type) x)
	Effects: 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. More...

std::pair< iterator, bool >	insert (BOOST_RV_REF(movable_value_type) x)
	Effects: 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. More...

iterator	insert (const_iterator p, const value_type &x)
	Effects: 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. More...

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

iterator	insert (const_iterator p, BOOST_RV_REF(movable_value_type) x)
	Effects: Inserts an element 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_unique_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()) if and only if there is no element with key equivalent to the key of that element. More...

void	insert (ordered_unique_range_t, std::initializer_list< value_type > il)
	Requires: [il.begin(), il.end()) must be ordered according to the predicate and must be unique values. 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_map &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: Allocator 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_map &x, const flat_map &y)
	Effects: Returns true if x and y are equal More...

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

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

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

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

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

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

Detailed Description

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

A flat_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 flat_map class supports random-access iterators.

A flat_map satisfies all of the requirements of a container and of a reversible container and of an associative container. A flat_map also provides most operations described for unique keys. For a flat_map<Key,T> the key_type is Key and the value_type is std::pair<Key,T> (unlike std::map<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_map is similar to std::map 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_map< Key, T, Compare, Allocator >::allocator_traits_type

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

typedef Allocator boost::container::flat_map< 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_map< 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_map< 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_map< Key, T, Compare, Allocator >::difference_type

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

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

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

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

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

typedef T boost::container::flat_map< 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_map< Key, T, Compare, Allocator >::pointer

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

typedef boost::container::allocator_traits<Allocator>::reference boost::container::flat_map< 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_map< Key, T, Compare, Allocator >::size_type

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

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

Constructor & Destructor Documentation

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

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

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_map< Key, T, Compare, Allocator >::flat_map	(	const Compare &	comp,
		const allocator_type &	a = `allocator_type()`
	)

inlineexplicit

Effects: Constructs an empty flat_map 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_map< Key, T, Compare, Allocator >::flat_map ( const allocator_type & a )

inlineexplicit

Effects: Constructs an empty flat_map 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_map< Key, T, Compare, Allocator >::flat_map	(	InputIterator	first,
		InputIterator	last,
		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 [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_map< Key, T, Compare, Allocator >::flat_map	(	ordered_unique_range_t	,
		InputIterator	first,
		InputIterator	last,
		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 ordered unique 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 and must be unique values.

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_map< Key, T, Compare, Allocator >::flat_map	(	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_map< Key, T, Compare, Allocator >::flat_map	(	ordered_unique_range_t	,
		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 ordered unique 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 and must be unique values.

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_map< Key, T, Compare, Allocator >::flat_map ( const flat_map< Key, T, Compare, Allocator > & x )

inline

Effects: Copy constructs a flat_map.

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_map< Key, T, Compare, Allocator >::flat_map ( BOOST_RV_REF(flat_map< Key, T, Compare, Allocator >) x )

inline

Effects: Move constructs a flat_map.

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_map< Key, T, Compare, Allocator >::flat_map	(	const flat_map< Key, T, Compare, Allocator > &	x,
		const allocator_type &	a
	)

inline

Effects: Copy constructs a flat_map 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_map< Key, T, Compare, Allocator >::flat_map	(	BOOST_RV_REF(flat_map< Key, T, Compare, Allocator >)	x,
		const allocator_type &	a
	)

inline

Effects: Move constructs a flat_map using the specified allocator.

Constructs *this using x's resources.

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

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

Member Function Documentation

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

T& boost::container::flat_map< Key, T, Compare, Allocator >::at ( const key_type & k )

inline

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.

References boost::container::flat_map< Key, T, Compare, Allocator >::end(), boost::container::flat_map< Key, T, Compare, Allocator >::find(), boost::multiprecision::backends::i, and boost::container::throw_out_of_range().

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

const T& boost::container::flat_map< Key, T, Compare, Allocator >::at ( const key_type & k ) const

inline

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.

References boost::container::flat_map< Key, T, Compare, Allocator >::end(), boost::container::flat_map< Key, T, Compare, Allocator >::find(), boost::multiprecision::backends::i, and boost::container::throw_out_of_range().

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

iterator boost::container::flat_map< 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_map< 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_map< Key, T, Compare, Allocator >::BOOST_CONTAINER_IMPDEF ( Allocator )

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

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

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

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

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

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

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

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

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

typedef boost::container::flat_map< 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_map< Key, T, Compare, Allocator >::BOOST_CONTAINER_IMPDEF ( impl_value_type )

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

size_type boost::container::flat_map< 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_map< 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_map< 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_map< 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_map< 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_map< 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_map< 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_map< 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_map< Key, T, Compare, Allocator >::end ( )

inline

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

Throws: Nothing.

Complexity: Constant.

Referenced by boost::container::flat_map< Key, T, Compare, Allocator >::at().

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

const_iterator boost::container::flat_map< 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_map< 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_map< 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_map< 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_map< 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_map< 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_map< 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.

Referenced by boost::container::flat_map< Key, T, Compare, Allocator >::at().

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

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

inline

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

Complexity: Logarithmic.s

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

allocator_type boost::container::flat_map< 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_map< 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_map< 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 >

std::pair<iterator,bool> boost::container::flat_map< Key, T, Compare, Allocator >::insert ( const value_type & x )

inline

Effects: Inserts x if and only if there is no element in the container with key equivalent to the key of x.

Returns: The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of x.

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 >

std::pair<iterator,bool> boost::container::flat_map< Key, T, Compare, Allocator >::insert ( BOOST_RV_REF(value_type) x )

inline

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

Returns: The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of x.

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 >

std::pair<iterator,bool> boost::container::flat_map< Key, T, Compare, Allocator >::insert ( BOOST_RV_REF(movable_value_type) x )

inline

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

Returns: The bool component of the returned pair is true if and only if the insertion takes place, and the iterator component of the pair points to the element with key equivalent to the key of x.

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_map< Key, T, Compare, Allocator >::insert	(	const_iterator	p,
		const value_type &	x
	)

inline

Effects: Inserts a copy of x in the container if and only if there is no element in the container with key equivalent to the key of x.

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

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

Complexity: Logarithmic search time (constant if x is inserted right before p) plus insertion linear 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_map< Key, T, Compare, Allocator >::insert	(	const_iterator	p,
		BOOST_RV_REF(value_type)	x
	)

inline

Effects: Inserts an element 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 if x is inserted right before p) plus insertion linear 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_map< Key, T, Compare, Allocator >::insert	(	const_iterator	p,
		BOOST_RV_REF(movable_value_type)	x
	)

inline

Effects: Inserts an element 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 if x is inserted right before p) plus insertion linear 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_map< 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) if and only if there is no element with key equivalent to the key of that element.

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_map< Key, T, Compare, Allocator >::insert	(	ordered_unique_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 and must be unique values.

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_map< Key, T, Compare, Allocator >::insert ( std::initializer_list< value_type > il )

inline

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.

Complexity: At most N log(size()+N) (N is the distance from il.first() to il.end()) 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_map< Key, T, Compare, Allocator >::insert	(	ordered_unique_range_t	,
		std::initializer_list< value_type >	il
	)

inline

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

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_map< 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_map< 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_map< 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_map< 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_map& boost::container::flat_map< Key, T, Compare, Allocator >::operator= ( BOOST_COPY_ASSIGN_REF(flat_map< 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_map& boost::container::flat_map< Key, T, Compare, Allocator >::operator= ( BOOST_RV_REF(flat_map< Key, T, Compare, Allocator >) x )

inline

Effects: Move constructs a flat_map.

Constructs *this using x's resources.

Throws: If allocator_traits_type::propagate_on_container_move_assignment is false and (allocation throws or value_type's move constructor throws)

Complexity: Constant if allocator_traits_type:: propagate_on_container_move_assignment is true or this->get>allocator() == x.get_allocator(). Linear otherwise.

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

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

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

inline

Effects: Assign elements from il to *this

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

reverse_iterator boost::container::flat_map< 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_map< 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_map< 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_map< 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_map< 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.

Referenced by boost::interprocess::flat_map_index< MapConfig >::reserve().

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

void boost::container::flat_map< 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().

Referenced by boost::interprocess::flat_map_index< MapConfig >::shrink_to_fit().

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

size_type boost::container::flat_map< 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_map< Key, T, Compare, Allocator >::swap ( flat_map< 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_map< 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_map< 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_map< 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_map< Key, T, Compare, Allocator > &	x,
		const flat_map< 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_map< Key, T, Compare, Allocator > &	x,
		const flat_map< 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_map< Key, T, Compare, Allocator > &	x,
		const flat_map< 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_map< Key, T, Compare, Allocator > &	x,
		const flat_map< 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_map< Key, T, Compare, Allocator > &	x,
		const flat_map< 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_map< Key, T, Compare, Allocator > &	x,
		const flat_map< 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_map< Key, T, Compare, Allocator > &	x,
		flat_map< 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_map< 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_map< Key, T, Compare, Allocator >