29 #ifndef _GLIBCXX_DEBUG_LIST
30 #define _GLIBCXX_DEBUG_LIST 1
36 namespace std _GLIBCXX_VISIBILITY(default)
41 template<
typename _Tp,
typename _Allocator = std::allocator<_Tp> >
43 :
public _GLIBCXX_STD_C::list<_Tp, _Allocator>,
46 typedef _GLIBCXX_STD_C::list<_Tp, _Allocator>
_Base;
53 typedef typename _Base::reference reference;
54 typedef typename _Base::const_reference const_reference;
61 typedef typename _Base::size_type size_type;
62 typedef typename _Base::difference_type difference_type;
64 typedef _Tp value_type;
65 typedef _Allocator allocator_type;
66 typedef typename _Base::pointer pointer;
67 typedef typename _Base::const_pointer const_pointer;
73 list(
const _Allocator& __a = _Allocator())
76 #if __cplusplus >= 201103L
81 list(size_type __n,
const _Tp& __value,
82 const _Allocator& __a = _Allocator())
83 :
_Base(__n, __value, __a) { }
86 list(size_type __n,
const _Tp& __value = _Tp(),
87 const _Allocator& __a = _Allocator())
88 :
_Base(__n, __value, __a) { }
91 #if __cplusplus >= 201103L
92 template<
class _InputIterator,
93 typename = std::_RequireInputIter<_InputIterator>>
95 template<
class _InputIterator>
97 list(_InputIterator __first, _InputIterator __last,
98 const _Allocator& __a = _Allocator())
104 list(
const list& __x)
107 list(
const _Base& __x)
110 #if __cplusplus >= 201103L
111 list(list&& __x) noexcept
112 :
_Base(std::move(__x))
116 const allocator_type& __a = allocator_type())
117 :
_Base(__l, __a) { }
120 ~list() _GLIBCXX_NOEXCEPT { }
123 operator=(
const list& __x)
125 static_cast<_Base&
>(*this) = __x;
126 this->_M_invalidate_all();
130 #if __cplusplus >= 201103L
132 operator=(list&& __x)
136 __glibcxx_check_self_move_assign(__x);
145 static_cast<_Base&
>(*this) = __l;
146 this->_M_invalidate_all();
154 this->_M_invalidate_all();
158 #if __cplusplus >= 201103L
159 template<
class _InputIterator,
160 typename = std::_RequireInputIter<_InputIterator>>
162 template<
class _InputIterator>
165 assign(_InputIterator __first, _InputIterator __last)
167 __glibcxx_check_valid_range(__first, __last);
170 this->_M_invalidate_all();
174 assign(size_type __n,
const _Tp& __t)
176 _Base::assign(__n, __t);
177 this->_M_invalidate_all();
180 using _Base::get_allocator;
184 begin() _GLIBCXX_NOEXCEPT
185 {
return iterator(_Base::begin(),
this); }
188 begin()
const _GLIBCXX_NOEXCEPT
192 end() _GLIBCXX_NOEXCEPT
193 {
return iterator(_Base::end(),
this); }
196 end()
const _GLIBCXX_NOEXCEPT
200 rbegin() _GLIBCXX_NOEXCEPT
204 rbegin()
const _GLIBCXX_NOEXCEPT
208 rend() _GLIBCXX_NOEXCEPT
212 rend()
const _GLIBCXX_NOEXCEPT
215 #if __cplusplus >= 201103L
217 cbegin()
const noexcept
221 cend()
const noexcept
225 crbegin()
const noexcept
229 crend()
const noexcept
236 using _Base::max_size;
238 #if __cplusplus >= 201103L
240 resize(size_type __sz)
247 for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
250 for (; __victim != __end; ++__victim)
262 __throw_exception_again;
267 resize(size_type __sz,
const _Tp& __c)
274 for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
277 for (; __victim != __end; ++__victim)
284 _Base::resize(__sz, __c);
289 __throw_exception_again;
294 resize(size_type __sz, _Tp __c = _Tp())
301 for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
304 for (; __victim != __end; ++__victim)
311 _Base::resize(__sz, __c);
316 __throw_exception_again;
325 __glibcxx_check_nonempty();
326 return _Base::front();
332 __glibcxx_check_nonempty();
333 return _Base::front();
339 __glibcxx_check_nonempty();
340 return _Base::back();
346 __glibcxx_check_nonempty();
347 return _Base::back();
351 using _Base::push_front;
353 #if __cplusplus >= 201103L
354 using _Base::emplace_front;
360 __glibcxx_check_nonempty();
365 using _Base::push_back;
367 #if __cplusplus >= 201103L
368 using _Base::emplace_back;
374 __glibcxx_check_nonempty();
379 #if __cplusplus >= 201103L
380 template<
typename... _Args>
382 emplace(
iterator __position, _Args&&... __args)
386 std::forward<_Args>(__args)...),
this);
391 insert(
iterator __position,
const _Tp& __x)
394 return iterator(_Base::insert(__position.
base(), __x),
this);
397 #if __cplusplus >= 201103L
399 insert(
iterator __position, _Tp&& __x)
400 {
return emplace(__position, std::move(__x)); }
406 _Base::insert(__p.
base(), __l);
411 insert(
iterator __position, size_type __n,
const _Tp& __x)
414 _Base::insert(__position.
base(), __n, __x);
417 #if __cplusplus >= 201103L
418 template<
class _InputIterator,
419 typename = std::_RequireInputIter<_InputIterator>>
421 template<
class _InputIterator>
424 insert(
iterator __position, _InputIterator __first,
425 _InputIterator __last)
437 return _Base::erase(__position);
454 __victim != __last.
base(); ++__victim)
456 _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
457 _M_message(__gnu_debug::__msg_valid_range)
458 ._M_iterator(__position,
"position")
459 ._M_iterator(__last,
"last"));
473 clear() _GLIBCXX_NOEXCEPT
476 this->_M_invalidate_all();
481 #if __cplusplus >= 201103L
482 splice(
iterator __position, list&& __x)
484 splice(
iterator __position, list& __x)
487 _GLIBCXX_DEBUG_VERIFY(&__x !=
this,
488 _M_message(__gnu_debug::__msg_self_splice)
489 ._M_sequence(*
this,
"this"));
491 _Base::splice(__position.
base(), _GLIBCXX_MOVE(__x._M_base()));
494 #if __cplusplus >= 201103L
496 splice(
iterator __position, list& __x)
497 { splice(__position, std::move(__x)); }
501 #if __cplusplus >= 201103L
513 _M_message(__gnu_debug::__msg_splice_bad)
514 ._M_iterator(__i,
"__i"));
516 _M_message(__gnu_debug::__msg_splice_other)
517 ._M_iterator(__i,
"__i")._M_sequence(__x,
"__x"));
522 _Base::splice(__position.
base(), _GLIBCXX_MOVE(__x._M_base()),
526 #if __cplusplus >= 201103L
529 { splice(__position, std::move(__x), __i); }
533 #if __cplusplus >= 201103L
542 __glibcxx_check_valid_range(__first, __last);
544 _M_message(__gnu_debug::__msg_splice_other)
545 ._M_sequence(__x,
"x")
546 ._M_iterator(__first,
"first"));
552 __tmp != __last.
base(); ++__tmp)
554 _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
555 _M_message(__gnu_debug::__msg_valid_range)
556 ._M_iterator(__first,
"first")
557 ._M_iterator(__last,
"last"));
558 _GLIBCXX_DEBUG_VERIFY(&__x !=
this || __tmp != __position,
559 _M_message(__gnu_debug::__msg_splice_overlap)
560 ._M_iterator(__tmp,
"position")
561 ._M_iterator(__first,
"first")
562 ._M_iterator(__last,
"last"));
568 _Base::splice(__position.
base(), _GLIBCXX_MOVE(__x._M_base()),
572 #if __cplusplus >= 201103L
575 { splice(__position, std::move(__x), __first, __last); }
579 remove(
const _Tp& __value)
590 template<
class _Predicate>
592 remove_if(_Predicate __pred)
608 if (__first == __last)
611 while (__next != __last)
613 if (*__first == *__next)
614 __next = _M_erase(__next);
620 template<
class _BinaryPredicate>
622 unique(_BinaryPredicate __binary_pred)
626 if (__first == __last)
629 while (__next != __last)
631 if (__binary_pred(*__first, *__next))
632 __next = _M_erase(__next);
639 #if __cplusplus >= 201103L
649 __glibcxx_check_sorted(_Base::begin(), _Base::end());
650 __glibcxx_check_sorted(__x.begin().
base(), __x.end().
base());
652 _Base::merge(_GLIBCXX_MOVE(__x._M_base()));
656 #if __cplusplus >= 201103L
659 { merge(std::move(__x)); }
662 template<
class _Compare>
664 #if __cplusplus >= 201103L
665 merge(list&& __x, _Compare __comp)
667 merge(list& __x, _Compare __comp)
679 _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp);
683 #if __cplusplus >= 201103L
684 template<
typename _Compare>
686 merge(list& __x, _Compare __comp)
687 { merge(std::move(__x), __comp); }
691 sort() { _Base::sort(); }
693 template<
typename _StrictWeakOrdering>
695 sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); }
697 using _Base::reverse;
700 _M_base() _GLIBCXX_NOEXCEPT {
return *
this; }
703 _M_base()
const _GLIBCXX_NOEXCEPT {
return *
this; }
713 template<
typename _Tp,
typename _Alloc>
717 {
return __lhs._M_base() == __rhs._M_base(); }
719 template<
typename _Tp,
typename _Alloc>
723 {
return __lhs._M_base() != __rhs._M_base(); }
725 template<
typename _Tp,
typename _Alloc>
727 operator<(const list<_Tp, _Alloc>& __lhs,
728 const list<_Tp, _Alloc>& __rhs)
729 {
return __lhs._M_base() < __rhs._M_base(); }
731 template<
typename _Tp,
typename _Alloc>
733 operator<=(const list<_Tp, _Alloc>& __lhs,
734 const list<_Tp, _Alloc>& __rhs)
735 {
return __lhs._M_base() <= __rhs._M_base(); }
737 template<
typename _Tp,
typename _Alloc>
739 operator>=(
const list<_Tp, _Alloc>& __lhs,
740 const list<_Tp, _Alloc>& __rhs)
741 {
return __lhs._M_base() >= __rhs._M_base(); }
743 template<
typename _Tp,
typename _Alloc>
745 operator>(
const list<_Tp, _Alloc>& __lhs,
746 const list<_Tp, _Alloc>& __rhs)
747 {
return __lhs._M_base() > __rhs._M_base(); }
749 template<
typename _Tp,
typename _Alloc>
751 swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs)
752 { __lhs.swap(__rhs); }