STLdoc
STLdocumentation
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Public Types | Public Member Functions | List of all members
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc > Class Template Reference
Inheritance diagram for unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >:
_Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true > >

Public Types

typedef unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc > _Myt
 
typedef _Uhash_compare< _Kty, _Hasher, _Keyeq > _Mytraits
 
typedef _Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
 
typedef _Hasher hasher
 
typedef _Kty key_type
 
typedef _Ty mapped_type
 
typedef _Keyeq key_equal
 
typedef _Mytraits key_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::value_type value_type
 
typedef _Mybase::iterator local_iterator
 
typedef _Mybase::const_iterator const_local_iterator
 
typedef _Mybase::_Alty _Alty
 
- Public Types inherited from _Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true > >
enum  
 
typedef _Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true > > _Myt
 
typedef _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true >::key_type key_type
 
typedef _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true >::key_compare key_compare
 
typedef _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true >::value_compare value_compare
 
typedef list< typename _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true >::value_type, typename _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true >::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 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

 unordered_multimap ()
 
 unordered_multimap (const allocator_type &_Al)
 
 unordered_multimap (const _Myt &_Right)
 
 unordered_multimap (const _Myt &_Right, const allocator_type &_Al)
 
 unordered_multimap (size_type _Buckets)
 
 unordered_multimap (size_type _Buckets, const hasher &_Hasharg)
 
 unordered_multimap (size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg)
 
 unordered_multimap (size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg, const allocator_type &_Al)
 
template<class _Iter >
 unordered_multimap (_Iter _First, _Iter _Last)
 
template<class _Iter >
 unordered_multimap (_Iter _First, _Iter _Last, size_type _Buckets)
 
template<class _Iter >
 unordered_multimap (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg)
 
template<class _Iter >
 unordered_multimap (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg)
 
template<class _Iter >
 unordered_multimap (_Iter _First, _Iter _Last, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg, const allocator_type &_Al)
 
_Mytoperator= (const _Myt &_Right)
 
 unordered_multimap (_Myt &&_Right)
 
 unordered_multimap (_Myt &&_Right, const allocator_type &_Al)
 
_Mytoperator= (_Myt &&_Right) _NOEXCEPT_OP(_Alty
 
template<class... _Valty>
iterator emplace (_Valty &&..._Val)
 
void swap (_Myt &_Right) _NOEXCEPT_OP(_Alty
 
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator insert (_Valty &&_Val)
 
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator insert (const_iterator _Where, _Valty &&_Val)
 
 unordered_multimap (_XSTD initializer_list< value_type > _Ilist)
 
 unordered_multimap (_XSTD initializer_list< value_type > _Ilist, size_type _Buckets)
 
 unordered_multimap (_XSTD initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg)
 
 unordered_multimap (_XSTD initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg)
 
 unordered_multimap (_XSTD initializer_list< value_type > _Ilist, size_type _Buckets, const hasher &_Hasharg, const _Keyeq &_Keyeqarg, const allocator_type &_Al)
 
_Mytoperator= (_XSTD initializer_list< value_type > _Ilist)
 
hasher hash_function () const
 
key_equal key_eq () const
 
- Public Member Functions inherited from _Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true > >
 _Hash (const key_compare &_Parg, const allocator_type &_Al)
 
 _Hash (const _Myt &_Right, const _Any_alloc &_Al)
 
 _Hash (_Myt &&_Right)
 
 _Hash (_Myt &&_Right, const allocator_type &_Al)
 
_Mytoperator= (_Myt &&_Right)
 
_Mytoperator= (const _Myt &_Right)
 
void _Assign_rv (_Myt &&_Right)
 
_Pairib emplace (_Valty &&..._Val)
 
iterator emplace_hint (const_iterator, _Valty &&..._Val)
 
 ~_Hash () _NOEXCEPT
 
iterator begin () _NOEXCEPT
 
const_iterator begin () const _NOEXCEPT
 
local_iterator begin (size_type _Bucket)
 
const_local_iterator begin (size_type _Bucket) const
 
iterator end () _NOEXCEPT
 
const_iterator end () const _NOEXCEPT
 
local_iterator end (size_type _Bucket)
 
const_local_iterator end (size_type _Bucket) const
 
_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
 
const_iterator cbegin () const _NOEXCEPT
 
const_local_iterator cbegin (size_type _Bucket) const
 
const_iterator cend () const _NOEXCEPT
 
const_local_iterator cend (size_type _Bucket) const
 
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
 
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 value_type &_Val)
 
_Pairib insert (value_type &&_Val)
 
iterator insert (value_type &&_Val)
 
iterator insert (const_iterator, const value_type &_Val)
 
iterator insert (const_iterator, value_type &&_Val)
 
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< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true > >
_Unchecked_iterator _Buynode_if_nil (_Valty &&, _Unchecked_iterator _Plist)
 
_Unchecked_iterator _Buynode_if_nil (_Valty &&_Val, _Nil)
 
void _Destroy_if_not_nil (_Unchecked_iterator _Plist)
 
void _Destroy_if_not_nil (_Nil)
 
_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 ()
 
float & _Max_bucket_size () _NOEXCEPT
 
const float & _Max_bucket_size () const _NOEXCEPT
 
- Protected Attributes inherited from _Hash< _Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true > >
_Umap_traits< _Kty, _Ty, _Uhash_compare< _Kty, _Hasher, _Keyeq >, _Alloc, true_Traitsobj
 
_Mylist _List
 
_Myvec _Vec
 
size_type _Mask
 
size_type _Maxidx
 

Member Typedef Documentation

template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::_Alty unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Alty
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Hash<_Umap_traits<_Kty, _Ty, _Mytraits, _Alloc, true> > unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Mybase
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef unordered_multimap<_Kty, _Ty, _Hasher, _Keyeq, _Alloc> unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Myt
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Uhash_compare<_Kty, _Hasher, _Keyeq> unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::_Mytraits
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::allocator_type unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::allocator_type
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::const_iterator unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::const_iterator
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::const_iterator unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::const_local_iterator
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::const_pointer unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::const_pointer
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::const_reference unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::const_reference
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::difference_type unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::difference_type
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Hasher unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::hasher
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::iterator unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::iterator
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mytraits unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::key_compare
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Keyeq unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::key_equal
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Kty unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::key_type
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::iterator unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::local_iterator
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Ty unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::mapped_type
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::pointer unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::pointer
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::reference unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::reference
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::size_type unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::size_type
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
typedef _Mybase::value_type unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::value_type

Constructor & Destructor Documentation

template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( )
inline
512  { // construct empty map from defaults
513  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( const allocator_type _Al)
inlineexplicit
516  : _Mybase(key_compare(), _Al)
517  { // construct empty map from defaults, allocator
518  }
_Mytraits key_compare
Definition: unordered_map:491
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( const _Myt _Right)
inline
521  : _Mybase(_Right,
522  _Right._List._Getal().select_on_container_copy_construction())
523  { // construct map by copying _Right
524  }
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( const _Myt _Right,
const allocator_type _Al 
)
inline
527  : _Mybase(_Right, _Al)
528  { // construct map by copying _Right, allocator
529  }
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( size_type  _Buckets)
inlineexplicit
533  { // construct empty map from defaults, ignore initial size
534  _Mybase::rehash(_Buckets);
535  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( size_type  _Buckets,
const hasher _Hasharg 
)
inline
538  : _Mybase(key_compare(_Hasharg), allocator_type())
539  { // construct empty map from hasher
540  _Mybase::rehash(_Buckets);
541  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( size_type  _Buckets,
const hasher _Hasharg,
const _Keyeq &  _Keyeqarg 
)
inline
545  : _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
546  { // construct empty map from hasher and equality comparator
547  _Mybase::rehash(_Buckets);
548  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( size_type  _Buckets,
const hasher _Hasharg,
const _Keyeq &  _Keyeqarg,
const allocator_type _Al 
)
inline
552  : _Mybase(key_compare(_Hasharg, _Keyeqarg), _Al)
553  { // construct empty map from hasher and equality comparator
554  _Mybase::rehash(_Buckets);
555  }
_Mytraits key_compare
Definition: unordered_map:491
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Iter >
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _Iter  _First,
_Iter  _Last 
)
inline
560  { // construct map from sequence, defaults
561  insert(_First, _Last);
562  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
_FwdIt _Last
Definition: algorithm:1936
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Iter >
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _Iter  _First,
_Iter  _Last,
size_type  _Buckets 
)
inline
568  { // construct map from sequence, defaults, ignore initial size
569  _Mybase::rehash(_Buckets);
570  insert(_First, _Last);
571  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
_FwdIt _Last
Definition: algorithm:1936
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Iter >
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _Iter  _First,
_Iter  _Last,
size_type  _Buckets,
const hasher _Hasharg 
)
inline
576  : _Mybase(key_compare(_Hasharg), allocator_type())
577  { // construct map from sequence, comparator
578  _Mybase::rehash(_Buckets);
579  insert(_First, _Last);
580  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
_FwdIt _Last
Definition: algorithm:1936
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Iter >
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _Iter  _First,
_Iter  _Last,
size_type  _Buckets,
const hasher _Hasharg,
const _Keyeq &  _Keyeqarg 
)
inline
586  : _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
587  { // construct map from sequence, comparator, and allocator
588  _Mybase::rehash(_Buckets);
589  insert(_First, _Last);
590  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
_FwdIt _Last
Definition: algorithm:1936
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Iter >
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _Iter  _First,
_Iter  _Last,
size_type  _Buckets,
const hasher _Hasharg,
const _Keyeq &  _Keyeqarg,
const allocator_type _Al 
)
inline
596  : _Mybase(key_compare(_Hasharg, _Keyeqarg), _Al)
597  { // construct map from sequence, comparator, and allocator
598  _Mybase::rehash(_Buckets);
599  insert(_First, _Last);
600  }
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
_FwdIt _Last
Definition: algorithm:1936
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _Myt &&  _Right)
inline
609  : _Mybase(_STD move(_Right))
610  { // construct map by moving _Right
611  }
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
constexpr remove_reference< _Ty >::type && move(_Ty &&_Arg) _NOEXCEPT
Definition: type_traits:1290
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _Myt &&  _Right,
const allocator_type _Al 
)
inline
614  : _Mybase(_STD move(_Right), _Al)
615  { // construct map by moving _Right, allocator
616  }
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
constexpr remove_reference< _Ty >::type && move(_Ty &&_Arg) _NOEXCEPT
Definition: type_traits:1290
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _XSTD initializer_list< value_type _Ilist)
inline
659  { // construct map from initializer_list, defaults
660  insert(_Ilist);
661  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _XSTD initializer_list< value_type _Ilist,
size_type  _Buckets 
)
inline
666  { // construct map from initializer_list
667  _Mybase::rehash(_Buckets);
668  insert(_Ilist);
669  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _XSTD initializer_list< value_type _Ilist,
size_type  _Buckets,
const hasher _Hasharg 
)
inline
673  : _Mybase(key_compare(_Hasharg), allocator_type())
674  { // construct map from initializer_list, hasher
675  _Mybase::rehash(_Buckets);
676  insert(_Ilist);
677  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _XSTD initializer_list< value_type _Ilist,
size_type  _Buckets,
const hasher _Hasharg,
const _Keyeq &  _Keyeqarg 
)
inline
682  : _Mybase(key_compare(_Hasharg, _Keyeqarg), allocator_type())
683  { // construct map from initializer_list, comparator
684  _Mybase::rehash(_Buckets);
685  insert(_Ilist);
686  }
_Mybase::allocator_type allocator_type
Definition: unordered_map:494
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
void rehash(size_type _Buckets)
Definition: xhash:463
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::unordered_multimap ( _XSTD initializer_list< value_type _Ilist,
size_type  _Buckets,
const hasher _Hasharg,
const _Keyeq &  _Keyeqarg,
const allocator_type _Al 
)
inline
691  : _Mybase(key_compare(_Hasharg, _Keyeqarg), _Al)
692  { // construct map from initializer_list, allocator
693  _Mybase::rehash(_Buckets);
694  insert(_Ilist);
695  }
_Mytraits key_compare
Definition: unordered_map:491
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
_Hash< _Umap_traits< _Kty, _Ty, _Mytraits, _Alloc, true > > _Mybase
Definition: unordered_map:486
void rehash(size_type _Buckets)
Definition: xhash:463

Member Function Documentation

template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class... _Valty>
iterator unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::emplace ( _Valty &&...  _Val)
inline
629  { // try to insert value_type(_Val...), favoring right side
630  return (_Mybase::emplace(_STD forward<_Valty>(_Val)...).first);
631  }
_In_ int _Val
Definition: vcruntime_string.h:62
_Pairib emplace(_Valty &&..._Val)
Definition: xhash:252
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
hasher unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::hash_function ( ) const
inline
705  { // return hasher object
706  return (_Mybase::_Traitsobj._Gethash());
707  }
_Traits _Traitsobj
Definition: xhash:910
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::insert ( _Valty &&  _Val)
inline
646  { // insert _Val
647  return (this->emplace(_STD forward<_Valty>(_Val)));
648  }
iterator emplace(_Valty &&..._Val)
Definition: unordered_map:628
_In_ int _Val
Definition: vcruntime_string.h:62
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::insert ( const_iterator  _Where,
_Valty &&  _Val 
)
inline
653  { // insert _Val with hint
654  return (this->emplace_hint(_Where, _STD forward<_Valty>(_Val)));
655  }
_In_ int _Val
Definition: vcruntime_string.h:62
iterator emplace_hint(const_iterator, _Valty &&..._Val)
Definition: xhash:259
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
key_equal unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::key_eq ( ) const
inline
710  { // return equality comparator object
711  return (_Mybase::_Traitsobj._Getkeyeq());
712  }
_Traits _Traitsobj
Definition: xhash:910
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
_Myt& unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::operator= ( const _Myt _Right)
inline
603  { // assign by copying _Right
605  return (*this);
606  }
_Myt & operator=(_Myt &&_Right)
Definition: xhash:238
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
_Myt& unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::operator= ( _Myt &&  _Right)
inline
622  { // assign by moving _Right
624  return (*this);
625  }
_Myt & operator=(_Myt &&_Right)
Definition: xhash:238
constexpr remove_reference< _Ty >::type && move(_Ty &&_Arg) _NOEXCEPT
Definition: type_traits:1290
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
_Myt& unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::operator= ( _XSTD initializer_list< value_type _Ilist)
inline
698  { // assign initializer_list
699  _Mybase::clear();
700  insert(_Ilist);
701  return (*this);
702  }
void clear() _NOEXCEPT
Definition: xhash:569
iterator insert(_Valty &&_Val)
Definition: unordered_map:645
template<class _Kty, class _Ty, class _Hasher = hash<_Kty>, class _Keyeq = equal_to<_Kty>, class _Alloc = allocator<pair<const _Kty, _Ty> >>
void unordered_multimap< _Kty, _Ty, _Hasher, _Keyeq, _Alloc >::swap ( _Myt _Right)
inline
637  { // exchange contents with non-movable _Right
639  }
void swap(_Myt &_Right)
Definition: xhash:673
constexpr const _Ty &() _Right
Definition: algorithm:3591

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