boost::unordered::unordered_map< K, T, H, P, A > Singleton Reference

#include <unordered_map_fwd.hpp>

Inheritance diagram for boost::unordered::unordered_map< K, T, H, P, A >:

Public Types
typedef K	key_type
typedef std::pair< const K, T >	value_type
typedef T	mapped_type
typedef H	hasher
typedef P	key_equal
typedef A	allocator_type
typedef allocator_traits::pointer	pointer
typedef allocator_traits::const_pointer	const_pointer
typedef value_type &	reference
typedef value_type const &	const_reference
typedef std::size_t	size_type
typedef std::ptrdiff_t	difference_type
typedef table::cl_iterator	const_local_iterator
typedef table::l_iterator	local_iterator
typedef table::c_iterator	const_iterator
typedef table::iterator	iterator

Public Member Functions
	unordered_map (size_type=boost::unordered::detail::default_bucket_count, const hasher &=hasher(), const key_equal &=key_equal(), const allocator_type &=allocator_type())
	unordered_map (allocator_type const &)
template<class InputIt >
	unordered_map (InputIt, InputIt)
template<class InputIt >
	unordered_map (InputIt, InputIt, size_type, const hasher &=hasher(), const key_equal &=key_equal())
template<class InputIt >
	unordered_map (InputIt, InputIt, size_type, const hasher &, const key_equal &, const allocator_type &)
	unordered_map (unordered_map const &)
	unordered_map (unordered_map const &, allocator_type const &)
	unordered_map (unordered_map &&other) BOOST_NOEXCEPT_IF(table
	unordered_map (unordered_map &&, allocator_type const &)
	unordered_map (std::initializer_list< value_type >, size_type=boost::unordered::detail::default_bucket_count, const hasher &=hasher(), const key_equal &l=key_equal(), const allocator_type &=allocator_type())
	~unordered_map () BOOST_NOEXCEPT
unordered_map &	operator= (unordered_map const &x)
unordered_map &	operator= (unordered_map &&x)
unordered_map &	operator= (std::initializer_list< value_type >)
allocator_type	get_allocator () const BOOST_NOEXCEPT
bool	empty () const BOOST_NOEXCEPT
size_type	size () const BOOST_NOEXCEPT
size_type	max_size () const BOOST_NOEXCEPT
iterator	begin () BOOST_NOEXCEPT
const_iterator	begin () const BOOST_NOEXCEPT
iterator	end () BOOST_NOEXCEPT
const_iterator	end () const BOOST_NOEXCEPT
const_iterator	cbegin () const BOOST_NOEXCEPT
const_iterator	cend () const BOOST_NOEXCEPT
template<class... Args>
std::pair< iterator, bool >	emplace (BOOST_FWD_REF(Args)...args)
template<class... Args>
iterator	emplace_hint (const_iterator, BOOST_FWD_REF(Args)...args)
std::pair< iterator, bool >	insert (value_type const &x)
std::pair< iterator, bool >	insert (BOOST_RV_REF(value_type) x)
iterator	insert (const_iterator hint, value_type const &x)
iterator	insert (const_iterator hint, BOOST_RV_REF(value_type) x)
template<class InputIt >
void	insert (InputIt, InputIt)
void	insert (std::initializer_list< value_type >)
iterator	erase (const_iterator)
size_type	erase (const key_type &)
iterator	erase (const_iterator, const_iterator)
void	quick_erase (const_iterator it)
void	erase_return_void (const_iterator it)
void	clear ()
void	swap (unordered_map &)
hasher	hash_function () const
key_equal	key_eq () const
mapped_type &	operator[] (const key_type &)
mapped_type &	at (const key_type &)
mapped_type const &	at (const key_type &) const
iterator	find (const key_type &)
const_iterator	find (const key_type &) const
template<class CompatibleKey , class CompatibleHash , class CompatiblePredicate >
iterator	find (CompatibleKey const &, CompatibleHash const &, CompatiblePredicate const &)
template<class CompatibleKey , class CompatibleHash , class CompatiblePredicate >
const_iterator	find (CompatibleKey const &, CompatibleHash const &, CompatiblePredicate const &) const
size_type	count (const key_type &) const
std::pair< iterator, iterator >	equal_range (const key_type &)
std::pair< const_iterator, const_iterator >	equal_range (const key_type &) const
size_type	bucket_count () const BOOST_NOEXCEPT
size_type	max_bucket_count () const BOOST_NOEXCEPT
size_type	bucket_size (size_type) const
size_type	bucket (const key_type &k) const
local_iterator	begin (size_type n)
const_local_iterator	begin (size_type n) const
local_iterator	end (size_type)
const_local_iterator	end (size_type) const
const_local_iterator	cbegin (size_type n) const
const_local_iterator	cend (size_type) const
float	max_load_factor () const BOOST_NOEXCEPT
float	load_factor () const BOOST_NOEXCEPT
void	max_load_factor (float) BOOST_NOEXCEPT
void	rehash (size_type)
void	reserve (size_type)

Friends
bool	operator== (unordered_map const &, unordered_map const &)
bool	operator!= (unordered_map const &, unordered_map const &)

Member Typedef Documentation

template<class K, class T, class H, class P, class A>

typedef A boost::unordered::unordered_map< K, T, H, P, A >::allocator_type

template<class K, class T, class H, class P, class A>

typedef table::c_iterator boost::unordered::unordered_map< K, T, H, P, A >::const_iterator

template<class K, class T, class H, class P, class A>

typedef table::cl_iterator boost::unordered::unordered_map< K, T, H, P, A >::const_local_iterator

template<class K, class T, class H, class P, class A>

typedef allocator_traits::const_pointer boost::unordered::unordered_map< K, T, H, P, A >::const_pointer

template<class K, class T, class H, class P, class A>

typedef value_type const& boost::unordered::unordered_map< K, T, H, P, A >::const_reference

template<class K, class T, class H, class P, class A>

typedef std::ptrdiff_t boost::unordered::unordered_map< K, T, H, P, A >::difference_type

template<class K, class T, class H, class P, class A>

typedef H boost::unordered::unordered_map< K, T, H, P, A >::hasher

template<class K, class T, class H, class P, class A>

typedef table::iterator boost::unordered::unordered_map< K, T, H, P, A >::iterator

template<class K, class T, class H, class P, class A>

typedef P boost::unordered::unordered_map< K, T, H, P, A >::key_equal

template<class K, class T, class H, class P, class A>

typedef K boost::unordered::unordered_map< K, T, H, P, A >::key_type

template<class K, class T, class H, class P, class A>

typedef table::l_iterator boost::unordered::unordered_map< K, T, H, P, A >::local_iterator

template<class K, class T, class H, class P, class A>

typedef T boost::unordered::unordered_map< K, T, H, P, A >::mapped_type

template<class K, class T, class H, class P, class A>

typedef allocator_traits::pointer boost::unordered::unordered_map< K, T, H, P, A >::pointer

template<class K, class T, class H, class P, class A>

typedef value_type& boost::unordered::unordered_map< K, T, H, P, A >::reference

template<class K, class T, class H, class P, class A>

typedef std::size_t boost::unordered::unordered_map< K, T, H, P, A >::size_type

template<class K, class T, class H, class P, class A>

typedef std::pair<const K, T> boost::unordered::unordered_map< K, T, H, P, A >::value_type

Constructor & Destructor Documentation

template<class K , class T , class H , class P , class A >

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map ( size_type  n = boost::unordered::detail::default_bucket_count, const hasher &  hf = hasher(), const key_equal &  eql = key_equal(), const allocator_type &  a = allocator_type()  )

explicit

template<class K , class T , class H , class P , class A >

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map ( allocator_type const &  a )

explicit

template<class K , class T , class H , class P , class A >

template<class InputIt >

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map	(	InputIt	f,
		InputIt	l
	)

template<class K , class T , class H , class P , class A >

template<class InputIt >

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map	(	InputIt	f,
		InputIt	l,
		size_type	n,
		const hasher &	hf = hasher(),
		const key_equal &	eql = key_equal()
	)

template<class K , class T , class H , class P , class A >

template<class InputIt >

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map	(	InputIt	f,
		InputIt	l,
		size_type	n,
		const hasher &	hf,
		const key_equal &	eql,
		const allocator_type &	a
	)

template<class K , class T , class H , class P , class A >

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map

(

unordered_map< K, T, H, P, A > const &

other

)

template<class K , class T , class H , class P , class A >

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map	(	unordered_map< K, T, H, P, A > const &	other,
		allocator_type const &	a
	)

template<class K, class T, class H, class P, class A>

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map ( unordered_map< K, T, H, P, A > &&  other )

inline

template<class K , class T , class H , class P , class A >

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map	(	unordered_map< K, T, H, P, A > &&	other,
		allocator_type const &	a
	)

template<class K , class T , class H , class P , class A >

boost::unordered::unordered_map< K, T, H, P, A >::unordered_map	(	std::initializer_list< value_type >	list,
		size_type	n = boost::unordered::detail::default_bucket_count,
		const hasher &	hf = hasher(),
		const key_equal &	l = key_equal(),
		const allocator_type &	a = allocator_type()
	)

template<class K , class T , class H , class P , class A >

boost::unordered::unordered_map< K, T, H, P, A >::~unordered_map

(

)

Member Function Documentation

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::mapped_type & boost::unordered::unordered_map< K, T, H, P, A >::at

(

const key_type &

k

)

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::mapped_type const & boost::unordered::unordered_map< K, T, H, P, A >::at

(

const key_type &

k

)

const

template<class K, class T, class H, class P, class A>

iterator boost::unordered::unordered_map< K, T, H, P, A >::begin ( void  )

inline

template<class K, class T, class H, class P, class A>

const_iterator boost::unordered::unordered_map< K, T, H, P, A >::begin ( void  ) const

inline

template<class K, class T, class H, class P, class A>

local_iterator boost::unordered::unordered_map< K, T, H, P, A >::begin ( size_type  n )

inline

template<class K, class T, class H, class P, class A>

const_local_iterator boost::unordered::unordered_map< K, T, H, P, A >::begin ( size_type  n ) const

inline

template<class K, class T, class H, class P, class A>

size_type boost::unordered::unordered_map< K, T, H, P, A >::bucket ( const key_type &  k ) const

inline

template<class K, class T, class H, class P, class A>

size_type boost::unordered::unordered_map< K, T, H, P, A >::bucket_count ( ) const

inline

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::size_type boost::unordered::unordered_map< K, T, H, P, A >::bucket_size

(

size_type

n

)

const

template<class K, class T, class H, class P, class A>

const_iterator boost::unordered::unordered_map< K, T, H, P, A >::cbegin ( ) const

inline

template<class K, class T, class H, class P, class A>

const_local_iterator boost::unordered::unordered_map< K, T, H, P, A >::cbegin ( size_type  n ) const

inline

template<class K, class T, class H, class P, class A>

const_iterator boost::unordered::unordered_map< K, T, H, P, A >::cend ( ) const

inline

template<class K, class T, class H, class P, class A>

const_local_iterator boost::unordered::unordered_map< K, T, H, P, A >::cend ( size_type  ) const

inline

template<class K , class T , class H , class P , class A >

void boost::unordered::unordered_map< K, T, H, P, A >::clear

(

void

)

Referenced by boost::spirit::qi::tst_map< Char, T >::clear(), and boost::unordered::unordered_map< K, T, H, P, A >::operator=().

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::size_type boost::unordered::unordered_map< K, T, H, P, A >::count

(

const key_type &

k

)

const

template<class K, class T, class H, class P, class A>

template<class... Args>

std::pair<iterator, bool> boost::unordered::unordered_map< K, T, H, P, A >::emplace ( BOOST_FWD_REF(Args)...  args )

inline

Referenced by boost::unordered::unordered_map< sync_id, void * >::insert().

template<class K, class T, class H, class P, class A>

template<class... Args>

iterator boost::unordered::unordered_map< K, T, H, P, A >::emplace_hint ( const_iterator  , BOOST_FWD_REF(Args)...  args  )

inline

Referenced by boost::unordered::unordered_map< sync_id, void * >::insert().

template<class K, class T, class H, class P, class A>

bool boost::unordered::unordered_map< K, T, H, P, A >::empty ( void  ) const

inline

template<class K, class T, class H, class P, class A>

iterator boost::unordered::unordered_map< K, T, H, P, A >::end ( void  )

inline

Referenced by boost::interprocess::ipcdetail::sync_handles::destroy_handle(), boost::spirit::qi::tst_map< Char, T >::find(), and boost::spirit::qi::tst_map< Char, T >::remove().

template<class K, class T, class H, class P, class A>

const_iterator boost::unordered::unordered_map< K, T, H, P, A >::end ( void  ) const

inline

template<class K, class T, class H, class P, class A>

local_iterator boost::unordered::unordered_map< K, T, H, P, A >::end ( size_type  )

inline

template<class K, class T, class H, class P, class A>

const_local_iterator boost::unordered::unordered_map< K, T, H, P, A >::end ( size_type  ) const

inline

template<class K , class T , class H , class P , class A >

std::pair< typename unordered_map< K, T, H, P, A >::iterator, typename unordered_map< K, T, H, P, A >::iterator > boost::unordered::unordered_map< K, T, H, P, A >::equal_range

(

const key_type &

k

)

template<class K , class T , class H , class P , class A >

std::pair< typename unordered_map< K, T, H, P, A >::const_iterator, typename unordered_map< K, T, H, P, A >::const_iterator > boost::unordered::unordered_map< K, T, H, P, A >::equal_range

(

const key_type &

k

)

const

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::iterator boost::unordered::unordered_map< K, T, H, P, A >::erase

(

const_iterator

position

)

Referenced by boost::interprocess::ipcdetail::sync_handles::destroy_handle(), boost::interprocess::ipcdetail::sync_handles::destroy_syncs_in_range(), boost::unordered::unordered_map< sync_id, void * >::erase_return_void(), boost::unordered::unordered_map< sync_id, void * >::quick_erase(), and boost::spirit::qi::tst_map< Char, T >::remove().

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::size_type boost::unordered::unordered_map< K, T, H, P, A >::erase

(

const key_type &

k

)

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::iterator boost::unordered::unordered_map< K, T, H, P, A >::erase	(	const_iterator	first,
		const_iterator	last
	)

template<class K, class T, class H, class P, class A>

void boost::unordered::unordered_map< K, T, H, P, A >::erase_return_void ( const_iterator  it )

inline

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::iterator boost::unordered::unordered_map< K, T, H, P, A >::find

(

const key_type &

k

)

Referenced by boost::interprocess::ipcdetail::sync_handles::destroy_handle(), boost::spirit::qi::tst_map< Char, T >::find(), and boost::spirit::qi::tst_map< Char, T >::remove().

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::const_iterator boost::unordered::unordered_map< K, T, H, P, A >::find

(

const key_type &

k

)

const

template<class K , class T , class H , class P , class A >

template<class CompatibleKey , class CompatibleHash , class CompatiblePredicate >

unordered_map< K, T, H, P, A >::iterator boost::unordered::unordered_map< K, T, H, P, A >::find	(	CompatibleKey const &	k,
		CompatibleHash const &	hash,
		CompatiblePredicate const &	eq
	)

template<class K , class T , class H , class P , class A >

template<class CompatibleKey , class CompatibleHash , class CompatiblePredicate >

unordered_map< K, T, H, P, A >::const_iterator boost::unordered::unordered_map< K, T, H, P, A >::find	(	CompatibleKey const &	k,
		CompatibleHash const &	hash,
		CompatiblePredicate const &	eq
	)		const

template<class K, class T, class H, class P, class A>

allocator_type boost::unordered::unordered_map< K, T, H, P, A >::get_allocator ( void  ) const

inline

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::hasher boost::unordered::unordered_map< K, T, H, P, A >::hash_function

(

)

const

template<class K, class T, class H, class P, class A>

std::pair<iterator, bool> boost::unordered::unordered_map< K, T, H, P, A >::insert ( value_type const &  x )

inline

Referenced by boost::spirit::qi::tst_map< Char, T >::add(), boost::interprocess::ipcdetail::sync_handles::obtain_mutex(), and boost::interprocess::ipcdetail::sync_handles::obtain_semaphore().

template<class K, class T, class H, class P, class A>

std::pair<iterator, bool> boost::unordered::unordered_map< K, T, H, P, A >::insert ( BOOST_RV_REF(value_type)  x )

inline

template<class K, class T, class H, class P, class A>

iterator boost::unordered::unordered_map< K, T, H, P, A >::insert ( const_iterator  hint, value_type const &  x  )

inline

template<class K, class T, class H, class P, class A>

iterator boost::unordered::unordered_map< K, T, H, P, A >::insert ( const_iterator  hint, BOOST_RV_REF(value_type)  x  )

inline

template<class K , class T , class H , class P , class A >

template<class InputIt >

void boost::unordered::unordered_map< K, T, H, P, A >::insert	(	InputIt	first,
		InputIt	last
	)

template<class K , class T , class H , class P , class A >

void boost::unordered::unordered_map< K, T, H, P, A >::insert

(

std::initializer_list< value_type >

list

)

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::key_equal boost::unordered::unordered_map< K, T, H, P, A >::key_eq

(

)

const

template<class K , class T , class H , class P , class A >

float boost::unordered::unordered_map< K, T, H, P, A >::load_factor

(

)

const

template<class K, class T, class H, class P, class A>

size_type boost::unordered::unordered_map< K, T, H, P, A >::max_bucket_count ( ) const

inline

template<class K, class T, class H, class P, class A>

float boost::unordered::unordered_map< K, T, H, P, A >::max_load_factor ( ) const

inline

template<class K , class T , class H , class P , class A >

void boost::unordered::unordered_map< K, T, H, P, A >::max_load_factor

(

float

m

)

template<class K , class T , class H , class P , class A >

std::size_t boost::unordered::unordered_map< K, T, H, P, A >::max_size

(

void

)

const

template<class K, class T, class H, class P, class A>

unordered_map& boost::unordered::unordered_map< K, T, H, P, A >::operator= ( unordered_map< K, T, H, P, A > const &  x )

inline

template<class K, class T, class H, class P, class A>

unordered_map& boost::unordered::unordered_map< K, T, H, P, A >::operator= ( unordered_map< K, T, H, P, A > &&  x )

inline

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A > & boost::unordered::unordered_map< K, T, H, P, A >::operator=

(

std::initializer_list< value_type >

list

)

References boost::unordered::unordered_map< K, T, H, P, A >::clear().

template<class K , class T , class H , class P , class A >

unordered_map< K, T, H, P, A >::mapped_type & boost::unordered::unordered_map< K, T, H, P, A >::operator[]

(

const key_type &

k

)

template<class K, class T, class H, class P, class A>

void boost::unordered::unordered_map< K, T, H, P, A >::quick_erase ( const_iterator  it )

inline

template<class K , class T , class H , class P , class A >

void boost::unordered::unordered_map< K, T, H, P, A >::rehash

(

size_type

n

)

Referenced by boost::interprocess::unordered_map_index< MapConfig >::reserve(), and boost::interprocess::unordered_map_index< MapConfig >::shrink_to_fit().

template<class K , class T , class H , class P , class A >

void boost::unordered::unordered_map< K, T, H, P, A >::reserve

(

size_type

n

)

template<class K, class T, class H, class P, class A>

size_type boost::unordered::unordered_map< K, T, H, P, A >::size ( void  ) const

inline

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

template<class K , class T , class H , class P , class A >

void boost::unordered::unordered_map< K, T, H, P, A >::swap

(

unordered_map< K, T, H, P, A > &

other

)

Referenced by boost::unordered::swap().

Friends And Related Function Documentation

template<class K, class T, class H, class P, class A>

bool operator!= ( unordered_map< K, T, H, P, A > const &  , unordered_map< K, T, H, P, A > const &    )

friend

template<class K, class T, class H, class P, class A>

bool operator== ( unordered_map< K, T, H, P, A > const &  , unordered_map< K, T, H, P, A > const &    )

friend

---

The documentation for this singleton was generated from the following file:

• boost_1_57_0/boost/unordered/unordered_map.hpp