BDE 4.14.0 Production release: bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > Class Template Reference

BDE 4.14.0 Production release

Loading...

Searching...

No Matches

#include <bslstp_hashmap.h>

Public Types
typedef _Ht::key_type	key_type

typedef _Tp	data_type

typedef _Tp	mapped_type

typedef _Ht::value_type	_value_type

typedef _Ht::value_type	value_type

typedef _Ht::hasher	hasher

typedef _Ht::key_equal	key_equal

typedef _Ht::size_type	size_type

typedef _Ht::difference_type	difference_type

typedef _Ht::pointer	pointer

typedef _Ht::const_pointer	const_pointer

typedef _Ht::reference	reference

typedef _Ht::const_reference	const_reference

typedef _Ht::iterator	iterator

typedef _Ht::const_iterator	const_iterator

typedef _Ht::allocator_type	allocator_type

Public Member Functions
hasher	hash_funct () const

key_equal	key_eq () const

allocator_type	get_allocator () const

	hash_map ()

	hash_map (size_type __n)

	hash_map (size_type __n, const hasher &__hf)

	hash_map (const allocator_type &__a)

	hash_map (size_type __n, const allocator_type &__a)

	hash_map (size_type __n, const hasher &__hf, const allocator_type &__a)

	hash_map (size_type __n, const hasher &__hf, const key_equal &__eql, const allocator_type &__a=allocator_type())

template<class _InputIterator >
	hash_map (_InputIterator __f, _InputIterator __l)

template<class _InputIterator >
	hash_map (_InputIterator __f, _InputIterator __l, size_type __n)

template<class _InputIterator >
	hash_map (_InputIterator __f, _InputIterator __l, size_type __n, const hasher &__hf)

template<class _InputIterator >
	hash_map (_InputIterator __f, _InputIterator __l, const allocator_type &__a)

template<class _InputIterator >
	hash_map (_InputIterator __f, _InputIterator __l, size_type __n, const allocator_type &__a)

template<class _InputIterator >
	hash_map (_InputIterator __f, _InputIterator __l, size_type __n, const hasher &__hf, const allocator_type &__a)

template<class _InputIterator >
	hash_map (_InputIterator __f, _InputIterator __l, size_type __n, const hasher &__hf, const key_equal &__eql, const allocator_type &__a=allocator_type())

	hash_map (const _Self &__x, const allocator_type &__a)

size_type	size () const

size_type	max_size () const

bool	empty () const

void	swap (_Self &__hs)

iterator	begin ()

iterator	end ()

const_iterator	begin () const

const_iterator	end () const

pair< iterator, bool >	insert (const value_type &__obj)

template<class _InputIterator >
void	insert (_InputIterator __f, _InputIterator __l)

pair< iterator, bool >	insert_noresize (const value_type &__obj)

iterator	find (const key_type &__key)

const_iterator	find (const key_type &__key) const

_Tp &	operator[] (const key_type &__key)

size_type	count (const key_type &__key) const

pair< iterator, iterator >	equal_range (const key_type &__key)

pair< const_iterator, const_iterator >	equal_range (const key_type &__key) const

size_type	erase (const key_type &__key)

void	erase (iterator __it)

void	erase (iterator __f, iterator __l)

void	clear ()

void	resize (size_type __hint)

size_type	bucket_count () const

size_type	max_bucket_count () const

size_type	elems_in_bucket (size_type __n) const

Static Public Member Functions
static bool	_M_equal (const _Self &__x, const _Self &__y)

Member Typedef Documentation

◆ _value_type

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::value_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::_value_type

◆ allocator_type

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::allocator_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::allocator_type

◆ const_iterator

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::const_iterator bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::const_iterator

◆ const_pointer

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::const_pointer bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::const_pointer

◆ const_reference

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::const_reference bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::const_reference

◆ data_type

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Tp bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::data_type

◆ difference_type

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::difference_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::difference_type

◆ hasher

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::hasher bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hasher

◆ iterator

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::iterator bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::iterator

◆ key_equal

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::key_equal bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::key_equal

◆ key_type

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::key_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::key_type

◆ mapped_type

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Tp bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::mapped_type

◆ pointer

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::pointer bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::pointer

◆ reference

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::reference bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::reference

◆ size_type

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::size_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::size_type

◆ value_type

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

typedef _Ht::value_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::value_type

Constructor & Destructor Documentation

◆ hash_map() [1/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map ( )

inline

◆ hash_map() [2/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map ( size_type __n )

inlineexplicit

◆ hash_map() [3/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	size_type	__n,
		const hasher &	__hf
	)

inline

◆ hash_map() [4/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map ( const allocator_type & __a )

inlineexplicit

◆ hash_map() [5/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	size_type	__n,
		const allocator_type &	__a
	)

inline

◆ hash_map() [6/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	size_type	__n,
		const hasher &	__hf,
		const allocator_type &	__a
	)

inline

◆ hash_map() [7/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	size_type	__n,
		const hasher &	__hf,
		const key_equal &	__eql,
		const allocator_type &	__a = `allocator_type()`
	)

inline

◆ hash_map() [8/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

template<class _InputIterator >

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	_InputIterator	__f,
		_InputIterator	__l
	)

inline

◆ hash_map() [9/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

template<class _InputIterator >

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	_InputIterator	__f,
		_InputIterator	__l,
		size_type	__n
	)

inline

◆ hash_map() [10/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

template<class _InputIterator >

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	_InputIterator	__f,
		_InputIterator	__l,
		size_type	__n,
		const hasher &	__hf
	)

inline

◆ hash_map() [11/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

template<class _InputIterator >

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	_InputIterator	__f,
		_InputIterator	__l,
		const allocator_type &	__a
	)

inline

◆ hash_map() [12/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

template<class _InputIterator >

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	_InputIterator	__f,
		_InputIterator	__l,
		size_type	__n,
		const allocator_type &	__a
	)

inline

◆ hash_map() [13/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

template<class _InputIterator >

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	_InputIterator	__f,
		_InputIterator	__l,
		size_type	__n,
		const hasher &	__hf,
		const allocator_type &	__a
	)

inline

◆ hash_map() [14/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

template<class _InputIterator >

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	_InputIterator	__f,
		_InputIterator	__l,
		size_type	__n,
		const hasher &	__hf,
		const key_equal &	__eql,
		const allocator_type &	__a = `allocator_type()`
	)

inline

◆ hash_map() [15/15]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_map	(	const _Self &	__x,
		const allocator_type &	__a
	)

inline

Member Function Documentation

◆ _M_equal()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

static bool bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::_M_equal	(	const _Self &	__x,
		const _Self &	__y
	)

inlinestatic

◆ begin() [1/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

iterator bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::begin ( )

inline

◆ begin() [2/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

const_iterator bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::begin ( ) const

inline

◆ bucket_count()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

size_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::bucket_count ( ) const

inline

◆ clear()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

void bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::clear ( )

inline

◆ count()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

size_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::count ( const key_type & __key ) const

inline

◆ elems_in_bucket()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

size_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::elems_in_bucket ( size_type __n ) const

inline

◆ empty()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

bool bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::empty ( ) const

inline

◆ end() [1/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

iterator bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::end ( )

inline

◆ end() [2/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

const_iterator bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::end ( ) const

inline

◆ equal_range() [1/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

pair< iterator, iterator > bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::equal_range ( const key_type & __key )

inline

◆ equal_range() [2/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

pair< const_iterator, const_iterator > bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::equal_range ( const key_type & __key ) const

inline

◆ erase() [1/3]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

size_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::erase ( const key_type & __key )

inline

◆ erase() [2/3]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

void bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::erase	(	iterator	__f,
		iterator	__l
	)

inline

◆ erase() [3/3]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

void bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::erase ( iterator __it )

inline

◆ find() [1/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

iterator bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::find ( const key_type & __key )

inline

◆ find() [2/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

const_iterator bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::find ( const key_type & __key ) const

inline

◆ get_allocator()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

allocator_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::get_allocator ( ) const

inline

◆ hash_funct()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

hasher bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::hash_funct ( ) const

inline

◆ insert() [1/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

template<class _InputIterator >

void bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::insert	(	_InputIterator	__f,
		_InputIterator	__l
	)

inline

◆ insert() [2/2]

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

pair< iterator, bool > bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::insert ( const value_type & __obj )

inline

◆ insert_noresize()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

pair< iterator, bool > bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::insert_noresize ( const value_type & __obj )

inline

◆ key_eq()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

key_equal bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::key_eq ( ) const

inline

◆ max_bucket_count()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

size_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::max_bucket_count ( ) const

inline

◆ max_size()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

size_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::max_size ( ) const

inline

◆ operator[]()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

_Tp & bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::operator[] ( const key_type & __key )

inline

◆ resize()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

void bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::resize ( size_type __hint )

inline

◆ size()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

size_type bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::size ( ) const

inline

◆ swap()

template<class _Key , class _Tp , class _HashFcn = typename ::BloombergLP::bslstp::HashSelector<_Key>::Type, class _EqualKey = typename bsl::ComparatorSelector<_Key>::Type, class _Alloc = bsl::allocator< pair < const _Key, _Tp > >>

void bsl::hash_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc >::swap ( _Self & __hs )

inline

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

bslstp_hashmap.h

bsl
hash_map
Generated by 1.9.8