28 #ifndef _GLIBCXX_PROFILE_UNORDERED_MAP
29 #define _GLIBCXX_PROFILE_UNORDERED_MAP 1
31 #if __cplusplus < 201103L
39 #define _GLIBCXX_BASE unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
40 #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
42 namespace std _GLIBCXX_VISIBILITY(default)
47 template<
typename _Key,
typename _Tp,
52 :
public _GLIBCXX_STD_BASE,
53 public _Unordered_profile<unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
56 typedef typename _GLIBCXX_STD_BASE
_Base;
59 _M_base() noexcept {
return *
this; }
62 _M_base()
const noexcept {
return *
this; }
65 typedef typename _Base::size_type size_type;
66 typedef typename _Base::hasher hasher;
67 typedef typename _Base::key_equal key_equal;
68 typedef typename _Base::allocator_type allocator_type;
69 typedef typename _Base::key_type key_type;
70 typedef typename _Base::value_type value_type;
71 typedef typename _Base::difference_type difference_type;
72 typedef typename _Base::reference reference;
73 typedef typename _Base::const_reference const_reference;
74 typedef typename _Base::mapped_type mapped_type;
76 typedef typename _Base::iterator iterator;
77 typedef typename _Base::const_iterator const_iterator;
83 const hasher& __hf = hasher(),
84 const key_equal& __eql = key_equal(),
85 const allocator_type& __a = allocator_type())
86 :
_Base(__n, __hf, __eql, __a) { }
88 template<
typename _InputIterator>
91 const hasher& __hf = hasher(),
92 const key_equal& __eql = key_equal(),
93 const allocator_type& __a = allocator_type())
94 :
_Base(__f, __l, __n, __hf, __eql, __a) { }
108 const allocator_type& __a)
109 :
_Base(__umap, __a) { }
112 const allocator_type& __a)
113 :
_Base(std::move(__umap._M_base()), __a) { }
117 const hasher& __hf = hasher(),
118 const key_equal& __eql = key_equal(),
119 const allocator_type& __a = allocator_type())
120 :
_Base(__l, __n, __hf, __eql, __a) { }
127 const allocator_type& __a)
131 template<
typename _InputIterator>
134 const allocator_type& __a)
135 :
unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
138 template<
typename _InputIterator>
140 size_type __n,
const hasher& __hf,
141 const allocator_type& __a)
142 :
unordered_map(__first, __last, __n, __hf, key_equal(), __a)
147 const allocator_type& __a)
152 size_type __n,
const hasher& __hf,
153 const allocator_type& __a)
166 this->_M_profile_destruct();
168 this->_M_profile_construct();
175 this->_M_profile_destruct();
177 this->_M_profile_construct();
180 template<
typename... _Args>
182 emplace(_Args&&... __args)
184 size_type __old_size = _Base::bucket_count();
186 = _Base::emplace(std::forward<_Args>(__args)...);
187 this->_M_profile_resize(__old_size);
191 template<
typename... _Args>
193 emplace_hint(const_iterator __it, _Args&&... __args)
195 size_type __old_size = _Base::bucket_count();
197 = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
198 this->_M_profile_resize(__old_size);
205 size_type __old_size = _Base::bucket_count();
207 this->_M_profile_resize(__old_size);
211 insert(
const value_type& __obj)
213 size_type __old_size = _Base::bucket_count();
215 this->_M_profile_resize(__old_size);
220 insert(const_iterator __iter,
const value_type& __v)
222 size_type __old_size = _Base::bucket_count();
223 iterator __res = _Base::insert(__iter, __v);
224 this->_M_profile_resize(__old_size);
228 template<
typename _Pair,
typename =
typename
229 std::enable_if<std::is_constructible<value_type,
230 _Pair&&>::value>::type>
232 insert(_Pair&& __obj)
234 size_type __old_size = _Base::bucket_count();
236 = _Base::insert(std::forward<_Pair>(__obj));
237 this->_M_profile_resize(__old_size);
241 template<
typename _Pair,
typename =
typename
242 std::enable_if<std::is_constructible<value_type,
243 _Pair&&>::value>::type>
245 insert(const_iterator __iter, _Pair&& __v)
247 size_type __old_size = _Base::bucket_count();
248 iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
249 this->_M_profile_resize(__old_size);
253 template<
typename _InputIter>
255 insert(_InputIter __first, _InputIter __last)
257 size_type __old_size = _Base::bucket_count();
258 _Base::insert(__first, __last);
259 this->_M_profile_resize(__old_size);
264 operator[](
const _Key& __k)
266 size_type __old_size = _Base::bucket_count();
267 mapped_type& __res = _M_base()[__k];
268 this->_M_profile_resize(__old_size);
273 operator[](_Key&& __k)
275 size_type __old_size = _Base::bucket_count();
276 mapped_type& __res = _M_base()[std::move(__k)];
277 this->_M_profile_resize(__old_size);
283 noexcept( noexcept(__x._M_base().swap(__x)) )
285 _Base::swap(__x._M_base());
289 void rehash(size_type __n)
291 size_type __old_size = _Base::bucket_count();
293 this->_M_profile_resize(__old_size);
297 template<
typename _Key,
typename _Tp,
typename _Hash,
298 typename _Pred,
typename _Alloc>
302 noexcept(noexcept(__x.swap(__y)))
305 template<
typename _Key,
typename _Tp,
typename _Hash,
306 typename _Pred,
typename _Alloc>
310 {
return static_cast<const _GLIBCXX_STD_BASE&
>(__x) == __y; }
312 template<
typename _Key,
typename _Tp,
typename _Hash,
313 typename _Pred,
typename _Alloc>
315 operator!=(
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
316 const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
317 {
return !(__x == __y); }
320 #undef _GLIBCXX_STD_BASE
321 #define _GLIBCXX_BASE unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
322 #define _GLIBCXX_STD_BASE _GLIBCXX_STD_C::_GLIBCXX_BASE
325 template<
typename _Key,
typename _Tp,
330 :
public _GLIBCXX_STD_BASE,
331 public _Unordered_profile<unordered_multimap<_Key, _Tp,
332 _Hash, _Pred, _Alloc>,
335 typedef typename _GLIBCXX_STD_BASE
_Base;
338 _M_base() noexcept {
return *
this; }
341 _M_base()
const noexcept {
return *
this; }
344 typedef typename _Base::size_type size_type;
345 typedef typename _Base::hasher hasher;
346 typedef typename _Base::key_equal key_equal;
347 typedef typename _Base::allocator_type allocator_type;
348 typedef typename _Base::key_type key_type;
349 typedef typename _Base::value_type value_type;
350 typedef typename _Base::difference_type difference_type;
351 typedef typename _Base::reference reference;
352 typedef typename _Base::const_reference const_reference;
354 typedef typename _Base::iterator iterator;
355 typedef typename _Base::const_iterator const_iterator;
361 const hasher& __hf = hasher(),
362 const key_equal& __eql = key_equal(),
363 const allocator_type& __a = allocator_type())
364 :
_Base(__n, __hf, __eql, __a) { }
366 template<
typename _InputIterator>
369 const hasher& __hf = hasher(),
370 const key_equal& __eql = key_equal(),
371 const allocator_type& __a = allocator_type())
372 :
_Base(__f, __l, __n, __hf, __eql, __a) { }
386 const allocator_type& __a)
387 :
_Base(__ummap._M_base(), __a) { }
390 const allocator_type& __a)
391 :
_Base(std::move(__ummap._M_base()), __a) { }
395 const hasher& __hf = hasher(),
396 const key_equal& __eql = key_equal(),
397 const allocator_type& __a = allocator_type())
398 :
_Base(__l, __n, __hf, __eql, __a) { }
405 const allocator_type& __a)
409 template<
typename _InputIterator>
412 const allocator_type& __a)
416 template<
typename _InputIterator>
418 size_type __n,
const hasher& __hf,
419 const allocator_type& __a)
425 const allocator_type& __a)
430 size_type __n,
const hasher& __hf,
431 const allocator_type& __a)
444 this->_M_profile_destruct();
446 this->_M_profile_construct();
453 this->_M_profile_destruct();
455 this->_M_profile_construct();
458 template<
typename... _Args>
460 emplace(_Args&&... __args)
462 size_type __old_size = _Base::bucket_count();
464 = _Base::emplace(std::forward<_Args>(__args)...);
465 this->_M_profile_resize(__old_size);
469 template<
typename... _Args>
471 emplace_hint(const_iterator __it, _Args&&... __args)
473 size_type __old_size = _Base::bucket_count();
475 = _Base::emplace_hint(__it, std::forward<_Args>(__args)...);
476 this->_M_profile_resize(__old_size);
483 size_type __old_size = _Base::bucket_count();
485 this->_M_profile_resize(__old_size);
489 insert(
const value_type& __obj)
491 size_type __old_size = _Base::bucket_count();
492 iterator __res = _Base::insert(__obj);
493 this->_M_profile_resize(__old_size);
498 insert(const_iterator __iter,
const value_type& __v)
500 size_type __old_size = _Base::bucket_count();
501 iterator __res = _Base::insert(__iter, __v);
502 this->_M_profile_resize(__old_size);
506 template<
typename _Pair,
typename =
typename
507 std::enable_if<std::is_constructible<value_type,
508 _Pair&&>::value>::type>
510 insert(_Pair&& __obj)
512 size_type __old_size = _Base::bucket_count();
513 iterator __res = _Base::insert(std::forward<_Pair>(__obj));
514 this->_M_profile_resize(__old_size);
518 template<
typename _Pair,
typename =
typename
519 std::enable_if<std::is_constructible<value_type,
520 _Pair&&>::value>::type>
522 insert(const_iterator __iter, _Pair&& __v)
524 size_type __old_size = _Base::bucket_count();
525 iterator __res = _Base::insert(__iter, std::forward<_Pair>(__v));
526 this->_M_profile_resize(__old_size);
530 template<
typename _InputIter>
532 insert(_InputIter __first, _InputIter __last)
534 size_type __old_size = _Base::bucket_count();
535 _Base::insert(__first, __last);
536 this->_M_profile_resize(__old_size);
541 noexcept( noexcept(__x._M_base().swap(__x)) )
543 _Base::swap(__x._M_base());
548 rehash(size_type __n)
550 size_type __old_size = _Base::bucket_count();
552 this->_M_profile_resize(__old_size);
556 template<
typename _Key,
typename _Tp,
typename _Hash,
557 typename _Pred,
typename _Alloc>
561 noexcept(noexcept(__x.swap(__y)))
564 template<
typename _Key,
typename _Tp,
typename _Hash,
565 typename _Pred,
typename _Alloc>
569 {
return static_cast<const _GLIBCXX_STD_BASE&
>(__x) == __y; }
571 template<
typename _Key,
typename _Tp,
typename _Hash,
572 typename _Pred,
typename _Alloc>
574 operator!=(
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
575 const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
576 {
return !(__x == __y); }
582 #undef _GLIBCXX_STD_BASE
A standard container composed of unique keys (containing at most one of each key value) that associat...
Class std::unordered_map wrapper with performance instrumentation.
Primary class template hash.
The standard allocator, as per [20.4].
One of the comparison functors.
Class std::unordered_multimap wrapper with performance instrumentation.
Sequential helper functions. This file is a GNU profile extension to the Standard C++ Library...
Struct holding two objects of arbitrary type.
A standard container composed of equivalent keys (possibly containing multiple of each key value) tha...