STLdoc
STLdocumentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Public Types | Public Member Functions | List of all members
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc > Class Template Reference
Inheritance diagram for stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >:
_Hash< _Traits >

Public Types

typedef hash_map< _Kty, _Ty, _Tr, _Alloc > _Myt
 
typedef _Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _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::value_type value_type
 
typedef _Mybase::_Pairib _Pairib
 
typedef _STD reverse_iterator< iterator > reverse_iterator
 
typedef _STD reverse_iterator< const_iterator > const_reverse_iterator
 
- 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 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_map ()
 
 hash_map (const allocator_type &_Al)
 
 hash_map (const _Myt &_Right)
 
 hash_map (const _Myt &_Right, const allocator_type &_Al)
 
 hash_map (const key_compare &_Traits)
 
 hash_map (const key_compare &_Traits, const allocator_type &_Al)
 
template<class _Iter >
 hash_map (_Iter _First, _Iter _Last)
 
template<class _Iter >
 hash_map (_Iter _First, _Iter _Last, const key_compare &_Traits)
 
template<class _Iter >
 hash_map (_Iter _First, _Iter _Last, const key_compare &_Traits, const allocator_type &_Al)
 
_Myt & operator= (const _Myt &_Right)
 
 hash_map (_Myt &&_Right)
 
 hash_map (_Myt &&_Right, const allocator_type &_Al)
 
_Myt & operator= (_Myt &&_Right)
 
mapped_type & operator[] (key_type &&_Keyval)
 
void swap (_Myt &_Right)
 
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
_Pairib insert (_Valty &&_Val)
 
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator insert (const_iterator _Where, _Valty &&_Val)
 
 hash_map (_XSTD initializer_list< value_type > _Ilist)
 
 hash_map (_XSTD initializer_list< value_type > _Ilist, const key_compare &_Pred)
 
 hash_map (_XSTD initializer_list< value_type > _Ilist, const key_compare &_Pred, const allocator_type &_Al)
 
_Myt & operator= (_XSTD initializer_list< value_type > _Ilist)
 
mapped_type & operator[] (const key_type &_Keyval)
 
mapped_type & at (const key_type &_Keyval)
 
const mapped_type & at (const key_type &_Keyval) const
 
reverse_iterator rbegin () _NOEXCEPT
 
const_reverse_iterator rbegin () const _NOEXCEPT
 
reverse_iterator rend () _NOEXCEPT
 
const_reverse_iterator rend () const _NOEXCEPT
 
const_reverse_iterator crbegin () const _NOEXCEPT
 
const_reverse_iterator crend () const _NOEXCEPT
 
- Public Member Functions inherited from _Hash< _Traits >
 _Hash (const key_compare &_Parg, const allocator_type &_Al)
 
template<class _Any_alloc >
 _Hash (const _Myt &_Right, const _Any_alloc &_Al)
 
 _Hash (_Myt &&_Right)
 
 _Hash (_Myt &&_Right, const allocator_type &_Al)
 
_Myt & operator= (_Myt &&_Right)
 
void _Assign_rv (_Myt &&_Right)
 
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
 
const_iterator cbegin () const _NOEXCEPT
 
const_iterator cend () 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
 
const_local_iterator cend (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)
 
template<bool _Multi2 = _Multi, enable_if_t<!_Multi2, int > = 0>
_Pairib insert (const value_type &_Val)
 
template<bool _Multi2 = _Multi, enable_if_t< _Multi2, int > = 0>
iterator insert (const value_type &_Val)
 
template<bool _Multi2 = _Multi, enable_if_t<!_Multi2, int > = 0>
_Pairib insert (value_type &&_Val)
 
template<bool _Multi2 = _Multi, enable_if_t< _Multi2, int > = 0>
iterator insert (value_type &&_Val)
 
iterator insert (const_iterator, const value_type &_Val)
 
iterator insert (const_iterator, 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 ()
 
float & _Max_bucket_size () _NOEXCEPT
 
const float & _Max_bucket_size () const _NOEXCEPT
 
- Protected Attributes inherited from _Hash< _Traits >
_Traits _Traitsobj
 
_Mylist _List
 
_Myvec _Vec
 
size_type _Mask
 
size_type _Maxidx
 

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, false> > stdext::hash_map< _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_map<_Kty, _Ty, _Tr, _Alloc> stdext::hash_map< _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::_Pairib stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::_Pairib
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_map< _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_map< _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_map< _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_map< _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 _STD reverse_iterator<const_iterator> stdext::hash_map< _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_map< _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_map< _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_map< _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_map< _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_map< _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_map< _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_map< _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_map< _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 _STD reverse_iterator<iterator> stdext::hash_map< _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_map< _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_map< _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_map< _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_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( )
inline
131  : _Mybase(key_compare(), allocator_type())
132  { // construct empty map from defaults
133  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
stdext::hash_map::key_compare
_Tr key_compare
Definition: hash_map:116
stdext::hash_map::allocator_type
_Mybase::allocator_type allocator_type
Definition: hash_map:118
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( const allocator_type &  _Al)
inlineexplicit
136  : _Mybase(key_compare(), _Al)
137  { // construct empty map from defaults, allocator
138  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
stdext::hash_map::key_compare
_Tr key_compare
Definition: hash_map:116
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( const _Myt &  _Right)
inline
141  : _Mybase(_Right,
142  _Right._List._Getal().select_on_container_copy_construction())
143  { // construct map by copying _Right
144  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( const _Myt &  _Right,
const allocator_type &  _Al 
)
inline
147  : _Mybase(_Right, _Al)
148  { // construct map by copying _Right, allocator
149  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( const key_compare &  _Traits)
inlineexplicit
152  : _Mybase(_Traits, allocator_type())
153  { // construct empty map from comparator
154  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
stdext::hash_map::allocator_type
_Mybase::allocator_type allocator_type
Definition: hash_map:118
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( const key_compare &  _Traits,
const allocator_type &  _Al 
)
inline
157  : _Mybase(_Traits, _Al)
158  { // construct empty map from comparator and allocator
159  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Iter >
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _Iter  _First,
_Iter  _Last 
)
inline
163  : _Mybase(key_compare(), allocator_type())
164  { // construct map from sequence, defaults
165  insert(_First, _Last);
166  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
stdext::hash_map::key_compare
_Tr key_compare
Definition: hash_map:116
stdext::hash_map::allocator_type
_Mybase::allocator_type allocator_type
Definition: hash_map:118
stdext::hash_map::insert
_Pairib insert(_Valty &&_Val)
Definition: hash_map:227
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Iter >
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _Iter  _First,
_Iter  _Last,
const key_compare &  _Traits 
)
inline
171  : _Mybase(_Traits, allocator_type())
172  { // construct map from sequence, comparator
173  insert(_First, _Last);
174  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
stdext::hash_map::allocator_type
_Mybase::allocator_type allocator_type
Definition: hash_map:118
stdext::hash_map::insert
_Pairib insert(_Valty &&_Val)
Definition: hash_map:227
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Iter >
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _Iter  _First,
_Iter  _Last,
const key_compare &  _Traits,
const allocator_type &  _Al 
)
inline
180  : _Mybase(_Traits, _Al)
181  { // construct map from sequence, comparator, and allocator
182  insert(_First, _Last);
183  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
stdext::hash_map::insert
_Pairib insert(_Valty &&_Val)
Definition: hash_map:227
cliext::_Last
_FwdIt _Last
Definition: algorithm:1936
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _Myt &&  _Right)
inline
192  : _Mybase(_STD move(_Right))
193  { // construct map by moving _Right
194  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
move
constexpr remove_reference< _Ty >::type && move(_Ty &&_Arg) _NOEXCEPT
Definition: type_traits:1290
_STD
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _Myt &&  _Right,
const allocator_type &  _Al 
)
inline
197  : _Mybase(_STD move(_Right), _Al)
198  { // construct map by moving _Right, allocator
199  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
move
constexpr remove_reference< _Ty >::type && move(_Ty &&_Arg) _NOEXCEPT
Definition: type_traits:1290
_STD
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _XSTD initializer_list< value_type >  _Ilist)
inline
240  : _Mybase(key_compare(), allocator_type())
241  { // construct from initializer_list, defaults
242  insert(_Ilist);
243  }
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
stdext::hash_map::key_compare
_Tr key_compare
Definition: hash_map:116
stdext::hash_map::allocator_type
_Mybase::allocator_type allocator_type
Definition: hash_map:118
stdext::hash_map::insert
_Pairib insert(_Valty &&_Val)
Definition: hash_map:227
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _XSTD initializer_list< value_type >  _Ilist,
const key_compare &  _Pred 
)
inline
247  : _Mybase(_Pred, allocator_type())
248  { // construct from initializer_list, comparator
249  insert(_Ilist);
250  }
cliext::_Pred
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
stdext::hash_map::allocator_type
_Mybase::allocator_type allocator_type
Definition: hash_map:118
stdext::hash_map::insert
_Pairib insert(_Valty &&_Val)
Definition: hash_map:227
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::hash_map ( _XSTD initializer_list< value_type >  _Ilist,
const key_compare &  _Pred,
const allocator_type &  _Al 
)
inline
254  : _Mybase(_Pred, _Al)
255  { // construct from initializer_list, comparator, and allocator
256  insert(_Ilist);
257  }
cliext::_Pred
_FwdIt const _Ty _Pr _Pred
Definition: algorithm:1985
stdext::hash_map::_Mybase
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > > _Mybase
Definition: hash_map:112
stdext::hash_map::insert
_Pairib insert(_Valty &&_Val)
Definition: hash_map:227

Member Function Documentation

template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
mapped_type& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::at ( const key_type &  _Keyval)
inline
278  { // find element matching _Keyval
279  iterator _Where = this->lower_bound(_Keyval);
280  if (_Where == this->end())
281  _Xout_of_range("invalid hash_map<K, T> key");
282  return (_Where->second);
283  }
iterator
Definition: xutility:563
_Hash::lower_bound
iterator lower_bound(const key_type &_Keyval)
Definition: xhash:591
_Xout_of_range
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range(_In_z_ const char *)
_Hash::end
iterator end() _NOEXCEPT
Definition: xhash:287
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
const mapped_type& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::at ( const key_type &  _Keyval) const
inline
286  { // find element matching _Keyval
287  const_iterator _Where = this->lower_bound(_Keyval);
288  if (_Where == this->end())
289  _Xout_of_range("invalid hash_map<K, T> key");
290  return (_Where->second);
291  }
_Hash::lower_bound
iterator lower_bound(const key_type &_Keyval)
Definition: xhash:591
stdext::hash_map::const_iterator
_Mybase::const_iterator const_iterator
Definition: hash_map:126
_Xout_of_range
_CRTIMP2_PURE void __CLRCALL_PURE_OR_CDECL _Xout_of_range(_In_z_ const char *)
_Hash::end
iterator end() _NOEXCEPT
Definition: xhash:287
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
const_reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::crbegin ( ) const
inline
317  { // return iterator for beginning of reversed nonmutable sequence
318  return (rbegin());
319  }
stdext::hash_map::rbegin
reverse_iterator rbegin() _NOEXCEPT
Definition: hash_map:296
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
const_reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::crend ( ) const
inline
322  { // return iterator for end of reversed nonmutable sequence
323  return (rend());
324  }
stdext::hash_map::rend
reverse_iterator rend() _NOEXCEPT
Definition: hash_map:306
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
_Pairib stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::insert ( _Valty &&  _Val)
inline
228  { // insert _Val
229  return (this->emplace(_STD forward<_Valty>(_Val)));
230  }
_Val
_In_ int _Val
Definition: vcruntime_string.h:62
_Hash::emplace
_Pairib emplace(_Valty &&..._Val)
Definition: xhash:252
_STD
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
template<class _Valty , class = enable_if_t<is_constructible<value_type, _Valty>::value>>
iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::insert ( const_iterator  _Where,
_Valty &&  _Val 
)
inline
235  { // insert _Val with hint
236  return (this->emplace_hint(_Where, _STD forward<_Valty>(_Val)));
237  }
_Val
_In_ int _Val
Definition: vcruntime_string.h:62
_Hash::emplace_hint
iterator emplace_hint(const_iterator, _Valty &&..._Val)
Definition: xhash:259
_STD
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
_Myt& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::operator= ( const _Myt &  _Right)
inline
186  { // assign by copying _Right
187  _Mybase::operator=(_Right);
188  return (*this);
189  }
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > >::operator=
_Myt & operator=(_Myt &&_Right)
Definition: xhash:238
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
_Myt& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::operator= ( _Myt &&  _Right)
inline
202  { // assign by moving _Right
203  _Mybase::operator=(_STD move(_Right));
204  return (*this);
205  }
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > >::operator=
_Myt & operator=(_Myt &&_Right)
Definition: xhash:238
move
constexpr remove_reference< _Ty >::type && move(_Ty &&_Arg) _NOEXCEPT
Definition: type_traits:1290
_STD
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
_Myt& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::operator= ( _XSTD initializer_list< value_type >  _Ilist)
inline
260  { // assign initializer_list
261  this->clear();
262  insert(_Ilist);
263  return (*this);
264  }
_Hash::clear
void clear() _NOEXCEPT
Definition: xhash:569
stdext::hash_map::insert
_Pairib insert(_Valty &&_Val)
Definition: hash_map:227
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
mapped_type& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::operator[] ( key_type &&  _Keyval)
inline
208  { // find element matching _Keyval or insert with default mapped
209  iterator _Where = this->lower_bound(_Keyval);
210  if (_Where == this->end())
211  _Where = insert(
212  pair<key_type, mapped_type>(
213  _STD move(_Keyval),
214  mapped_type())).first;
215  return (_Where->second);
216  }
iterator
Definition: xutility:563
_Hash::lower_bound
iterator lower_bound(const key_type &_Keyval)
Definition: xhash:591
pair::first
_Ty1 first
Definition: utility:242
stdext::hash_map::insert
_Pairib insert(_Valty &&_Val)
Definition: hash_map:227
_Hash::end
iterator end() _NOEXCEPT
Definition: xhash:287
pair
Definition: utility:75
move
constexpr remove_reference< _Ty >::type && move(_Ty &&_Arg) _NOEXCEPT
Definition: type_traits:1290
_STD
stdext::hash_map::mapped_type
_Ty mapped_type
Definition: hash_map:114
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
mapped_type& stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::operator[] ( const key_type &  _Keyval)
inline
267  { // find element matching _Keyval or insert with default mapped
268  iterator _Where = this->lower_bound(_Keyval);
269  if (_Where == this->end())
270  _Where = insert(
271  pair<key_type, mapped_type>(
272  _Keyval,
273  mapped_type())).first;
274  return (_Where->second);
275  }
iterator
Definition: xutility:563
_Hash::lower_bound
iterator lower_bound(const key_type &_Keyval)
Definition: xhash:591
pair::first
_Ty1 first
Definition: utility:242
stdext::hash_map::insert
_Pairib insert(_Valty &&_Val)
Definition: hash_map:227
_Hash::end
iterator end() _NOEXCEPT
Definition: xhash:287
pair
Definition: utility:75
stdext::hash_map::mapped_type
_Ty mapped_type
Definition: hash_map:114
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::rbegin ( )
inline
297  { // return iterator for beginning of reversed mutable sequence
298  return (reverse_iterator(this->end()));
299  }
_Hash::end
iterator end() _NOEXCEPT
Definition: xhash:287
stdext::hash_map::reverse_iterator
_STD reverse_iterator< iterator > reverse_iterator
Definition: hash_map:293
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
const_reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::rbegin ( ) const
inline
302  { // return iterator for beginning of reversed nonmutable sequence
303  return (const_reverse_iterator(this->end()));
304  }
stdext::hash_map::const_reverse_iterator
_STD reverse_iterator< const_iterator > const_reverse_iterator
Definition: hash_map:294
_Hash::end
iterator end() _NOEXCEPT
Definition: xhash:287
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::rend ( )
inline
307  { // return iterator for end of reversed mutable sequence
308  return (reverse_iterator(this->begin()));
309  }
_Hash::begin
iterator begin() _NOEXCEPT
Definition: xhash:277
stdext::hash_map::reverse_iterator
_STD reverse_iterator< iterator > reverse_iterator
Definition: hash_map:293
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
const_reverse_iterator stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::rend ( ) const
inline
312  { // return iterator for end of reversed nonmutable sequence
313  return (const_reverse_iterator(this->begin()));
314  }
stdext::hash_map::const_reverse_iterator
_STD reverse_iterator< const_iterator > const_reverse_iterator
Definition: hash_map:294
_Hash::begin
iterator begin() _NOEXCEPT
Definition: xhash:277
template<class _Kty, class _Ty, class _Tr = hash_compare<_Kty, less<_Kty> >, class _Alloc = allocator<pair<const _Kty, _Ty> >>
void stdext::hash_map< _Kty, _Ty, _Tr, _Alloc >::swap ( _Myt &  _Right)
inline
219  { // exchange contents with non-movable _Right
220  _Mybase::swap(_Right);
221  }
_Hash< _Hmap_traits< _Kty, _Ty, _Tr, _Alloc, false > >::swap
void swap(_Myt &_Right)
Definition: xhash:673
_Right
constexpr const _Ty &() _Right
Definition: algorithm:3591
The documentation for this class was generated from the following file:
Generated on Mon Jul 24 2017 18:20:06 for STLdoc by   doxygen 1.8.8