30 #ifndef _GLIBCXX_DEBUG_UNORDERED_MAP
31 #define _GLIBCXX_DEBUG_UNORDERED_MAP 1
33 #ifdef __GXX_EXPERIMENTAL_CXX0X__
47 template<
typename _Key,
typename _Tp,
52 :
public _GLIBCXX_STD_D::unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>,
56 typedef _GLIBCXX_STD_D::unordered_map<_Key, _Tp, _Hash,
61 typedef typename _Base::size_type size_type;
62 typedef typename _Base::hasher hasher;
63 typedef typename _Base::key_equal key_equal;
64 typedef typename _Base::allocator_type allocator_type;
66 typedef typename _Base::key_type key_type;
67 typedef typename _Base::value_type value_type;
70 unordered_map> iterator;
72 unordered_map> const_iterator;
75 unordered_map(size_type __n = 10,
76 const hasher& __hf = hasher(),
77 const key_equal& __eql = key_equal(),
78 const allocator_type& __a = allocator_type())
79 : _Base(__n, __hf, __eql, __a) { }
81 template<
typename _InputIterator>
82 unordered_map(_InputIterator __f, _InputIterator __l,
84 const hasher& __hf = hasher(),
85 const key_equal& __eql = key_equal(),
86 const allocator_type& __a = allocator_type())
87 : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n,
88 __hf, __eql, __a), _Safe_base() { }
90 unordered_map(
const unordered_map& __x)
91 : _Base(__x), _Safe_base() { }
93 unordered_map(
const _Base& __x)
94 : _Base(__x), _Safe_base() { }
96 unordered_map(unordered_map&& __x)
97 : _Base(std::forward<unordered_map>(__x)), _Safe_base() { }
99 unordered_map(initializer_list<value_type> __l,
101 const hasher& __hf = hasher(),
102 const key_equal& __eql = key_equal(),
103 const allocator_type& __a = allocator_type())
104 : _Base(__l, __n, __hf, __eql, __a), _Safe_base() { }
107 operator=(
const unordered_map& __x)
109 *
static_cast<_Base*
>(
this) = __x;
115 operator=(unordered_map&& __x)
124 operator=(initializer_list<value_type> __l)
132 swap(unordered_map&& __x)
147 {
return iterator(_Base::begin(),
this); }
151 {
return const_iterator(_Base::begin(),
this); }
155 {
return iterator(_Base::end(),
this); }
159 {
return const_iterator(_Base::end(),
this); }
163 {
return const_iterator(_Base::begin(),
this); }
167 {
return const_iterator(_Base::end(),
this); }
176 insert(
const value_type& __obj)
179 __pair_type __res = _Base::insert(__obj);
180 return std::make_pair(iterator(__res.first,
this), __res.second);
184 insert(iterator,
const value_type& __obj)
187 __pair_type __res = _Base::insert(__obj);
188 return iterator(__res.first,
this);
192 insert(const_iterator,
const value_type& __obj)
195 __pair_type __res = _Base::insert(__obj);
196 return const_iterator(__res.first,
this);
201 { _Base::insert(__l); }
203 template<
typename _InputIterator>
205 insert(_InputIterator __first, _InputIterator __last)
207 __glibcxx_check_valid_range(__first, __last);
208 _Base::insert(__first, __last);
212 find(
const key_type& __key)
213 {
return iterator(_Base::find(__key),
this); }
216 find(
const key_type& __key)
const
217 {
return const_iterator(_Base::find(__key),
this); }
220 equal_range(
const key_type& __key)
222 typedef typename _Base::iterator _Base_iterator;
224 __pair_type __res = _Base::equal_range(__key);
225 return std::make_pair(iterator(__res.first,
this),
226 iterator(__res.second,
this));
230 equal_range(
const key_type& __key)
const
232 typedef typename _Base::const_iterator _Base_iterator;
234 __pair_type __res = _Base::equal_range(__key);
235 return std::make_pair(const_iterator(__res.first,
this),
236 const_iterator(__res.second,
this));
240 erase(
const key_type& __key)
243 iterator __victim(_Base::find(__key),
this);
244 if (__victim != end())
246 this->erase(__victim);
256 __it._M_invalidate();
257 return iterator(_Base::erase(__it.base()),
this);
261 erase(const_iterator __it)
264 __it._M_invalidate();
265 return const_iterator(_Base::erase(__it.base()),
this);
269 erase(iterator __first, iterator __last)
272 for (iterator __tmp = __first; __tmp != __last;)
274 iterator __victim = __tmp++;
275 __victim._M_invalidate();
277 return iterator(_Base::erase(__first.base(),
278 __last.base()),
this);
282 erase(const_iterator __first, const_iterator __last)
285 for (const_iterator __tmp = __first; __tmp != __last;)
287 const_iterator __victim = __tmp++;
288 __victim._M_invalidate();
290 return const_iterator(_Base::erase(__first.base(),
291 __last.base()),
this);
295 _M_base() {
return *
this; }
298 _M_base()
const {
return *
this; }
304 typedef typename _Base::const_iterator _Base_const_iterator;
310 template<
typename _Key,
typename _Tp,
typename _Hash,
311 typename _Pred,
typename _Alloc>
313 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
314 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
317 template<
typename _Key,
typename _Tp,
typename _Hash,
318 typename _Pred,
typename _Alloc>
320 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
321 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
324 template<
typename _Key,
typename _Tp,
typename _Hash,
325 typename _Pred,
typename _Alloc>
327 swap(unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
328 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
332 template<
typename _Key,
typename _Tp,
336 class unordered_multimap
337 :
public _GLIBCXX_STD_D::unordered_multimap<_Key, _Tp, _Hash,
342 typedef _GLIBCXX_STD_D::unordered_multimap<_Key, _Tp, _Hash,
343 _Pred, _Alloc> _Base;
347 typedef typename _Base::size_type size_type;
348 typedef typename _Base::hasher hasher;
349 typedef typename _Base::key_equal key_equal;
350 typedef typename _Base::allocator_type allocator_type;
352 typedef typename _Base::key_type key_type;
353 typedef typename _Base::value_type value_type;
356 unordered_multimap> iterator;
358 unordered_multimap> const_iterator;
361 unordered_multimap(size_type __n = 10,
362 const hasher& __hf = hasher(),
363 const key_equal& __eql = key_equal(),
364 const allocator_type& __a = allocator_type())
365 : _Base(__n, __hf, __eql, __a) { }
367 template<
typename _InputIterator>
368 unordered_multimap(_InputIterator __f, _InputIterator __l,
370 const hasher& __hf = hasher(),
371 const key_equal& __eql = key_equal(),
372 const allocator_type& __a = allocator_type())
373 : _Base(__gnu_debug::__check_valid_range(__f, __l), __l, __n,
374 __hf, __eql, __a), _Safe_base() { }
376 unordered_multimap(
const unordered_multimap& __x)
377 : _Base(__x), _Safe_base() { }
379 unordered_multimap(
const _Base& __x)
380 : _Base(__x), _Safe_base() { }
382 unordered_multimap(unordered_multimap&& __x)
383 : _Base(std::forward<unordered_multimap>(__x)), _Safe_base() { }
385 unordered_multimap(initializer_list<value_type> __l,
387 const hasher& __hf = hasher(),
388 const key_equal& __eql = key_equal(),
389 const allocator_type& __a = allocator_type())
390 : _Base(__l, __n, __hf, __eql, __a), _Safe_base() { }
393 operator=(
const unordered_multimap& __x)
395 *
static_cast<_Base*
>(
this) = __x;
401 operator=(unordered_multimap&& __x)
410 operator=(initializer_list<value_type> __l)
418 swap(unordered_multimap&& __x)
433 {
return iterator(_Base::begin(),
this); }
437 {
return const_iterator(_Base::begin(),
this); }
441 {
return iterator(_Base::end(),
this); }
445 {
return const_iterator(_Base::end(),
this); }
449 {
return const_iterator(_Base::begin(),
this); }
453 {
return const_iterator(_Base::end(),
this); }
462 insert(
const value_type& __obj)
463 {
return iterator(_Base::insert(__obj),
this); }
466 insert(iterator,
const value_type& __obj)
467 {
return iterator(_Base::insert(__obj),
this); }
470 insert(const_iterator,
const value_type& __obj)
471 {
return const_iterator(_Base::insert(__obj),
this); }
475 { _Base::insert(__l); }
477 template<
typename _InputIterator>
479 insert(_InputIterator __first, _InputIterator __last)
481 __glibcxx_check_valid_range(__first, __last);
482 _Base::insert(__first, __last);
486 find(
const key_type& __key)
487 {
return iterator(_Base::find(__key),
this); }
490 find(
const key_type& __key)
const
491 {
return const_iterator(_Base::find(__key),
this); }
494 equal_range(
const key_type& __key)
496 typedef typename _Base::iterator _Base_iterator;
498 __pair_type __res = _Base::equal_range(__key);
499 return std::make_pair(iterator(__res.first,
this),
500 iterator(__res.second,
this));
504 equal_range(
const key_type& __key)
const
506 typedef typename _Base::const_iterator _Base_iterator;
508 __pair_type __res = _Base::equal_range(__key);
509 return std::make_pair(const_iterator(__res.first,
this),
510 const_iterator(__res.second,
this));
514 erase(
const key_type& __key)
517 iterator __victim(_Base::find(__key),
this);
518 if (__victim != end())
520 this->erase(__victim);
530 __it._M_invalidate();
531 return iterator(_Base::erase(__it.base()),
this);
535 erase(const_iterator __it)
538 __it._M_invalidate();
539 return const_iterator(_Base::erase(__it.base()),
this);
543 erase(iterator __first, iterator __last)
546 for (iterator __tmp = __first; __tmp != __last;)
548 iterator __victim = __tmp++;
549 __victim._M_invalidate();
551 return iterator(_Base::erase(__first.base(),
552 __last.base()),
this);
556 erase(const_iterator __first, const_iterator __last)
559 for (const_iterator __tmp = __first; __tmp != __last;)
561 const_iterator __victim = __tmp++;
562 __victim._M_invalidate();
564 return const_iterator(_Base::erase(__first.base(),
565 __last.base()),
this);
569 _M_base() {
return *
this; }
572 _M_base()
const {
return *
this; }
578 typedef typename _Base::const_iterator _Base_const_iterator;
584 template<
typename _Key,
typename _Tp,
typename _Hash,
585 typename _Pred,
typename _Alloc>
587 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
588 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
591 template<
typename _Key,
typename _Tp,
typename _Hash,
592 typename _Pred,
typename _Alloc>
594 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __x,
595 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __y)
598 template<
typename _Key,
typename _Tp,
typename _Hash,
599 typename _Pred,
typename _Alloc>
601 swap(unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
602 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&& __y)
void _M_invalidate_if(_Predicate __pred)
pair holds two objects of arbitrary type.
#define __glibcxx_check_erase(_Position)
Base class for constructing a "safe" sequence type that tracks iterators that reference it...
The "standard" allocator, as per [20.4].Further details: http://gcc.gnu.org/onlinedocs/libstdc++/manu...
void _M_invalidate_all() const
#define __glibcxx_check_erase_range(_First, _Last)
void _M_swap(_Safe_sequence_base &__x)
One of the comparison functors.