29 #ifndef _GLIBCXX_DEBUG_UNORDERED_MAP 30 #define _GLIBCXX_DEBUG_UNORDERED_MAP 1 32 #pragma GCC system_header 34 #if __cplusplus < 201103L 44 namespace std _GLIBCXX_VISIBILITY(default)
49 template<
typename _Key,
typename _Tp,
55 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>, _Alloc,
56 __gnu_debug::_Safe_unordered_container>,
57 public _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>
59 typedef _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash,
63 typedef typename _Base::const_iterator _Base_const_iterator;
64 typedef typename _Base::iterator _Base_iterator;
65 typedef typename _Base::const_local_iterator
66 _Base_const_local_iterator;
67 typedef typename _Base::local_iterator _Base_local_iterator;
70 typedef typename _Base::size_type size_type;
71 typedef typename _Base::hasher hasher;
72 typedef typename _Base::key_equal key_equal;
73 typedef typename _Base::allocator_type allocator_type;
75 typedef typename _Base::key_type key_type;
76 typedef typename _Base::value_type value_type;
79 _Base_iterator, unordered_map>
iterator;
87 unordered_map() =
default;
90 unordered_map(size_type __n,
91 const hasher& __hf = hasher(),
92 const key_equal& __eql = key_equal(),
93 const allocator_type& __a = allocator_type())
94 : _Base(__n, __hf, __eql, __a) { }
96 template<
typename _InputIterator>
97 unordered_map(_InputIterator __first, _InputIterator __last,
99 const hasher& __hf = hasher(),
100 const key_equal& __eql = key_equal(),
101 const allocator_type& __a = allocator_type())
102 : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
104 __gnu_debug::__base(__last), __n,
105 __hf, __eql, __a) { }
107 unordered_map(
const unordered_map&) =
default;
109 unordered_map(
const _Base& __x)
112 unordered_map(unordered_map&&) =
default;
115 unordered_map(
const allocator_type& __a)
118 unordered_map(
const unordered_map& __umap,
119 const allocator_type& __a)
120 : _Base(__umap, __a) { }
122 unordered_map(unordered_map&& __umap,
123 const allocator_type& __a)
124 : _Safe(std::move(__umap._M_safe()), __a),
125 _Base(std::move(__umap._M_base()), __a) { }
129 const hasher& __hf = hasher(),
130 const key_equal& __eql = key_equal(),
131 const allocator_type& __a = allocator_type())
132 : _Base(__l, __n, __hf, __eql, __a) { }
134 unordered_map(size_type __n,
const allocator_type& __a)
135 : unordered_map(__n, hasher(), key_equal(), __a)
138 unordered_map(size_type __n,
140 const allocator_type& __a)
141 : unordered_map(__n, __hf, key_equal(), __a)
144 template<
typename _InputIterator>
145 unordered_map(_InputIterator __first, _InputIterator __last,
147 const allocator_type& __a)
148 : unordered_map(__first, __last, __n, hasher(), key_equal(), __a)
151 template<
typename _InputIterator>
152 unordered_map(_InputIterator __first, _InputIterator __last,
155 const allocator_type& __a)
156 : unordered_map(__first, __last, __n, __hf, key_equal(), __a)
161 const allocator_type& __a)
162 : unordered_map(__l, __n, hasher(), key_equal(), __a)
168 const allocator_type& __a)
169 : unordered_map(__l, __n, __hf, key_equal(), __a)
172 ~unordered_map() =
default;
175 operator=(
const unordered_map&) =
default;
178 operator=(unordered_map&&) =
default;
184 this->_M_invalidate_all();
189 swap(unordered_map& __x)
190 noexcept( noexcept(declval<_Base&>().swap(__x)) )
200 this->_M_invalidate_all();
205 {
return iterator(_Base::begin(),
this); }
208 begin()
const noexcept
209 {
return const_iterator(_Base::begin(),
this); }
213 {
return iterator(_Base::end(),
this); }
217 {
return const_iterator(_Base::end(),
this); }
220 cbegin()
const noexcept
221 {
return const_iterator(_Base::begin(),
this); }
224 cend()
const noexcept
225 {
return const_iterator(_Base::end(),
this); }
231 __glibcxx_check_bucket_index(__b);
232 return local_iterator(_Base::begin(__b),
this);
238 __glibcxx_check_bucket_index(__b);
239 return local_iterator(_Base::end(__b),
this);
243 begin(size_type __b)
const 245 __glibcxx_check_bucket_index(__b);
246 return const_local_iterator(_Base::begin(__b),
this);
250 end(size_type __b)
const 252 __glibcxx_check_bucket_index(__b);
253 return const_local_iterator(_Base::end(__b),
this);
257 cbegin(size_type __b)
const 259 __glibcxx_check_bucket_index(__b);
260 return const_local_iterator(_Base::cbegin(__b),
this);
264 cend(size_type __b)
const 266 __glibcxx_check_bucket_index(__b);
267 return const_local_iterator(_Base::cend(__b),
this);
271 bucket_size(size_type __b)
const 273 __glibcxx_check_bucket_index(__b);
274 return _Base::bucket_size(__b);
278 max_load_factor()
const noexcept
279 {
return _Base::max_load_factor(); }
282 max_load_factor(
float __f)
284 __glibcxx_check_max_load_factor(__f);
285 _Base::max_load_factor(__f);
288 template<
typename... _Args>
290 emplace(_Args&&... __args)
292 size_type __bucket_count = this->bucket_count();
294 = _Base::emplace(std::forward<_Args>(__args)...);
295 _M_check_rehashed(__bucket_count);
299 template<
typename... _Args>
301 emplace_hint(const_iterator __hint, _Args&&... __args)
304 size_type __bucket_count = this->bucket_count();
305 _Base_iterator __it = _Base::emplace_hint(__hint.
base(),
306 std::forward<_Args>(__args)...);
307 _M_check_rehashed(__bucket_count);
308 return iterator(__it,
this);
312 insert(
const value_type& __obj)
314 size_type __bucket_count = this->bucket_count();
315 auto __res = _Base::insert(__obj);
316 _M_check_rehashed(__bucket_count);
317 return { iterator(__res.first,
this), __res.second };
323 insert(value_type&& __x)
325 size_type __bucket_count = this->bucket_count();
326 auto __res = _Base::insert(std::move(__x));
327 _M_check_rehashed(__bucket_count);
328 return { iterator(__res.first,
this), __res.second };
331 template<
typename _Pair,
typename =
typename 333 _Pair&&>::value>::type>
335 insert(_Pair&& __obj)
337 size_type __bucket_count = this->bucket_count();
339 _Base::insert(std::forward<_Pair>(__obj));
340 _M_check_rehashed(__bucket_count);
345 insert(const_iterator __hint,
const value_type& __obj)
348 size_type __bucket_count = this->bucket_count();
349 _Base_iterator __it = _Base::insert(__hint.
base(), __obj);
350 _M_check_rehashed(__bucket_count);
351 return iterator(__it,
this);
357 insert(const_iterator __hint, value_type&& __x)
360 size_type __bucket_count = this->bucket_count();
361 auto __it = _Base::insert(__hint.
base(), std::move(__x));
362 _M_check_rehashed(__bucket_count);
363 return iterator(__it,
this);
366 template<
typename _Pair,
typename =
typename 368 _Pair&&>::value>::type>
370 insert(const_iterator __hint, _Pair&& __obj)
373 size_type __bucket_count = this->bucket_count();
374 _Base_iterator __it =
375 _Base::insert(__hint.
base(), std::forward<_Pair>(__obj));
376 _M_check_rehashed(__bucket_count);
377 return iterator(__it,
this);
383 size_type __bucket_count = this->bucket_count();
385 _M_check_rehashed(__bucket_count);
388 template<
typename _InputIterator>
390 insert(_InputIterator __first, _InputIterator __last)
393 __glibcxx_check_valid_range2(__first, __last, __dist);
394 size_type __bucket_count = this->bucket_count();
396 if (__dist.
second >= __gnu_debug::__dp_sign)
397 _Base::insert(__gnu_debug::__unsafe(__first),
398 __gnu_debug::__unsafe(__last));
400 _Base::insert(__first, __last);
402 _M_check_rehashed(__bucket_count);
405 #if __cplusplus > 201402L 406 template <
typename... _Args>
408 try_emplace(
const key_type& __k, _Args&&... __args)
410 auto __res = _Base::try_emplace(__k,
411 std::forward<_Args>(__args)...);
412 return { iterator(__res.first,
this), __res.second };
415 template <
typename... _Args>
417 try_emplace(key_type&& __k, _Args&&... __args)
419 auto __res = _Base::try_emplace(std::move(__k),
420 std::forward<_Args>(__args)...);
421 return { iterator(__res.first,
this), __res.second };
424 template <
typename... _Args>
426 try_emplace(const_iterator __hint,
const key_type& __k,
430 return iterator(_Base::try_emplace(__hint.
base(), __k,
431 std::forward<_Args>(__args)...),
435 template <
typename... _Args>
437 try_emplace(const_iterator __hint, key_type&& __k, _Args&&... __args)
440 return iterator(_Base::try_emplace(__hint.
base(), std::move(__k),
441 std::forward<_Args>(__args)...),
445 template <
typename _Obj>
447 insert_or_assign(
const key_type& __k, _Obj&& __obj)
449 auto __res = _Base::insert_or_assign(__k,
450 std::forward<_Obj>(__obj));
451 return { iterator(__res.first,
this), __res.second };
454 template <
typename _Obj>
456 insert_or_assign(key_type&& __k, _Obj&& __obj)
458 auto __res = _Base::insert_or_assign(std::move(__k),
459 std::forward<_Obj>(__obj));
460 return { iterator(__res.first,
this), __res.second };
463 template <
typename _Obj>
465 insert_or_assign(const_iterator __hint,
const key_type& __k,
469 return iterator(_Base::insert_or_assign(__hint.
base(), __k,
470 std::forward<_Obj>(__obj)),
474 template <
typename _Obj>
476 insert_or_assign(const_iterator __hint, key_type&& __k, _Obj&& __obj)
479 return iterator(_Base::insert_or_assign(__hint.
base(),
481 std::forward<_Obj>(__obj)),
486 #if __cplusplus > 201402L 487 using node_type =
typename _Base::node_type;
488 using insert_return_type = _Node_insert_return<iterator, node_type>;
491 extract(const_iterator __position)
494 _Base_const_iterator __victim = __position.
base();
496 [__victim](_Base_const_iterator __it) {
return __it == __victim; }
499 [__victim](_Base_const_local_iterator __it) {
500 return __it._M_curr() == __victim._M_cur;
502 return _Base::extract(__position.
base());
506 extract(
const key_type& __key)
508 const auto __position = find(__key);
509 if (__position != end())
510 return extract(__position);
515 insert(node_type&& __nh)
517 auto __ret = _Base::insert(std::move(__nh));
518 iterator __pos = iterator(__ret.position,
this);
519 return { __pos, __ret.inserted, std::move(__ret.node) };
523 insert(const_iterator __hint, node_type&& __nh)
526 return iterator(_Base::insert(__hint.
base(), std::move(__nh)),
this);
533 find(
const key_type& __key)
534 {
return iterator(_Base::find(__key),
this); }
537 find(
const key_type& __key)
const 538 {
return const_iterator(_Base::find(__key),
this); }
541 equal_range(
const key_type& __key)
544 _Base::equal_range(__key);
546 iterator(__res.
second,
this));
550 equal_range(
const key_type& __key)
const 553 _Base::equal_range(__key);
555 const_iterator(__res.
second,
this));
559 erase(
const key_type& __key)
562 _Base_iterator __victim(_Base::find(__key));
563 if (__victim != _Base::end())
566 {
return __it == __victim; });
568 [__victim](_Base_const_local_iterator __it)
569 {
return __it._M_curr() == __victim._M_cur; });
570 size_type __bucket_count = this->bucket_count();
571 _Base::erase(__victim);
572 _M_check_rehashed(__bucket_count);
579 erase(const_iterator __it)
582 _Base_const_iterator __victim = __it.
base();
584 {
return __it == __victim; });
586 [__victim](_Base_const_local_iterator __it)
587 {
return __it._M_curr() == __victim._M_cur; });
588 size_type __bucket_count = this->bucket_count();
589 _Base_iterator __next = _Base::erase(__it.base());
590 _M_check_rehashed(__bucket_count);
591 return iterator(__next,
this);
596 {
return erase(const_iterator(__it)); }
599 erase(const_iterator __first, const_iterator __last)
602 for (_Base_const_iterator __tmp = __first.
base();
603 __tmp != __last.
base(); ++__tmp)
605 _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
606 _M_message(__gnu_debug::__msg_valid_range)
607 ._M_iterator(__first,
"first")
608 ._M_iterator(__last,
"last"));
610 {
return __it == __tmp; });
612 [__tmp](_Base_const_local_iterator __it)
613 {
return __it._M_curr() == __tmp._M_cur; });
615 size_type __bucket_count = this->bucket_count();
616 _Base_iterator __next = _Base::erase(__first.
base(), __last.
base());
617 _M_check_rehashed(__bucket_count);
618 return iterator(__next,
this);
622 _M_base() noexcept {
return *
this; }
625 _M_base()
const noexcept {
return *
this; }
629 _M_check_rehashed(size_type __prev_count)
631 if (__prev_count != this->bucket_count())
632 this->_M_invalidate_locals();
636 #if __cpp_deduction_guides >= 201606 638 template<
typename _InputIterator,
642 typename = _RequireInputIter<_InputIterator>,
643 typename = _RequireAllocator<_Allocator>>
645 typename unordered_map<int, int>::size_type = {},
646 _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
648 __iter_val_t<_InputIterator>,
649 _Hash, _Pred, _Allocator>;
651 template<
typename _Key,
typename _Tp,
typename _Hash = hash<_Key>,
652 typename _Pred = equal_to<_Key>,
653 typename _Allocator = allocator<pair<const _Key, _Tp>>,
654 typename = _RequireAllocator<_Allocator>>
656 typename unordered_map<int, int>::size_type = {},
657 _Hash = _Hash(), _Pred = _Pred(), _Allocator = _Allocator())
660 template<
typename _InputIterator,
typename _Allocator,
661 typename = _RequireInputIter<_InputIterator>,
662 typename = _RequireAllocator<_Allocator>>
664 typename unordered_map<int, int>::size_type, _Allocator)
666 __iter_val_t<_InputIterator>,
671 template<
typename _InputIterator,
typename _Allocator,
672 typename = _RequireInputIter<_InputIterator>,
673 typename = _RequireAllocator<_Allocator>>
676 __iter_val_t<_InputIterator>,
677 hash<__iter_key_t<_InputIterator>>,
678 equal_to<__iter_key_t<_InputIterator>>,
681 template<
typename _InputIterator,
typename _Hash,
typename _Allocator,
682 typename = _RequireInputIter<_InputIterator>,
683 typename = _RequireAllocator<_Allocator>>
685 typename unordered_map<int, int>::size_type,
688 __iter_val_t<_InputIterator>, _Hash,
689 equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
691 template<
typename _Key,
typename _Tp,
typename _Allocator,
692 typename = _RequireAllocator<_Allocator>>
694 typename unordered_map<int, int>::size_type,
698 template<
typename _Key,
typename _Tp,
typename _Allocator,
699 typename = _RequireAllocator<_Allocator>>
703 template<
typename _Key,
typename _Tp,
typename _Hash,
typename _Allocator,
704 typename = _RequireAllocator<_Allocator>>
706 typename unordered_map<int, int>::size_type,
712 template<
typename _Key,
typename _Tp,
typename _Hash,
713 typename _Pred,
typename _Alloc>
717 noexcept(noexcept(__x.swap(__y)))
720 template<
typename _Key,
typename _Tp,
typename _Hash,
721 typename _Pred,
typename _Alloc>
725 {
return __x._M_base() == __y._M_base(); }
727 template<
typename _Key,
typename _Tp,
typename _Hash,
728 typename _Pred,
typename _Alloc>
732 {
return !(__x == __y); }
736 template<
typename _Key,
typename _Tp,
742 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>, _Alloc,
743 __gnu_debug::_Safe_unordered_container>,
744 public _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>
746 typedef _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
747 _Pred, _Alloc>
_Base;
750 typedef typename _Base::const_iterator _Base_const_iterator;
751 typedef typename _Base::iterator _Base_iterator;
752 typedef typename _Base::const_local_iterator _Base_const_local_iterator;
753 typedef typename _Base::local_iterator _Base_local_iterator;
756 typedef typename _Base::size_type size_type;
757 typedef typename _Base::hasher hasher;
758 typedef typename _Base::key_equal key_equal;
759 typedef typename _Base::allocator_type allocator_type;
761 typedef typename _Base::key_type key_type;
762 typedef typename _Base::value_type value_type;
765 _Base_iterator, unordered_multimap>
iterator;
773 unordered_multimap() =
default;
776 unordered_multimap(size_type __n,
777 const hasher& __hf = hasher(),
778 const key_equal& __eql = key_equal(),
779 const allocator_type& __a = allocator_type())
780 : _Base(__n, __hf, __eql, __a) { }
782 template<
typename _InputIterator>
783 unordered_multimap(_InputIterator __first, _InputIterator __last,
785 const hasher& __hf = hasher(),
786 const key_equal& __eql = key_equal(),
787 const allocator_type& __a = allocator_type())
788 : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
790 __gnu_debug::__base(__last), __n,
791 __hf, __eql, __a) { }
793 unordered_multimap(
const unordered_multimap&) =
default;
795 unordered_multimap(
const _Base& __x)
798 unordered_multimap(unordered_multimap&&) =
default;
801 unordered_multimap(
const allocator_type& __a)
804 unordered_multimap(
const unordered_multimap& __umap,
805 const allocator_type& __a)
806 : _Base(__umap, __a) { }
808 unordered_multimap(unordered_multimap&& __umap,
809 const allocator_type& __a)
810 : _Safe(std::move(__umap._M_safe()), __a),
811 _Base(std::move(__umap._M_base()), __a) { }
815 const hasher& __hf = hasher(),
816 const key_equal& __eql = key_equal(),
817 const allocator_type& __a = allocator_type())
818 : _Base(__l, __n, __hf, __eql, __a) { }
820 unordered_multimap(size_type __n,
const allocator_type& __a)
821 : unordered_multimap(__n, hasher(), key_equal(), __a)
824 unordered_multimap(size_type __n,
const hasher& __hf,
825 const allocator_type& __a)
826 : unordered_multimap(__n, __hf, key_equal(), __a)
829 template<
typename _InputIterator>
830 unordered_multimap(_InputIterator __first, _InputIterator __last,
832 const allocator_type& __a)
833 : unordered_multimap(__first, __last, __n, hasher(), key_equal(), __a)
836 template<
typename _InputIterator>
837 unordered_multimap(_InputIterator __first, _InputIterator __last,
838 size_type __n,
const hasher& __hf,
839 const allocator_type& __a)
840 : unordered_multimap(__first, __last, __n, __hf, key_equal(), __a)
845 const allocator_type& __a)
846 : unordered_multimap(__l, __n, hasher(), key_equal(), __a)
850 size_type __n,
const hasher& __hf,
851 const allocator_type& __a)
852 : unordered_multimap(__l, __n, __hf, key_equal(), __a)
855 ~unordered_multimap() =
default;
858 operator=(
const unordered_multimap&) =
default;
861 operator=(unordered_multimap&&) =
default;
866 this->_M_base() = __l;
867 this->_M_invalidate_all();
872 swap(unordered_multimap& __x)
873 noexcept( noexcept(declval<_Base&>().swap(__x)) )
883 this->_M_invalidate_all();
888 {
return iterator(_Base::begin(),
this); }
891 begin()
const noexcept
892 {
return const_iterator(_Base::begin(),
this); }
896 {
return iterator(_Base::end(),
this); }
900 {
return const_iterator(_Base::end(),
this); }
904 {
return const_iterator(_Base::begin(),
this); }
907 cend()
const noexcept
908 {
return const_iterator(_Base::end(),
this); }
914 __glibcxx_check_bucket_index(__b);
915 return local_iterator(_Base::begin(__b),
this);
921 __glibcxx_check_bucket_index(__b);
922 return local_iterator(_Base::end(__b),
this);
926 begin(size_type __b)
const 928 __glibcxx_check_bucket_index(__b);
929 return const_local_iterator(_Base::begin(__b),
this);
933 end(size_type __b)
const 935 __glibcxx_check_bucket_index(__b);
936 return const_local_iterator(_Base::end(__b),
this);
940 cbegin(size_type __b)
const 942 __glibcxx_check_bucket_index(__b);
943 return const_local_iterator(_Base::cbegin(__b),
this);
947 cend(size_type __b)
const 949 __glibcxx_check_bucket_index(__b);
950 return const_local_iterator(_Base::cend(__b),
this);
954 bucket_size(size_type __b)
const 956 __glibcxx_check_bucket_index(__b);
957 return _Base::bucket_size(__b);
961 max_load_factor()
const noexcept
962 {
return _Base::max_load_factor(); }
965 max_load_factor(
float __f)
967 __glibcxx_check_max_load_factor(__f);
968 _Base::max_load_factor(__f);
971 template<
typename... _Args>
973 emplace(_Args&&... __args)
975 size_type __bucket_count = this->bucket_count();
977 = _Base::emplace(std::forward<_Args>(__args)...);
978 _M_check_rehashed(__bucket_count);
979 return iterator(__it,
this);
982 template<
typename... _Args>
984 emplace_hint(const_iterator __hint, _Args&&... __args)
987 size_type __bucket_count = this->bucket_count();
988 _Base_iterator __it = _Base::emplace_hint(__hint.
base(),
989 std::forward<_Args>(__args)...);
990 _M_check_rehashed(__bucket_count);
991 return iterator(__it,
this);
995 insert(
const value_type& __obj)
997 size_type __bucket_count = this->bucket_count();
998 _Base_iterator __it = _Base::insert(__obj);
999 _M_check_rehashed(__bucket_count);
1000 return iterator(__it,
this);
1006 insert(value_type&& __x)
1008 size_type __bucket_count = this->bucket_count();
1009 auto __it = _Base::insert(std::move(__x));
1010 _M_check_rehashed(__bucket_count);
1011 return { __it,
this };
1015 insert(const_iterator __hint,
const value_type& __obj)
1018 size_type __bucket_count = this->bucket_count();
1019 _Base_iterator __it = _Base::insert(__hint.
base(), __obj);
1020 _M_check_rehashed(__bucket_count);
1021 return iterator(__it,
this);
1027 insert(const_iterator __hint, value_type&& __x)
1030 size_type __bucket_count = this->bucket_count();
1031 auto __it = _Base::insert(__hint.
base(), std::move(__x));
1032 _M_check_rehashed(__bucket_count);
1033 return iterator(__it,
this);
1036 template<
typename _Pair,
typename =
typename 1038 _Pair&&>::value>::type>
1040 insert(_Pair&& __obj)
1042 size_type __bucket_count = this->bucket_count();
1043 _Base_iterator __it = _Base::insert(std::forward<_Pair>(__obj));
1044 _M_check_rehashed(__bucket_count);
1045 return iterator(__it,
this);
1048 template<
typename _Pair,
typename =
typename 1050 _Pair&&>::value>::type>
1052 insert(const_iterator __hint, _Pair&& __obj)
1055 size_type __bucket_count = this->bucket_count();
1056 _Base_iterator __it =
1057 _Base::insert(__hint.
base(), std::forward<_Pair>(__obj));
1058 _M_check_rehashed(__bucket_count);
1059 return iterator(__it,
this);
1064 { _Base::insert(__l); }
1066 template<
typename _InputIterator>
1068 insert(_InputIterator __first, _InputIterator __last)
1071 __glibcxx_check_valid_range2(__first, __last, __dist);
1072 size_type __bucket_count = this->bucket_count();
1074 if (__dist.
second >= __gnu_debug::__dp_sign)
1075 _Base::insert(__gnu_debug::__unsafe(__first),
1076 __gnu_debug::__unsafe(__last));
1078 _Base::insert(__first, __last);
1080 _M_check_rehashed(__bucket_count);
1083 #if __cplusplus > 201402L 1084 using node_type =
typename _Base::node_type;
1087 extract(const_iterator __position)
1090 _Base_const_iterator __victim = __position.
base();
1092 [__victim](_Base_const_iterator __it) {
return __it == __victim; }
1095 [__victim](_Base_const_local_iterator __it) {
1096 return __it._M_curr() == __victim._M_cur;
1098 return _Base::extract(__position.
base());
1102 extract(
const key_type& __key)
1104 const auto __position = find(__key);
1105 if (__position !=
end())
1106 return extract(__position);
1111 insert(node_type&& __nh)
1112 {
return iterator(_Base::insert(std::move(__nh)),
this); }
1115 insert(const_iterator __hint, node_type&& __nh)
1118 return iterator(_Base::insert(__hint.
base(), std::move(__nh)),
this);
1125 find(
const key_type& __key)
1126 {
return iterator(_Base::find(__key),
this); }
1129 find(
const key_type& __key)
const 1130 {
return const_iterator(_Base::find(__key),
this); }
1133 equal_range(
const key_type& __key)
1136 _Base::equal_range(__key);
1138 iterator(__res.
second,
this));
1142 equal_range(
const key_type& __key)
const 1145 _Base::equal_range(__key);
1147 const_iterator(__res.
second,
this));
1151 erase(
const key_type& __key)
1154 size_type __bucket_count = this->bucket_count();
1156 _Base::equal_range(__key);
1157 for (_Base_iterator __victim = __pair.
first; __victim != __pair.
second;)
1160 {
return __it == __victim; });
1162 [__victim](_Base_const_local_iterator __it)
1163 {
return __it._M_curr() == __victim._M_cur; });
1164 _Base::erase(__victim++);
1167 _M_check_rehashed(__bucket_count);
1172 erase(const_iterator __it)
1175 _Base_const_iterator __victim = __it.
base();
1177 {
return __it == __victim; });
1179 [__victim](_Base_const_local_iterator __it)
1180 {
return __it._M_curr() == __victim._M_cur; });
1181 size_type __bucket_count = this->bucket_count();
1182 _Base_iterator __next = _Base::erase(__it.base());
1183 _M_check_rehashed(__bucket_count);
1184 return iterator(__next,
this);
1188 erase(iterator __it)
1189 {
return erase(const_iterator(__it)); }
1192 erase(const_iterator __first, const_iterator __last)
1195 for (_Base_const_iterator __tmp = __first.
base();
1196 __tmp != __last.
base(); ++__tmp)
1198 _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
1199 _M_message(__gnu_debug::__msg_valid_range)
1200 ._M_iterator(__first,
"first")
1201 ._M_iterator(__last,
"last"));
1203 {
return __it == __tmp; });
1205 [__tmp](_Base_const_local_iterator __it)
1206 {
return __it._M_curr() == __tmp._M_cur; });
1208 size_type __bucket_count = this->bucket_count();
1209 _Base_iterator __next = _Base::erase(__first.
base(), __last.
base());
1210 _M_check_rehashed(__bucket_count);
1211 return iterator(__next,
this);
1215 _M_base() noexcept {
return *
this; }
1218 _M_base()
const noexcept {
return *
this; }
1222 _M_check_rehashed(size_type __prev_count)
1224 if (__prev_count != this->bucket_count())
1225 this->_M_invalidate_locals();
1229 #if __cpp_deduction_guides >= 201606 1231 template<
typename _InputIterator,
1232 typename _Hash = hash<__iter_key_t<_InputIterator>>,
1233 typename _Pred = equal_to<__iter_key_t<_InputIterator>>,
1235 typename = _RequireInputIter<_InputIterator>,
1236 typename = _RequireAllocator<_Allocator>>
1238 unordered_multimap<int, int>::size_type = {},
1239 _Hash = _Hash(), _Pred = _Pred(),
1240 _Allocator = _Allocator())
1242 __iter_val_t<_InputIterator>, _Hash, _Pred,
1245 template<
typename _Key,
typename _Tp,
typename _Hash = hash<_Key>,
1246 typename _Pred = equal_to<_Key>,
1247 typename _Allocator = allocator<pair<const _Key, _Tp>>,
1248 typename = _RequireAllocator<_Allocator>>
1250 unordered_multimap<int, int>::size_type = {},
1251 _Hash = _Hash(), _Pred = _Pred(),
1252 _Allocator = _Allocator())
1255 template<
typename _InputIterator,
typename _Allocator,
1256 typename = _RequireInputIter<_InputIterator>,
1257 typename = _RequireAllocator<_Allocator>>
1259 unordered_multimap<int, int>::size_type, _Allocator)
1261 __iter_val_t<_InputIterator>,
1262 hash<__iter_key_t<_InputIterator>>,
1263 equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
1265 template<
typename _InputIterator,
typename _Allocator,
1266 typename = _RequireInputIter<_InputIterator>,
1267 typename = _RequireAllocator<_Allocator>>
1270 __iter_val_t<_InputIterator>,
1271 hash<__iter_key_t<_InputIterator>>,
1272 equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
1274 template<
typename _InputIterator,
typename _Hash,
typename _Allocator,
1275 typename = _RequireInputIter<_InputIterator>,
1276 typename = _RequireAllocator<_Allocator>>
1278 unordered_multimap<int, int>::size_type, _Hash,
1281 __iter_val_t<_InputIterator>, _Hash,
1282 equal_to<__iter_key_t<_InputIterator>>, _Allocator>;
1284 template<
typename _Key,
typename _Tp,
typename _Allocator,
1285 typename = _RequireAllocator<_Allocator>>
1287 unordered_multimap<int, int>::size_type,
1291 template<
typename _Key,
typename _Tp,
typename _Allocator,
1292 typename = _RequireAllocator<_Allocator>>
1296 template<
typename _Key,
typename _Tp,
typename _Hash,
typename _Allocator,
1297 typename = _RequireAllocator<_Allocator>>
1299 unordered_multimap<int, int>::size_type,
1305 template<
typename _Key,
typename _Tp,
typename _Hash,
1306 typename _Pred,
typename _Alloc>
1310 noexcept(noexcept(__x.swap(__y)))
1313 template<
typename _Key,
typename _Tp,
typename _Hash,
1314 typename _Pred,
typename _Alloc>
1318 {
return __x._M_base() == __y._M_base(); }
1320 template<
typename _Key,
typename _Tp,
typename _Hash,
1321 typename _Pred,
typename _Alloc>
1325 {
return !(__x == __y); }
One of the comparison functors.
Struct holding two objects of arbitrary type.
The standard allocator, as per [20.4].
constexpr const _Tp * end(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to one past the last element of the initializer_list. ...
Primary class template hash.
#define __glibcxx_check_erase_range(_First, _Last)
constexpr auto cbegin(const _Container &__cont) noexcept(noexcept(std::begin(__cont))) -> decltype(std::begin(__cont))
Return an iterator pointing to the first element of the const container.
constexpr pair< typename __decay_and_strip< _T1 >::__type, typename __decay_and_strip< _T2 >::__type > make_pair(_T1 &&__x, _T2 &&__y)
A convenience wrapper for creating a pair from two objects.
constexpr const _Tp * begin(initializer_list< _Tp > __ils) noexcept
Return an iterator pointing to the first element of the initializer_list.
void _M_invalidate_if(_Predicate __pred)
_Iterator & base() noexcept
Return the underlying iterator.
constexpr auto cend(const _Container &__cont) noexcept(noexcept(std::end(__cont))) -> decltype(std::end(__cont))
Return an iterator pointing to one past the last element of the const container.
Base class for constructing a safe unordered container type that tracks iterators that reference it...
Class std::unordered_multimap with safety/checking/debug instrumentation.
ISO C++ entities toplevel namespace is std.
Safe class dealing with some allocator dependent operations.
Define a member typedef type only if a boolean constant is true.
#define __glibcxx_check_erase(_Position)
Base class that supports tracking of iterators that reference a sequence.
_T2 second
first is a copy of the first object
Class std::unordered_map with safety/checking/debug instrumentation.
_T1 first
second_type is the second bound type
#define __glibcxx_check_insert(_Position)
void _M_invalidate_local_if(_Predicate __pred)