STLdoc: stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc > Class Template Reference

STLdoc

STLdocumentation

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros

Inheritance diagram for stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >:

Public Types
typedef hash_multimap< _Kty, _Ty, _Tr, _Alloc >	_Myt

typedef _Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, true > >	_Mybase

typedef _Kty	key_type

typedef _Ty	mapped_type

typedef _Ty	referent_type

typedef _Tr	key_compare

typedef _Mybase::value_compare	value_compare

typedef _Mybase::allocator_type	allocator_type

typedef _Mybase::size_type	size_type

typedef _Mybase::difference_type	difference_type

typedef _Mybase::pointer	pointer

typedef _Mybase::const_pointer	const_pointer

typedef _Mybase::reference	reference

typedef _Mybase::const_reference	const_reference

typedef _Mybase::iterator	iterator

typedef _Mybase::const_iterator	const_iterator

typedef _Mybase::reverse_iterator	reverse_iterator

typedef _Mybase::const_reverse_iterator	const_reverse_iterator

typedef _Mybase::value_type	value_type

Public Types inherited from _Hash< _Traits >
enum	{ _Bucket_size = key_compare::bucket_size, _Min_buckets = 8, _Multi = _Traits::_Multi }

typedef _Hash< _Traits >	_Myt

typedef _Traits::key_type	key_type

typedef _Traits::key_compare	key_compare

typedef _Traits::value_compare	value_compare

typedef list< typename _Traits::value_type, typename _Traits::allocator_type >	_Mylist

typedef _Mylist::_Alty	_Alty

typedef _Mylist::value_type	value_type

typedef _Mylist::allocator_type	allocator_type

typedef _Mylist::size_type	size_type

typedef _Mylist::difference_type	difference_type

typedef _Mylist::pointer	pointer

typedef _Mylist::const_pointer	const_pointer

typedef _Mylist::reference	reference

typedef _Mylist::const_reference	const_reference

typedef _If< is_same< key_type, value_type >::value, typename _Mylist::const_iterator, typename _Mylist::iterator >::type	iterator

typedef _Mylist::const_iterator	const_iterator

typedef _If< is_same< key_type, value_type >::value, typename _Mylist::_Unchecked_const_iterator, typename _Mylist::_Unchecked_iterator >::type	_Unchecked_iterator

typedef _Mylist::_Unchecked_const_iterator	_Unchecked_const_iterator

typedef _STD reverse_iterator< iterator >	reverse_iterator

typedef _STD reverse_iterator< const_iterator >	const_reverse_iterator

typedef vector< _Unchecked_iterator, typename _Alty::template rebind< _Unchecked_iterator >::other >	_Myvec

typedef pair< iterator, bool >	_Pairib

typedef pair< iterator, iterator >	_Pairii

typedef pair< const_iterator, const_iterator >	_Paircc

typedef iterator	local_iterator

typedef const_iterator	const_local_iterator

Public Member Functions
	hash_multimap ()

	hash_multimap (const allocator_type &_Al)

	hash_multimap (const _Myt &_Right)

	hash_multimap (const _Myt &_Right, const allocator_type &_Al)

	hash_multimap (const key_compare &_Traits)

	hash_multimap (const key_compare &_Traits, const allocator_type &_Al)

template<class _Iter >
	hash_multimap (_Iter _First, _Iter _Last)

template<class _Iter >
	hash_multimap (_Iter _First, _Iter _Last, const key_compare &_Traits)

template<class _Iter >
	hash_multimap (_Iter _First, _Iter _Last, const key_compare &_Traits, const allocator_type &_Al)

_Myt &	operator= (const _Myt &_Right)

	hash_multimap (_Myt &&_Right)

	hash_multimap (_Myt &&_Right, const allocator_type &_Al)

_Myt &	operator= (_Myt &&_Right)

template<class _Valty >
enable_if< is_convertible< _Valty, value_type >::value, iterator >::type	insert (_Valty &&_Val)

template<class _Valty >
enable_if< is_convertible< _Valty, value_type >::value, iterator >::type	insert (const_iterator _Where, _Valty &&_Val)

void	swap (_Myt &_Right)

	hash_multimap (_XSTD initializer_list< value_type > _Ilist)

	hash_multimap (_XSTD initializer_list< value_type > _Ilist, const key_compare &_Pred)

	hash_multimap (_XSTD initializer_list< value_type > _Ilist, const key_compare &_Pred, const allocator_type &_Al)

_Myt &	operator= (_XSTD initializer_list< value_type > _Ilist)

void	insert (_XSTD initializer_list< value_type > _Ilist)

iterator	insert (const value_type &_Val)

iterator	insert (const_iterator _Where, const value_type &_Val)

template<class _Iter >
void	insert (_Iter _First, _Iter _Last)

Public Member Functions inherited from _Hash< _Traits >
	_Hash (const key_compare &_Parg, const allocator_type &_Al)

	_Hash (const value_type _First, const value_type _Last, const key_compare &_Parg, const allocator_type &_Al)

	_Hash (const _Myt &_Right, const allocator_type &_Al)

	_Hash (_Myt &&_Right, const allocator_type &_Al)

_Myt &	operator= (_Myt &&_Right)

void	_Assign_rv (_Myt &&_Right)

_Pairib	insert (value_type &&_Val)

iterator	insert (const_iterator, value_type &&_Val)

template<class _Valty >
enable_if< is_convertible< _Valty, value_type >::value, _Pairib >::type	insert (_Valty &&_Val)

template<class _Valty >
enable_if< is_convertible< _Valty, value_type >::value, iterator >::type	insert (const_iterator, _Valty &&_Val)

template<class... _Valty>
_Pairib	emplace (_Valty &&..._Val)

template<class... _Valty>
iterator	emplace_hint (const_iterator, _Valty &&..._Val)

	~_Hash () _NOEXCEPT

_Myt &	operator= (const _Myt &_Right)

iterator	begin () _NOEXCEPT

const_iterator	begin () const _NOEXCEPT

iterator	end () _NOEXCEPT

const_iterator	end () const _NOEXCEPT

_Unchecked_iterator	_Unchecked_begin ()

_Unchecked_const_iterator	_Unchecked_begin () const

_Unchecked_iterator	_Unchecked_end ()

_Unchecked_const_iterator	_Unchecked_end () const

iterator	_Make_iter (_Unchecked_const_iterator _Where) const

iterator	_Make_iter (const_iterator _Where) const

reverse_iterator	rbegin () _NOEXCEPT

const_reverse_iterator	rbegin () const _NOEXCEPT

reverse_iterator	rend () _NOEXCEPT

const_reverse_iterator	rend () const _NOEXCEPT

const_iterator	cbegin () const _NOEXCEPT

const_iterator	cend () const _NOEXCEPT

const_reverse_iterator	crbegin () const _NOEXCEPT

const_reverse_iterator	crend () const _NOEXCEPT

size_type	size () const _NOEXCEPT

size_type	max_size () const _NOEXCEPT

bool	empty () const _NOEXCEPT

allocator_type	get_allocator () const _NOEXCEPT

key_compare	key_comp () const

value_compare	value_comp () const

size_type	bucket_count () const _NOEXCEPT

size_type	max_bucket_count () const _NOEXCEPT

size_type	bucket (const key_type &_Keyval) const

size_type	bucket_size (size_type _Bucket) const

local_iterator	begin (size_type _Bucket)

const_local_iterator	begin (size_type _Bucket) const

local_iterator	end (size_type _Bucket)

const_local_iterator	end (size_type _Bucket) const

const_local_iterator	cbegin (size_type _Bucket) const _NOEXCEPT

const_local_iterator	cend (size_type _Bucket) const _NOEXCEPT

float	load_factor () const _NOEXCEPT

float	max_load_factor () const _NOEXCEPT

void	max_load_factor (float _Newmax)

void	rehash (size_type _Buckets)

void	reserve (size_type _Maxcount)

_Pairib	insert (const value_type &_Val)

iterator	insert (const_iterator, const value_type &_Val)

template<class _Iter >
void	insert (_Iter _First, _Iter _Last)

void	insert (_XSTD initializer_list< value_type > _Ilist)

iterator	erase (const_iterator _Plist)

iterator	erase (const_iterator _First, const_iterator _Last)

size_type	erase (const key_type &_Keyval)

void	clear () _NOEXCEPT

iterator	find (const key_type &_Keyval)

const_iterator	find (const key_type &_Keyval) const

size_type	count (const key_type &_Keyval) const

iterator	lower_bound (const key_type &_Keyval)

const_iterator	lower_bound (const key_type &_Keyval) const

iterator	upper_bound (const key_type &_Keyval)

const_iterator	upper_bound (const key_type &_Keyval) const

_Pairii	equal_range (const key_type &_Keyval)

_Paircc	equal_range (const key_type &_Keyval) const

void	swap (_Myt &_Right)

Additional Inherited Members
Protected Member Functions inherited from _Hash< _Traits >
template<class _Valty >
_Unchecked_iterator	_Buynode_if_nil (_Valty &&, _Unchecked_iterator _Plist)

template<class _Valty >
_Unchecked_iterator	_Buynode_if_nil (_Valty &&_Val, _Nil)

void	_Destroy_if_not_nil (_Unchecked_iterator _Plist)

void	_Destroy_if_not_nil (_Nil)

template<class _Valty , class _Nodety >
_Pairib	_Insert (_Valty &&_Val, _Nodety _Pnode)

_Unchecked_iterator &	_Vec_lo (size_type _Bucket)

_Unchecked_const_iterator &	_Vec_lo (size_type _Bucket) const

_Unchecked_iterator &	_Vec_hi (size_type _Bucket)

_Unchecked_const_iterator &	_Vec_hi (size_type _Bucket) const

_Unchecked_iterator	_Begin (size_type _Bucket)

_Unchecked_const_iterator	_Begin (size_type _Bucket) const

_Unchecked_iterator	_End (size_type _Bucket)

_Unchecked_const_iterator	_End (size_type _Bucket) const

void	_Erase_bucket (iterator _Plist_arg, size_type _Bucket)

void	_Insert_bucket (_Unchecked_iterator _Plist, _Unchecked_iterator _Where, size_type _Bucket)

void	_Copy (const _Myt &_Right)

size_type	_Hashval (const key_type &_Keyval) const

void	_Init (size_type _Buckets=_Min_buckets)

void	_Check_size ()

void	_Reinsert ()

Protected Attributes inherited from _Hash< _Traits >
_Mylist	_List

_Myvec	_Vec

size_type	_Mask

size_type	_Maxidx

float	_Max_bucket_size

Member Typedef Documentation

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Hash<_Hmap_traits<_Kty, _Ty, _Tr, _Alloc, true> > stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::_Mybase

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef hash_multimap<_Kty, _Ty, _Tr, _Alloc> stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::_Myt

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::allocator_type stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::allocator_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_iterator stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::const_iterator

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_pointer stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::const_pointer

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_reference stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::const_reference

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::const_reverse_iterator stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::const_reverse_iterator

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::difference_type stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::difference_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::iterator stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::iterator

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Tr stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::key_compare

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Kty stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::key_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Ty stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::mapped_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::pointer stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::pointer

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::reference stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::reference

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Ty stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::referent_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::reverse_iterator stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::reverse_iterator

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::size_type stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::size_type

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::value_compare stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::value_compare

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

typedef _Mybase::value_type stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::value_type

Constructor & Destructor Documentation

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( )

inline

         : _Mybase(key_compare(), allocator_type())
         {   // construct empty map from defaults
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( const allocator_type & _Al )

inlineexplicit

         : _Mybase(key_compare(), _Al)
         {   // construct empty map from defaults, allocator
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( const _Myt & _Right )

inline

         : _Mybase(_Right,
             _Right._List._Getal().select_on_container_copy_construction())
 
 
         {   // construct map by copying _Right
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap	(	const _Myt &	_Right,
		const allocator_type &	_Al
	)

inline

         : _Mybase(_Right, _Al)
         {   // construct map by copying _Right, allocator
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( const key_compare & _Traits )

inlineexplicit

         : _Mybase(_Traits, allocator_type())
         {   // construct empty map from comparator
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap	(	const key_compare &	_Traits,
		const allocator_type &	_Al
	)

inline

         : _Mybase(_Traits, _Al)
         {   // construct empty map from comparator and allocator
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap	(	_Iter	_First,
		_Iter	_Last
	)

inline

         : _Mybase(key_compare(), allocator_type())
         {   // construct map from sequence, defaults
         _Mybase::insert(_First, _Last);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap	(	_Iter	_First,
		_Iter	_Last,
		const key_compare &	_Traits
	)

inline

         : _Mybase(_Traits, allocator_type())
         {   // construct map from sequence, comparator
         _Mybase::insert(_First, _Last);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap	(	_Iter	_First,
		_Iter	_Last,
		const key_compare &	_Traits,
		const allocator_type &	_Al
	)

inline

         : _Mybase(_Traits, _Al)
         {   // construct map from sequence, comparator, and allocator
         _Mybase::insert(_First, _Last);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _Myt && _Right )

inline

         : _Mybase(_STD move(_Right), _Right._List._Getal())
         {   // construct map by moving _Right
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap	(	_Myt &&	_Right,
		const allocator_type &	_Al
	)

inline

         : _Mybase(_STD move(_Right), _Al)
         {   // construct map by moving _Right, allocator
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap ( _XSTD initializer_list< value_type > _Ilist )

inline

         : _Mybase(key_compare(), allocator_type())
         {   // construct from initializer_list, defaults
         this->insert(_Ilist.begin(), _Ilist.end());
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap	(	_XSTD initializer_list< value_type >	_Ilist,
		const key_compare &	_Pred
	)

inline

         : _Mybase(_Pred, allocator_type())
         {   // construct from initializer_list, comparator
         this->insert(_Ilist.begin(), _Ilist.end());
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::hash_multimap	(	_XSTD initializer_list< value_type >	_Ilist,
		const key_compare &	_Pred,
		const allocator_type &	_Al
	)

inline

         : _Mybase(_Pred, _Al)
         {   // construct from initializer_list, comparator, and allocator
         this->insert(_Ilist.begin(), _Ilist.end());
         }

Member Function Documentation

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Valty >

enable_if<is_convertible<_Valty, value_type>::value, iterator>::type stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::insert ( _Valty && _Val )

inline

         {   // insert a {key, mapped} value
         return (_Mybase::insert(_STD forward<_Valty>(_Val)).first);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Valty >

enable_if<is_convertible<_Valty, value_type>::value, iterator>::type stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::insert	(	const_iterator	_Where,
		_Valty &&	_Val
	)

inline

         {   // insert a {key, mapped} value, with hint
         return (_Mybase::insert(_Where, _STD forward<_Valty>(_Val)));
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

void stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::insert ( _XSTD initializer_list< value_type > _Ilist )

inline

         {   // insert initializer_list
         this->insert(_Ilist.begin(), _Ilist.end());
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

iterator stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::insert ( const value_type & _Val )

inline

         {   // insert a {key, mapped} value
         return (_Mybase::insert(_Val).first);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

iterator stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::insert	(	const_iterator	_Where,
		const value_type &	_Val
	)

inline

         {   // insert a {key, mapped} value, with hint
         return (_Mybase::insert(_Where, _Val));
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

template<class _Iter >

void stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::insert	(	_Iter	_First,
		_Iter	_Last
	)

inline

         {   // insert [_First, _Last), arbitrary iterators
         _Mybase::insert(_First, _Last);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::operator= ( const _Myt & _Right )

inline

         {   // assign by copying _Right
         _Mybase::operator=(_Right);
         return (*this);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::operator= ( _Myt && _Right )

inline

         {   // assign by moving _Right
         _Mybase::operator=(_STD move(_Right));
         return (*this);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

_Myt& stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::operator= ( _XSTD initializer_list< value_type > _Ilist )

inline

         {   // assign initializer_list
         this->clear();
         this->insert(_Ilist.begin(), _Ilist.end());
         return (*this);
         }

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>

void stdext::hash_multimap< _Kty, _Ty, _Tr, _Alloc >::swap ( _Myt & _Right )

inline

         {   // exchange contents with non-movable _Right
         _Mybase::swap(_Right);
         }

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

VS2013/inc/hash_map