ReactOS  0.4.13-dev-92-gf251225
_unordered_map.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2004
3  * Francois Dumont
4  *
5  * This material is provided "as is", with absolutely no warranty expressed
6  * or implied. Any use is at your own risk.
7  *
8  * Permission to use or copy this software for any purpose is hereby granted
9  * without fee, provided the above notices are retained on all copies.
10  * Permission to modify the code and to distribute modified code is granted,
11  * provided the above notices are retained, and a notice that the code was
12  * modified is included with the above copyright notice.
13  *
14  */
15 
16 /* NOTE: This is an internal header file, included by other STL headers.
17  * You should not attempt to use it directly.
18  */
19 
20 #ifndef _STLP_INTERNAL_UNORDERED_MAP_H
21 #define _STLP_INTERNAL_UNORDERED_MAP_H
22 
23 #ifndef _STLP_INTERNAL_HASHTABLE_H
24 # include <stl/_hashtable.h>
25 #endif
26 
28 
29 //Specific iterator traits creation
30 _STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedMapTraitsT, traits)
31 
33 
34 template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
35  _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Key>),
36  _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
38 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
39  : public __stlport_class<unordered_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
40 #endif
41 {
42 private:
44 public:
45  typedef _Key key_type;
46  typedef _Tp data_type;
47  typedef _Tp mapped_type;
49 private:
50  //Specific iterator traits creation
51  typedef _STLP_PRIV _UnorderedMapTraitsT<value_type> _UnorderedMapTraits;
52 
53 public:
55  _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht;
56 
57  typedef typename _Ht::hasher hasher;
58  typedef typename _Ht::key_equal key_equal;
59 
60  typedef typename _Ht::size_type size_type;
62  typedef typename _Ht::pointer pointer;
64  typedef typename _Ht::reference reference;
66 
67  typedef typename _Ht::iterator iterator;
71 
73 
74  hasher hash_function() const { return _M_ht.hash_funct(); }
75  key_equal key_eq() const { return _M_ht.key_eq(); }
77 
78 private:
81 
82 public:
83  explicit unordered_map(size_type __n = 0, const hasher& __hf = hasher(),
84  const key_equal& __eql = key_equal(),
85  const allocator_type& __a = allocator_type())
86  : _M_ht(__n, __hf, __eql, __a) {}
87 
88 #if !defined (_STLP_NO_MOVE_SEMANTIC)
91 #endif
92 
93 #if defined (_STLP_MEMBER_TEMPLATES)
94  template <class _InputIterator>
95  unordered_map(_InputIterator __f, _InputIterator __l,
96  size_type __n = 0, const hasher& __hf = hasher(),
97  const key_equal& __eql = key_equal(),
98  const allocator_type& __a = allocator_type())
99  : _M_ht(__n, __hf, __eql, __a)
100  { _M_ht.insert_unique(__f, __l); }
101 #else
102  unordered_map(const value_type* __f, const value_type* __l,
103  size_type __n = 0, const hasher& __hf = hasher(),
104  const key_equal& __eql = key_equal(),
105  const allocator_type& __a = allocator_type())
106  : _M_ht(__n, __hf, __eql, __a)
107  { _M_ht.insert_unique(__f, __l); }
108 
110  size_type __n = 0, const hasher& __hf = hasher(),
111  const key_equal& __eql = key_equal(),
112  const allocator_type& __a = allocator_type())
113  : _M_ht(__n, __hf, __eql, __a)
114  { _M_ht.insert_unique(__f, __l); }
115 #endif /*_STLP_MEMBER_TEMPLATES */
116 
117  _Self& operator = (const _Self& __other)
118  { _M_ht = __other._M_ht; return *this; }
119 
120  size_type size() const { return _M_ht.size(); }
121  size_type max_size() const { return _M_ht.max_size(); }
122  bool empty() const { return _M_ht.empty(); }
123  void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
124 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
125  void _M_swap_workaround(_Self& __x) { swap(__x); }
126 #endif
127 
128  iterator begin() { return _M_ht.begin(); }
129  iterator end() { return _M_ht.end(); }
130  const_iterator begin() const { return _M_ht.begin(); }
131  const_iterator end() const { return _M_ht.end(); }
132 
134  { return _M_ht.insert_unique(__obj); }
135  iterator insert(const_iterator /*__hint*/, const value_type& __obj)
136  { return _M_ht.insert_unique(__obj); }
137 #if defined (_STLP_MEMBER_TEMPLATES)
138  template <class _InputIterator>
139  void insert(_InputIterator __f, _InputIterator __l)
140 #else
141  void insert(const value_type* __f, const value_type* __l)
142  { _M_ht.insert_unique(__f,__l); }
144 #endif /*_STLP_MEMBER_TEMPLATES */
145  { _M_ht.insert_unique(__f, __l); }
146 
148  iterator find(const _KT& __key) { return _M_ht.find(__key); }
150  const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
151 
153  _Tp& operator[](const _KT& __key) {
154  iterator __it = _M_ht.find(__key);
155  return (__it == _M_ht.end() ?
156  _M_ht._M_insert(value_type(__key, _STLP_DEFAULT_CONSTRUCTED(_Tp))).second :
157  (*__it).second );
158  }
159 
161  size_type count(const _KT& __key) const { return _M_ht.count(__key); }
162 
165  { return _M_ht.equal_range(__key); }
168  { return _M_ht.equal_range(__key); }
169 
170  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
172  void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); }
173  void clear() { _M_ht.clear(); }
174 
175  size_type bucket_count() const { return _M_ht.bucket_count(); }
179  size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); }
184 
185  float load_factor() const { return _M_ht.load_factor(); }
186  float max_load_factor() const { return _M_ht.max_load_factor(); }
188  void rehash(size_type __hint) { _M_ht.rehash(__hint); }
189 
190 #if defined (__DMC__) // disable operator==(pair<x,unordered_map>, pair<x,unordered_map>)
191  bool operator==(const _Self&) const;
192 #endif
193 };
194 
196 
197 //Specific iterator traits creation
198 _STLP_CREATE_HASH_ITERATOR_TRAITS(UnorderedMultimapTraitsT, traits)
199 
201 
202 template <class _Key, class _Tp, _STLP_DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
203  _STLP_DFL_TMPL_PARAM(_EqualKey, equal_to<_Key>),
204  _STLP_DEFAULT_PAIR_ALLOCATOR_SELECT(_STLP_CONST _Key, _Tp) >
206 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND)
207  : public __stlport_class<unordered_multimap<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> >
208 #endif
209 {
210 private:
212 public:
213  typedef _Key key_type;
214  typedef _Tp data_type;
215  typedef _Tp mapped_type;
217 private:
218  //Specific iterator traits creation
219  typedef _STLP_PRIV _UnorderedMultimapTraitsT<value_type> _UnorderedMultimapTraits;
220 
221 public:
223  _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht;
224 
225  typedef typename _Ht::hasher hasher;
226  typedef typename _Ht::key_equal key_equal;
227 
228  typedef typename _Ht::size_type size_type;
230  typedef typename _Ht::pointer pointer;
232  typedef typename _Ht::reference reference;
234 
235  typedef typename _Ht::iterator iterator;
239 
241 
242  hasher hash_function() const { return _M_ht.hash_funct(); }
243  key_equal key_eq() const { return _M_ht.key_eq(); }
245 
246 private:
249 
250 public:
251  explicit unordered_multimap(size_type __n = 0, const hasher& __hf = hasher(),
252  const key_equal& __eql = key_equal(),
253  const allocator_type& __a = allocator_type())
254  : _M_ht(__n, __hf, __eql, __a) {}
255 
256 #if !defined (_STLP_NO_MOVE_SEMANTIC)
258  : _M_ht(__move_source<_Ht>(src.get()._M_ht)) {}
259 #endif
260 
261 #if defined (_STLP_MEMBER_TEMPLATES)
262  template <class _InputIterator>
263  unordered_multimap(_InputIterator __f, _InputIterator __l,
264  size_type __n = 0, const hasher& __hf = hasher(),
265  const key_equal& __eql = key_equal(),
266  const allocator_type& __a = allocator_type())
267  : _M_ht(__n, __hf, __eql, __a)
268  { _M_ht.insert_equal(__f, __l); }
269 #else
270  unordered_multimap(const value_type* __f, const value_type* __l,
271  size_type __n = 0, const hasher& __hf = hasher(),
272  const key_equal& __eql = key_equal(),
273  const allocator_type& __a = allocator_type())
274  : _M_ht(__n, __hf, __eql, __a)
275  { _M_ht.insert_equal(__f, __l); }
276 
278  size_type __n = 0, const hasher& __hf = hasher(),
279  const key_equal& __eql = key_equal(),
280  const allocator_type& __a = allocator_type())
281  : _M_ht(__n, __hf, __eql, __a)
282  { _M_ht.insert_equal(__f, __l); }
283 #endif /*_STLP_MEMBER_TEMPLATES */
284 
285  _Self& operator = (const _Self& __other)
286  { _M_ht = __other._M_ht; return *this; }
287 
288  size_type size() const { return _M_ht.size(); }
289  size_type max_size() const { return _M_ht.max_size(); }
290  bool empty() const { return _M_ht.empty(); }
291  void swap(_Self& __hs) { _M_ht.swap(__hs._M_ht); }
292 #if defined (_STLP_USE_PARTIAL_SPEC_WORKAROUND) && !defined (_STLP_FUNCTION_TMPL_PARTIAL_ORDER)
293  void _M_swap_workaround(_Self& __x) { swap(__x); }
294 #endif
295 
296  iterator begin() { return _M_ht.begin(); }
297  iterator end() { return _M_ht.end(); }
298  const_iterator begin() const { return _M_ht.begin(); }
299  const_iterator end() const { return _M_ht.end(); }
300 
301  iterator insert(const value_type& __obj)
302  { return _M_ht.insert_equal(__obj); }
303  iterator insert(const_iterator /*__hint*/, const value_type& __obj)
304  { return _M_ht.insert_equal(__obj); }
305 #if defined (_STLP_MEMBER_TEMPLATES)
306  template <class _InputIterator>
307  void insert(_InputIterator __f, _InputIterator __l)
308 #else
309  void insert(const value_type* __f, const value_type* __l)
310  { _M_ht.insert_equal(__f,__l); }
312 #endif /*_STLP_MEMBER_TEMPLATES */
313  { _M_ht.insert_equal(__f, __l); }
314 
316  iterator find(const _KT& __key) { return _M_ht.find(__key); }
318  const_iterator find(const _KT& __key) const { return _M_ht.find(__key); }
319 
321  size_type count(const _KT& __key) const { return _M_ht.count(__key); }
322 
325  { return _M_ht.equal_range(__key); }
328  { return _M_ht.equal_range(__key); }
329 
330  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
332  void erase(const_iterator __f, const_iterator __l) { _M_ht.erase(__f, __l); }
333  void clear() { _M_ht.clear(); }
334 
335  size_type bucket_count() const { return _M_ht.bucket_count(); }
339  size_type bucket(const _KT& __k) const { return _M_ht.bucket(__k); }
344 
345  float load_factor() const { return _M_ht.load_factor(); }
346  float max_load_factor() const { return _M_ht.max_load_factor(); }
348  void rehash(size_type __hint) { _M_ht.rehash(__hint); }
349 };
350 
351 #define _STLP_TEMPLATE_HEADER template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
352 #define _STLP_TEMPLATE_CONTAINER unordered_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
353 
354 #include <stl/_relops_hash_cont.h>
355 
356 #undef _STLP_TEMPLATE_CONTAINER
357 #define _STLP_TEMPLATE_CONTAINER unordered_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>
358 
359 #include <stl/_relops_hash_cont.h>
360 
361 #undef _STLP_TEMPLATE_CONTAINER
362 #undef _STLP_TEMPLATE_HEADER
363 
365 
366 // Specialization of insert_iterator so that it will work for unordered_map
367 // and unordered_multimap.
368 
369 #if defined (_STLP_CLASS_PARTIAL_SPECIALIZATION)
370 # if !defined (_STLP_NO_MOVE_SEMANTIC)
371 template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
372 struct __move_traits<_STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
373  _STLP_PRIV __move_traits_help<typename _STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
374 {};
375 
376 template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
377 struct __move_traits<_STLP_TR1 unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > :
378  _STLP_PRIV __move_traits_help<typename _STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>::_Ht>
379 {};
380 # endif
381 
382 template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
383 class insert_iterator<_STLP_TR1 unordered_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
384 protected:
386  _Container* container;
387 public:
388  typedef _Container container_type;
390  typedef void value_type;
391  typedef void difference_type;
392  typedef void pointer;
393  typedef void reference;
394 
395  insert_iterator(_Container& __x) : container(&__x) {}
396  insert_iterator(_Container& __x, typename _Container::iterator)
397  : container(&__x) {}
399  operator=(const typename _Container::value_type& __val) {
400  container->insert(__val);
401  return *this;
402  }
403  insert_iterator<_Container>& operator*() { return *this; }
404  insert_iterator<_Container>& operator++() { return *this; }
405  insert_iterator<_Container>& operator++(int) { return *this; }
406 };
407 
408 template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
409 class insert_iterator<_STLP_TR1 unordered_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
410 protected:
412  _Container* container;
413  typename _Container::iterator iter;
414 public:
415  typedef _Container container_type;
417  typedef void value_type;
418  typedef void difference_type;
419  typedef void pointer;
420  typedef void reference;
421 
422  insert_iterator(_Container& __x) : container(&__x) {}
423  insert_iterator(_Container& __x, typename _Container::iterator)
424  : container(&__x) {}
426  operator=(const typename _Container::value_type& __val) {
427  container->insert(__val);
428  return *this;
429  }
430  insert_iterator<_Container>& operator*() { return *this; }
431  insert_iterator<_Container>& operator++() { return *this; }
432  insert_iterator<_Container>& operator++(int) { return *this; }
433 };
434 
435 #endif /* _STLP_CLASS_PARTIAL_SPECIALIZATION */
436 
438 
439 #endif /* _STLP_INTERNAL_UNORDERED_MAP_H */
440 
441 // Local Variables:
442 // mode:C++
443 // End:
size_type bucket_size(size_type __n) const
const_iterator begin() const
_Ht::reference reference
_Container container_type
Definition: _iterator.h:228
void insert(const_iterator __f, const_iterator __l)
local_iterator end(size_type __n)
_Self & operator *()
Definition: _iterator.h:243
unordered_map(const value_type *__f, const value_type *__l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
return __n
Definition: _algo.h:75
local_iterator end(size_type __n)
unordered_map(size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
iterator begin()
Definition: _hashtable.h:376
unordered_multimap< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > _Self
allocator_type get_allocator() const
void swap(_Self &__hs)
#define _STLP_CREATE_HASH_ITERATOR_TRAITS(Motif, Traits)
GLsizei const GLvoid * pointer
Definition: glext.h:5848
size_type max_size() const
#define _Alloc
Definition: _bvector.h:330
#define _STLP_BEGIN_TR1_NAMESPACE
Definition: features.h:502
void rehash(size_type __hint)
float load_factor() const
float max_load_factor() const
Definition: _hashtable.h:401
const_local_iterator begin(size_type __n) const
pair< iterator, bool > insert(const value_type &__obj)
_STLP_TEMPLATE_FOR_CONT_EXT size_type count(const _KT &__key) const
#define _STLP_TEMPLATE_FOR_CONT_EXT
Definition: features.h:623
pair< _STLP_CONST key_type, data_type > value_type
_Ht::const_reference const_reference
size_type max_bucket_count() const
_Ht::size_type size_type
iterator insert(const_iterator, const value_type &__obj)
size_type bucket_count() const
_Ht::const_local_iterator const_local_iterator
_Ht::pointer pointer
_STLP_TEMPLATE_FOR_CONT_EXT _Tp & operator[](const _KT &__key)
_STLP_PRIV _UnorderedMultimapTraitsT< value_type > _UnorderedMultimapTraits
size_type max_size() const
_STLP_TEMPLATE_FOR_CONT_EXT size_type bucket(const _KT &__k) const
iterator insert(const value_type &__obj)
hasher hash_function() const
_Ht::iterator iterator
unordered_map(const_iterator __f, const_iterator __l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
_Ht::key_equal key_equal
unordered_multimap(const value_type *__f, const value_type *__l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
pair< _STLP_CONST key_type, data_type > value_type
unordered_map(__move_source< _Self > src)
allocator_type get_allocator() const
Definition: _hashtable.h:300
size_type bucket_size(size_type __n) const
hashtable< value_type, key_type, _HashFcn, _UnorderedMapTraits, _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht
const_iterator end() const
void swap(_Self &__ht)
Definition: _hashtable.h:367
iterator end()
Definition: _hashtable.h:377
size_type max_bucket_count() const
Definition: _hashtable.h:392
#define _STLP_DEFAULT_CONSTRUCTED(_TTp)
Definition: _construct.h:265
const_iterator end() const
hasher hash_funct() const
Definition: _hashtable.h:246
void erase(const_iterator __it)
hasher hash_function() const
const_iterator begin() const
iterator insert_equal(const value_type &__obj)
Definition: _hashtable.h:412
void max_load_factor(float __val)
_Ht::const_iterator const_iterator
_Ht::const_iterator const_iterator
_Self & operator=(const _Self &__other)
void clear()
Definition: _hashtable.c:501
_STLP_TEMPLATE_FOR_CONT_EXT const_iterator find(const _KT &__key) const
output_iterator_tag iterator_category
Definition: _iterator.h:229
unordered_multimap(__move_source< _Self > src)
size_type bucket_count() const
Definition: _hashtable.h:391
_STLP_PRIV _UnorderedMapTraitsT< value_type > _UnorderedMapTraits
void get(int argc, const char *argv[])
Definition: cmds.c:480
size_type bucket_count() const
size_type max_bucket_count() const
size_type size() const
size_type erase(const key_type &__key)
_Ht::pointer pointer
key_equal key_eq() const
Definition: _hashtable.h:247
if(!(yy_init))
Definition: macro.lex.yy.c:714
_Ht::iterator iterator
_STLP_TEMPLATE_FOR_CONT_EXT pair< iterator, iterator > equal_range(const _KT &__key)
_Ht::local_iterator local_iterator
key_equal key_eq() const
hashtable< value_type, key_type, _HashFcn, _UnorderedMultimapTraits, _STLP_SELECT1ST(value_type, _Key), _EqualKey, _Alloc > _Ht
bool empty() const
_STLP_INLINE_LOOP _InputIter const _Tp & __val
Definition: _algobase.h:656
void rehash(size_type __num_buckets_hint)
Definition: _hashtable.c:365
float load_factor() const
Definition: _hashtable.h:400
_Ht::key_equal key_equal
_STLP_TEMPLATE_FOR_CONT_EXT pair< iterator, iterator > equal_range(const _KT &__key)
key_equal key_eq() const
size_type size() const
Definition: _hashtable.h:363
_STLP_MOVE_TO_PRIV_NAMESPACE const _InputIterator const input_iterator_tag &_InputIterator __it(__first)
size_type elems_in_bucket(size_type __bucket) const
Definition: _hashtable.h:393
iterator begin()
bool operator==(const TKeyDef &t1, const TKeyDef &t2)
Definition: tkeydef.cpp:122
_Ht::allocator_type allocator_type
_Ht::const_reference const_reference
iterator end()
const_local_iterator begin(size_type __n) const
GLint reference
Definition: glext.h:11729
#define _STLP_PRIV
Definition: _dm.h:70
GLenum src
Definition: glext.h:6340
void insert(const value_type *__f, const value_type *__l)
const_local_iterator end(size_type __n) const
size_type max_size() const
Definition: _hashtable.h:364
_STLP_TEMPLATE_FOR_CONT_EXT iterator find(const _KT &__key)
#define _STLP_KEY_TYPE_FOR_CONT_EXT(type)
Definition: features.h:622
void erase(const_iterator __f, const_iterator __l)
_STLP_TEMPLATE_FOR_CONT_EXT size_type count(const _KT &__key) const
_STLP_TEMPLATE_FOR_CONT_EXT pair< const_iterator, const_iterator > equal_range(const _KT &__key) const
_Ht::difference_type difference_type
_Ht::local_iterator local_iterator
_Ht::difference_type difference_type
bool empty() const
_STLP_TEMPLATE_FOR_CONT_EXT iterator find(const _KT &__key)
Definition: _hashtable.h:511
size_type size() const
#define _STLP_SELECT1ST(__x, __y)
_Container * container
Definition: _iterator.h:225
bool empty() const
Definition: _hashtable.h:365
void rehash(size_type __hint)
iterator insert(const_iterator, const value_type &__obj)
#define _STLP_END_NAMESPACE
Definition: features.h:503
Definition: _pair.h:47
_Ht::allocator_type allocator_type
void insert(const value_type *__f, const value_type *__l)
_STLP_TEMPLATE_FOR_CONT_EXT iterator find(const _KT &__key)
_STLP_TEMPLATE_FOR_CONT_EXT size_type count(const _KT &__key) const
Definition: _hashtable.h:516
_Ht::const_pointer const_pointer
_Ht::hasher hasher
_STLP_TEMPLATE_FOR_CONT_EXT size_type bucket(const _KT &__k) const
void swap(_Self &__hs)
size_type erase(const key_type &__key)
void erase(const_iterator __it)
float max_load_factor() const
_Self & operator++()
Definition: _iterator.h:244
unordered_multimap(size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
const_local_iterator end(size_type __n) const
unordered_map< _Key, _Tp, _HashFcn, _EqualKey, _Alloc > _Self
#define _STLP_TR1
Definition: features.h:518
_Ht::reference reference
local_iterator begin(size_type __n)
_Self & operator=(const _Self &__other)
_STLP_TEMPLATE_FOR_CONT_EXT pair< iterator, iterator > equal_range(const _KT &__key)
Definition: _hashtable.h:534
#define _STLP_BEGIN_NAMESPACE
Definition: features.h:501
pair< iterator, bool > insert_unique(const value_type &__obj)
Definition: _hashtable.h:407
_STLP_TEMPLATE_FOR_CONT_EXT size_type bucket(const _KT &__k) const
Definition: _hashtable.h:397
_Ht::const_pointer const_pointer
float max_load_factor() const
void max_load_factor(float __val)
unordered_multimap(const_iterator __f, const_iterator __l, size_type __n=0, const hasher &__hf=hasher(), const key_equal &__eql=key_equal(), const allocator_type &__a=allocator_type())
reference _M_insert(const value_type &__obj)
Definition: _hashtable.c:254
insert_iterator(_Container &__x, typename _Container::iterator __i)
Definition: _iterator.h:230
local_iterator begin(size_type __n)
void erase(const_iterator __f, const_iterator __l)
allocator_type get_allocator() const
void insert(const_iterator __f, const_iterator __l)
_STLP_TEMPLATE_FOR_CONT_EXT const_iterator find(const _KT &__key) const
_Ht::size_type size_type
float load_factor() const
size_type erase(const key_type &__key)
Definition: _hashtable.c:263
_Self & operator=(_Self const &__other)
Definition: _iterator.h:233
_STLP_TEMPLATE_FOR_CONT_EXT pair< const_iterator, const_iterator > equal_range(const _KT &__key) const
_Ht::const_local_iterator const_local_iterator