30 #ifndef _GLIBCXX_DEBUG_UNORDERED_MAP
31 #define _GLIBCXX_DEBUG_UNORDERED_MAP 1
33 #ifndef __GXX_EXPERIMENTAL_CXX0X__
42 namespace std _GLIBCXX_VISIBILITY(default)
47 template<
typename _Key,
typename _Tp,
52 :
public _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
54 _Hash, _Pred, _Alloc> >
56 typedef _GLIBCXX_STD_C::unordered_map<_Key, _Tp, _Hash,
59 typedef typename _Base::const_iterator _Base_const_iterator;
60 typedef typename _Base::iterator _Base_iterator;
61 typedef typename _Base::const_local_iterator _Base_const_local_iterator;
62 typedef typename _Base::local_iterator _Base_local_iterator;
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;
70 typedef typename _Base::key_type key_type;
71 typedef typename _Base::value_type value_type;
84 const hasher& __hf = hasher(),
85 const key_equal& __eql = key_equal(),
86 const allocator_type& __a = allocator_type())
87 :
_Base(__n, __hf, __eql, __a) { }
89 template<
typename _InputIterator>
92 const hasher& __hf = hasher(),
93 const key_equal& __eql = key_equal(),
94 const allocator_type& __a = allocator_type())
107 :
_Base(std::move(__x)) { }
111 const hasher& __hf = hasher(),
112 const key_equal& __eql = key_equal(),
113 const allocator_type& __a = allocator_type())
114 :
_Base(__l, __n, __hf, __eql, __a) { }
121 *
static_cast<_Base*
>(
this) = __x;
122 this->_M_invalidate_all();
155 this->_M_invalidate_all();
160 {
return iterator(_Base::begin(),
this); }
163 begin()
const noexcept
168 {
return iterator(_Base::end(),
this); }
175 cbegin()
const noexcept
179 cend()
const noexcept
192 begin(size_type __b)
const
196 end(size_type __b)
const
200 cbegin(size_type __b)
const
204 cend(size_type __b)
const
207 template<
typename... _Args>
209 emplace(_Args&&... __args)
211 size_type __bucket_count = this->bucket_count();
213 = _Base::emplace(std::forward<_Args>(__args)...);
214 _M_check_rehashed(__bucket_count);
218 template<
typename... _Args>
223 size_type __bucket_count = this->bucket_count();
224 _Base_iterator __it = _Base::emplace_hint(__hint.
base(),
225 std::forward<_Args>(__args)...);
226 _M_check_rehashed(__bucket_count);
231 insert(
const value_type& __obj)
233 size_type __bucket_count = this->bucket_count();
235 _M_check_rehashed(__bucket_count);
243 size_type __bucket_count = this->bucket_count();
244 _Base_iterator __it = _Base::insert(__hint.
base(), __obj);
245 _M_check_rehashed(__bucket_count);
249 template<
typename _Pair,
typename =
typename
251 _Pair&&>::value>::type>
253 insert(_Pair&& __obj)
255 size_type __bucket_count = this->bucket_count();
257 _Base::insert(std::forward<_Pair>(__obj));
258 _M_check_rehashed(__bucket_count);
262 template<
typename _Pair,
typename =
typename
264 _Pair&&>::value>::type>
269 size_type __bucket_count = this->bucket_count();
270 _Base_iterator __it =
271 _Base::insert(__hint.
base(), std::forward<_Pair>(__obj));
272 _M_check_rehashed(__bucket_count);
279 size_type __bucket_count = this->bucket_count();
281 _M_check_rehashed(__bucket_count);
284 template<
typename _InputIterator>
286 insert(_InputIterator __first, _InputIterator __last)
288 __glibcxx_check_valid_range(__first, __last);
289 size_type __bucket_count = this->bucket_count();
292 _M_check_rehashed(__bucket_count);
296 find(
const key_type& __key)
297 {
return iterator(_Base::find(__key),
this); }
300 find(
const key_type& __key)
const
304 equal_range(
const key_type& __key)
307 _Base::equal_range(__key);
313 equal_range(
const key_type& __key)
const
316 _Base::equal_range(__key);
322 erase(
const key_type& __key)
325 _Base_iterator __victim(_Base::find(__key));
326 if (__victim != _Base::end())
329 {
return __it == __victim; });
330 _Base_local_iterator __local_victim = _S_to_local(__victim);
332 [__local_victim](_Base_const_local_iterator __it)
333 {
return __it == __local_victim; });
334 size_type __bucket_count = this->bucket_count();
335 _Base::erase(__victim);
336 _M_check_rehashed(__bucket_count);
346 _Base_const_iterator __victim = __it.
base();
348 {
return __it == __victim; });
349 _Base_const_local_iterator __local_victim = _S_to_local(__victim);
351 [__local_victim](_Base_const_local_iterator __it)
352 {
return __it == __local_victim; });
353 size_type __bucket_count = this->bucket_count();
354 _Base_iterator __next = _Base::erase(__it.base());
355 _M_check_rehashed(__bucket_count);
367 for (_Base_const_iterator __tmp = __first.
base();
368 __tmp != __last.
base(); ++__tmp)
370 _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
371 _M_message(__gnu_debug::__msg_valid_range)
372 ._M_iterator(__first,
"first")
373 ._M_iterator(__last,
"last"));
375 {
return __it == __tmp; });
376 _Base_const_local_iterator __local_tmp = _S_to_local(__tmp);
378 [__local_tmp](_Base_const_local_iterator __it)
379 {
return __it == __local_tmp; });
381 size_type __bucket_count = this->bucket_count();
382 _Base_iterator __next = _Base::erase(__first.
base(), __last.
base());
383 _M_check_rehashed(__bucket_count);
388 _M_base() noexcept {
return *
this; }
391 _M_base()
const noexcept {
return *
this; }
395 _M_invalidate_locals()
397 _Base_local_iterator __local_end = _Base::end(0);
399 [__local_end](_Base_const_local_iterator __it)
400 {
return __it != __local_end; });
406 _Base_iterator __end = _Base::end();
408 {
return __it != __end; });
409 _M_invalidate_locals();
413 _M_check_rehashed(size_type __prev_count)
415 if (__prev_count != this->bucket_count())
416 _M_invalidate_locals();
419 static _Base_local_iterator
420 _S_to_local(_Base_iterator __it)
424 return _Base_local_iterator(__it._M_cur, 0, 0);
427 static _Base_const_local_iterator
428 _S_to_local(_Base_const_iterator __it)
432 return _Base_const_local_iterator(__it._M_cur, 0, 0);
436 template<
typename _Key,
typename _Tp,
typename _Hash,
437 typename _Pred,
typename _Alloc>
443 template<
typename _Key,
typename _Tp,
typename _Hash,
444 typename _Pred,
typename _Alloc>
448 {
return __x._M_equal(__y); }
450 template<
typename _Key,
typename _Tp,
typename _Hash,
451 typename _Pred,
typename _Alloc>
453 operator!=(
const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
454 const unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
455 {
return !(__x == __y); }
459 template<
typename _Key,
typename _Tp,
464 :
public _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
467 _Tp, _Hash, _Pred, _Alloc> >
469 typedef _GLIBCXX_STD_C::unordered_multimap<_Key, _Tp, _Hash,
470 _Pred, _Alloc>
_Base;
473 typedef typename _Base::const_iterator _Base_const_iterator;
474 typedef typename _Base::iterator _Base_iterator;
475 typedef typename _Base::const_local_iterator _Base_const_local_iterator;
476 typedef typename _Base::local_iterator _Base_local_iterator;
479 typedef typename _Base::size_type size_type;
480 typedef typename _Base::hasher hasher;
481 typedef typename _Base::key_equal key_equal;
482 typedef typename _Base::allocator_type allocator_type;
484 typedef typename _Base::key_type key_type;
485 typedef typename _Base::value_type value_type;
498 const hasher& __hf = hasher(),
499 const key_equal& __eql = key_equal(),
500 const allocator_type& __a = allocator_type())
501 :
_Base(__n, __hf, __eql, __a) { }
503 template<
typename _InputIterator>
506 const hasher& __hf = hasher(),
507 const key_equal& __eql = key_equal(),
508 const allocator_type& __a = allocator_type())
512 __hf, __eql, __a) { }
521 :
_Base(std::move(__x)) { }
525 const hasher& __hf = hasher(),
526 const key_equal& __eql = key_equal(),
527 const allocator_type& __a = allocator_type())
528 :
_Base(__l, __n, __hf, __eql, __a) { }
535 *
static_cast<_Base*
>(
this) = __x;
536 this->_M_invalidate_all();
569 this->_M_invalidate_all();
574 {
return iterator(_Base::begin(),
this); }
577 begin()
const noexcept
582 {
return iterator(_Base::end(),
this); }
589 cbegin()
const noexcept
593 cend()
const noexcept
606 begin(size_type __b)
const
610 end(size_type __b)
const
614 cbegin(size_type __b)
const
618 cend(size_type __b)
const
621 template<
typename... _Args>
623 emplace(_Args&&... __args)
625 size_type __bucket_count = this->bucket_count();
627 = _Base::emplace(std::forward<_Args>(__args)...);
628 _M_check_rehashed(__bucket_count);
632 template<
typename... _Args>
637 size_type __bucket_count = this->bucket_count();
638 _Base_iterator __it = _Base::emplace_hint(__hint.
base(),
639 std::forward<_Args>(__args)...);
640 _M_check_rehashed(__bucket_count);
645 insert(
const value_type& __obj)
647 size_type __bucket_count = this->bucket_count();
648 _Base_iterator __it = _Base::insert(__obj);
649 _M_check_rehashed(__bucket_count);
657 size_type __bucket_count = this->bucket_count();
658 _Base_iterator __it = _Base::insert(__hint.
base(), __obj);
659 _M_check_rehashed(__bucket_count);
663 template<
typename _Pair,
typename =
typename
665 _Pair&&>::value>::type>
667 insert(_Pair&& __obj)
669 size_type __bucket_count = this->bucket_count();
670 _Base_iterator __it = _Base::insert(std::forward<_Pair>(__obj));
671 _M_check_rehashed(__bucket_count);
675 template<
typename _Pair,
typename =
typename
677 _Pair&&>::value>::type>
682 size_type __bucket_count = this->bucket_count();
683 _Base_iterator __it =
684 _Base::insert(__hint.
base(), std::forward<_Pair>(__obj));
685 _M_check_rehashed(__bucket_count);
691 { _Base::insert(__l); }
693 template<
typename _InputIterator>
695 insert(_InputIterator __first, _InputIterator __last)
697 __glibcxx_check_valid_range(__first, __last);
698 size_type __bucket_count = this->bucket_count();
701 _M_check_rehashed(__bucket_count);
705 find(
const key_type& __key)
706 {
return iterator(_Base::find(__key),
this); }
709 find(
const key_type& __key)
const
713 equal_range(
const key_type& __key)
716 _Base::equal_range(__key);
722 equal_range(
const key_type& __key)
const
725 _Base::equal_range(__key);
731 erase(
const key_type& __key)
734 size_type __bucket_count = this->bucket_count();
736 _Base::equal_range(__key);
737 for (_Base_iterator __victim = __pair.
first; __victim != __pair.
second;)
740 {
return __it == __victim; });
741 _Base_local_iterator __local_victim = _S_to_local(__victim);
743 [__local_victim](_Base_const_local_iterator __it)
744 {
return __it == __local_victim; });
745 _Base::erase(__victim++);
748 _M_check_rehashed(__bucket_count);
756 _Base_const_iterator __victim = __it.
base();
758 {
return __it == __victim; });
759 _Base_const_local_iterator __local_victim = _S_to_local(__victim);
761 [__local_victim](_Base_const_local_iterator __it)
762 {
return __it == __local_victim; });
763 size_type __bucket_count = this->bucket_count();
764 _Base_iterator __next = _Base::erase(__it.base());
765 _M_check_rehashed(__bucket_count);
777 for (_Base_const_iterator __tmp = __first.
base();
778 __tmp != __last.
base(); ++__tmp)
780 _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
781 _M_message(__gnu_debug::__msg_valid_range)
782 ._M_iterator(__first,
"first")
783 ._M_iterator(__last,
"last"));
785 {
return __it == __tmp; });
786 _Base_const_local_iterator __local_tmp = _S_to_local(__tmp);
788 [__local_tmp](_Base_const_local_iterator __it)
789 {
return __it == __local_tmp; });
791 size_type __bucket_count = this->bucket_count();
792 _Base_iterator __next = _Base::erase(__first.
base(), __last.
base());
793 _M_check_rehashed(__bucket_count);
798 _M_base() noexcept {
return *
this; }
801 _M_base()
const noexcept {
return *
this; }
805 _M_invalidate_locals()
807 _Base_local_iterator __local_end = _Base::end(0);
809 [__local_end](_Base_const_local_iterator __it)
810 {
return __it != __local_end; });
816 _Base_iterator __end = _Base::end();
818 {
return __it != __end; });
819 _M_invalidate_locals();
823 _M_check_rehashed(size_type __prev_count)
825 if (__prev_count != this->bucket_count())
826 _M_invalidate_locals();
829 static _Base_local_iterator
830 _S_to_local(_Base_iterator __it)
834 return _Base_local_iterator(__it._M_cur, 0, 0);
837 static _Base_const_local_iterator
838 _S_to_local(_Base_const_iterator __it)
842 return _Base_const_local_iterator(__it._M_cur, 0, 0);
846 template<
typename _Key,
typename _Tp,
typename _Hash,
847 typename _Pred,
typename _Alloc>
853 template<
typename _Key,
typename _Tp,
typename _Hash,
854 typename _Pred,
typename _Alloc>
858 {
return __x._M_equal(__y); }
860 template<
typename _Key,
typename _Tp,
typename _Hash,
861 typename _Pred,
typename _Alloc>
863 operator!=(
const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
864 const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
865 {
return !(__x == __y); }
870 #endif // __GXX_EXPERIMENTAL_CXX0X__