30 #ifndef _GLIBCXX_DEBUG_MULTIMAP_H
31 #define _GLIBCXX_DEBUG_MULTIMAP_H 1
41 template<
typename _Key,
typename _Tp,
typename _Compare = std::less<_Key>,
42 typename _Allocator = std::allocator<std::pair<const _Key, _Tp> > >
44 :
public _GLIBCXX_STD_D::multimap<_Key, _Tp, _Compare, _Allocator>,
46 _Compare, _Allocator> >
48 typedef _GLIBCXX_STD_D::multimap<_Key, _Tp, _Compare, _Allocator> _Base;
53 typedef _Key key_type;
54 typedef _Tp mapped_type;
56 typedef _Compare key_compare;
57 typedef _Allocator allocator_type;
58 typedef typename _Base::reference reference;
59 typedef typename _Base::const_reference const_reference;
64 multimap> const_iterator;
66 typedef typename _Base::size_type size_type;
67 typedef typename _Base::difference_type difference_type;
68 typedef typename _Base::pointer pointer;
69 typedef typename _Base::const_pointer const_pointer;
73 using _Base::value_compare;
76 explicit multimap(
const _Compare& __comp = _Compare(),
77 const _Allocator& __a = _Allocator())
78 : _Base(__comp, __a) { }
80 template<
typename _InputIterator>
81 multimap(_InputIterator __first, _InputIterator __last,
82 const _Compare& __comp = _Compare(),
83 const _Allocator& __a = _Allocator())
84 : _Base(__gnu_debug::__check_valid_range(__first, __last), __last,
87 multimap(
const multimap& __x)
88 : _Base(__x), _Safe_base() { }
90 multimap(
const _Base& __x)
91 : _Base(__x), _Safe_base() { }
93 #ifdef __GXX_EXPERIMENTAL_CXX0X__
94 multimap(multimap&& __x)
95 : _Base(std::forward<multimap>(__x)), _Safe_base()
98 multimap(initializer_list<value_type> __l,
99 const _Compare& __c = _Compare(),
100 const allocator_type& __a = allocator_type())
101 : _Base(__l, __c, __a), _Safe_base() { }
107 operator=(
const multimap& __x)
109 *
static_cast<_Base*
>(
this) = __x;
114 #ifdef __GXX_EXPERIMENTAL_CXX0X__
116 operator=(multimap&& __x)
125 operator=(initializer_list<value_type> __l)
133 using _Base::get_allocator;
138 {
return iterator(_Base::begin(),
this); }
142 {
return const_iterator(_Base::begin(),
this); }
146 {
return iterator(_Base::end(),
this); }
150 {
return const_iterator(_Base::end(),
this); }
154 {
return reverse_iterator(end()); }
156 const_reverse_iterator
158 {
return const_reverse_iterator(end()); }
162 {
return reverse_iterator(begin()); }
164 const_reverse_iterator
166 {
return const_reverse_iterator(begin()); }
168 #ifdef __GXX_EXPERIMENTAL_CXX0X__
171 {
return const_iterator(_Base::begin(),
this); }
175 {
return const_iterator(_Base::end(),
this); }
177 const_reverse_iterator
179 {
return const_reverse_iterator(end()); }
181 const_reverse_iterator
183 {
return const_reverse_iterator(begin()); }
189 using _Base::max_size;
193 insert(
const value_type& __x)
194 {
return iterator(_Base::insert(__x),
this); }
196 #ifdef __GXX_EXPERIMENTAL_CXX0X__
199 { _Base::insert(__list); }
203 insert(iterator __position,
const value_type& __x)
206 return iterator(_Base::insert(__position.base(), __x),
this);
209 template<
typename _InputIterator>
211 insert(_InputIterator __first, _InputIterator __last)
213 __glibcxx_check_valid_range(__first, __last);
214 _Base::insert(__first, __last);
218 erase(iterator __position)
221 __position._M_invalidate();
222 _Base::erase(__position.base());
226 erase(
const key_type& __x)
229 size_type __count = 0;
232 iterator __victim = __victims.
first++;
234 _Base::erase(__victim.base());
241 erase(iterator __first, iterator __last)
246 while (__first != __last)
247 this->erase(__first++);
251 #ifdef __GXX_EXPERIMENTAL_CXX0X__
263 { this->erase(begin(), end()); }
266 using _Base::key_comp;
267 using _Base::value_comp;
271 find(
const key_type& __x)
272 {
return iterator(_Base::find(__x),
this); }
275 find(
const key_type& __x)
const
276 {
return const_iterator(_Base::find(__x),
this); }
281 lower_bound(
const key_type& __x)
282 {
return iterator(_Base::lower_bound(__x),
this); }
285 lower_bound(
const key_type& __x)
const
286 {
return const_iterator(_Base::lower_bound(__x),
this); }
289 upper_bound(
const key_type& __x)
290 {
return iterator(_Base::upper_bound(__x),
this); }
293 upper_bound(
const key_type& __x)
const
294 {
return const_iterator(_Base::upper_bound(__x),
this); }
297 equal_range(
const key_type& __x)
299 typedef typename _Base::iterator _Base_iterator;
301 _Base::equal_range(__x);
302 return std::make_pair(iterator(__res.
first,
this),
303 iterator(__res.
second,
this));
307 equal_range(
const key_type& __x)
const
309 typedef typename _Base::const_iterator _Base_const_iterator;
311 _Base::equal_range(__x);
312 return std::make_pair(const_iterator(__res.
first,
this),
313 const_iterator(__res.
second,
this));
317 _M_base() {
return *
this; }
320 _M_base()
const {
return *
this; }
326 typedef typename _Base::const_iterator _Base_const_iterator;
332 template<
typename _Key,
typename _Tp,
333 typename _Compare,
typename _Allocator>
335 operator==(
const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
336 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
337 {
return __lhs._M_base() == __rhs._M_base(); }
339 template<
typename _Key,
typename _Tp,
340 typename _Compare,
typename _Allocator>
342 operator!=(
const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
343 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
344 {
return __lhs._M_base() != __rhs._M_base(); }
346 template<
typename _Key,
typename _Tp,
347 typename _Compare,
typename _Allocator>
349 operator<(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
350 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
351 {
return __lhs._M_base() < __rhs._M_base(); }
353 template<
typename _Key,
typename _Tp,
354 typename _Compare,
typename _Allocator>
356 operator<=(const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
357 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
358 {
return __lhs._M_base() <= __rhs._M_base(); }
360 template<
typename _Key,
typename _Tp,
361 typename _Compare,
typename _Allocator>
363 operator>=(
const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
364 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
365 {
return __lhs._M_base() >= __rhs._M_base(); }
367 template<
typename _Key,
typename _Tp,
368 typename _Compare,
typename _Allocator>
370 operator>(
const multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
371 const multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
372 {
return __lhs._M_base() > __rhs._M_base(); }
374 template<
typename _Key,
typename _Tp,
375 typename _Compare,
typename _Allocator>
377 swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
378 multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
379 { __lhs.swap(__rhs); }
381 #ifdef __GXX_EXPERIMENTAL_CXX0X__
382 template<
typename _Key,
typename _Tp,
383 typename _Compare,
typename _Allocator>
385 swap(multimap<_Key, _Tp, _Compare, _Allocator>&& __lhs,
386 multimap<_Key, _Tp, _Compare, _Allocator>& __rhs)
387 { __lhs.swap(__rhs); }
389 template<
typename _Key,
typename _Tp,
390 typename _Compare,
typename _Allocator>
392 swap(multimap<_Key, _Tp, _Compare, _Allocator>& __lhs,
393 multimap<_Key, _Tp, _Compare, _Allocator>&& __rhs)
394 { __lhs.swap(__rhs); }
void _M_invalidate_if(_Predicate __pred)
pair holds two objects of arbitrary type.
#define __glibcxx_check_erase(_Position)
_T2 second
second is a copy of the second object
Base class for constructing a "safe" sequence type that tracks iterators that reference it...
_T1 first
first is a copy of the first object
void _M_invalidate_all() const
#define __glibcxx_check_erase_range(_First, _Last)
void _M_swap(_Safe_sequence_base &__x)
#define __glibcxx_check_insert(_Position)