1// Debugging list implementation -*- C++ -*-
2
3// Copyright (C) 2003-2015 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library.  This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
23// <http://www.gnu.org/licenses/>.
24
25/** @file debug/list
26 *  This file is a GNU debug extension to the Standard C++ Library.
27 */
28
29#ifndef _GLIBCXX_DEBUG_LIST
30#define _GLIBCXX_DEBUG_LIST 1
31
32#include <list>
33#include <debug/safe_sequence.h>
34#include <debug/safe_container.h>
35#include <debug/safe_iterator.h>
36
37namespace std _GLIBCXX_VISIBILITY(default)
38{
39namespace __debug
40{
41  /// Class std::list with safety/checking/debug instrumentation.
42  template<typename _Tp, typename _Allocator = std::allocator<_Tp> >
43    class list
44    : public __gnu_debug::_Safe_container<
45	list<_Tp, _Allocator>, _Allocator,
46	__gnu_debug::_Safe_node_sequence, false>,
47      public _GLIBCXX_STD_C::list<_Tp, _Allocator>
48    {
49      typedef _GLIBCXX_STD_C::list<_Tp, _Allocator>			_Base;
50      typedef __gnu_debug::_Safe_container<
51	list, _Allocator, __gnu_debug::_Safe_node_sequence, false>	_Safe;
52
53      typedef typename _Base::iterator		_Base_iterator;
54      typedef typename _Base::const_iterator	_Base_const_iterator;
55      typedef __gnu_debug::_Equal_to<_Base_const_iterator>	_Equal;
56      typedef __gnu_debug::_Not_equal_to<_Base_const_iterator>  _Not_equal;
57
58    public:
59      typedef typename _Base::reference			reference;
60      typedef typename _Base::const_reference		const_reference;
61
62      typedef __gnu_debug::_Safe_iterator<_Base_iterator, list>
63							iterator;
64      typedef __gnu_debug::_Safe_iterator<_Base_const_iterator, list>
65							const_iterator;
66
67      typedef typename _Base::size_type			size_type;
68      typedef typename _Base::difference_type		difference_type;
69
70      typedef _Tp					value_type;
71      typedef _Allocator				allocator_type;
72      typedef typename _Base::pointer			pointer;
73      typedef typename _Base::const_pointer		const_pointer;
74      typedef std::reverse_iterator<iterator>		reverse_iterator;
75      typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;
76
77      // 23.2.2.1 construct/copy/destroy:
78
79#if __cplusplus < 201103L
80      list()
81      : _Base() { }
82
83      list(const list& __x)
84      : _Base(__x) { }
85
86      ~list() { }
87#else
88      list() = default;
89      list(const list&) = default;
90      list(list&&) = default;
91
92      list(initializer_list<value_type> __l,
93	   const allocator_type& __a = allocator_type())
94      : _Base(__l, __a) { }
95
96      ~list() = default;
97#endif
98
99      explicit
100      list(const _Allocator& __a) _GLIBCXX_NOEXCEPT
101      : _Base(__a) { }
102
103#if __cplusplus >= 201103L
104      explicit
105      list(size_type __n)
106      : _Base(__n) { }
107
108      list(size_type __n, const _Tp& __value,
109	   const _Allocator& __a = _Allocator())
110      : _Base(__n, __value, __a) { }
111#else
112      explicit
113      list(size_type __n, const _Tp& __value = _Tp(),
114	   const _Allocator& __a = _Allocator())
115      : _Base(__n, __value, __a) { }
116#endif
117
118#if __cplusplus >= 201103L
119      template<class _InputIterator,
120	       typename = std::_RequireInputIter<_InputIterator>>
121#else
122      template<class _InputIterator>
123#endif
124	list(_InputIterator __first, _InputIterator __last,
125	     const _Allocator& __a = _Allocator())
126	: _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
127								     __last)),
128		__gnu_debug::__base(__last), __a)
129	{ }
130
131      list(const _Base& __x)
132      : _Base(__x) { }
133
134#if __cplusplus < 201103L
135      list&
136      operator=(const list& __x)
137      {
138	this->_M_safe() = __x;
139	_M_base() = __x;
140	return *this;
141      }
142#else
143      list&
144      operator=(const list&) = default;
145
146      list&
147      operator=(list&&) = default;
148
149      list&
150      operator=(initializer_list<value_type> __l)
151      {
152	this->_M_invalidate_all();
153	_M_base() = __l;
154	return *this;
155      }
156
157      void
158      assign(initializer_list<value_type> __l)
159      {
160	_Base::assign(__l);
161	this->_M_invalidate_all();
162      }
163#endif
164
165#if __cplusplus >= 201103L
166      template<class _InputIterator,
167	       typename = std::_RequireInputIter<_InputIterator>>
168#else
169      template<class _InputIterator>
170#endif
171	void
172	assign(_InputIterator __first, _InputIterator __last)
173	{
174	  __glibcxx_check_valid_range(__first, __last);
175	  _Base::assign(__gnu_debug::__base(__first),
176			__gnu_debug::__base(__last));
177	  this->_M_invalidate_all();
178	}
179
180      void
181      assign(size_type __n, const _Tp& __t)
182      {
183	_Base::assign(__n, __t);
184	this->_M_invalidate_all();
185      }
186
187      using _Base::get_allocator;
188
189      // iterators:
190      iterator
191      begin() _GLIBCXX_NOEXCEPT
192      { return iterator(_Base::begin(), this); }
193
194      const_iterator
195      begin() const _GLIBCXX_NOEXCEPT
196      { return const_iterator(_Base::begin(), this); }
197
198      iterator
199      end() _GLIBCXX_NOEXCEPT
200      { return iterator(_Base::end(), this); }
201
202      const_iterator
203      end() const _GLIBCXX_NOEXCEPT
204      { return const_iterator(_Base::end(), this); }
205
206      reverse_iterator
207      rbegin() _GLIBCXX_NOEXCEPT
208      { return reverse_iterator(end()); }
209
210      const_reverse_iterator
211      rbegin() const _GLIBCXX_NOEXCEPT
212      { return const_reverse_iterator(end()); }
213
214      reverse_iterator
215      rend() _GLIBCXX_NOEXCEPT
216      { return reverse_iterator(begin()); }
217
218      const_reverse_iterator
219      rend() const _GLIBCXX_NOEXCEPT
220      { return const_reverse_iterator(begin()); }
221
222#if __cplusplus >= 201103L
223      const_iterator
224      cbegin() const noexcept
225      { return const_iterator(_Base::begin(), this); }
226
227      const_iterator
228      cend() const noexcept
229      { return const_iterator(_Base::end(), this); }
230
231      const_reverse_iterator
232      crbegin() const noexcept
233      { return const_reverse_iterator(end()); }
234
235      const_reverse_iterator
236      crend() const noexcept
237      { return const_reverse_iterator(begin()); }
238#endif
239
240      // 23.2.2.2 capacity:
241      using _Base::empty;
242      using _Base::size;
243      using _Base::max_size;
244
245#if __cplusplus >= 201103L
246      void
247      resize(size_type __sz)
248      {
249	this->_M_detach_singular();
250
251	// if __sz < size(), invalidate all iterators in [begin + __sz, end())
252	_Base_iterator __victim = _Base::begin();
253	_Base_iterator __end = _Base::end();
254	for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
255	  ++__victim;
256
257	for (; __victim != __end; ++__victim)
258	  this->_M_invalidate_if(_Equal(__victim));
259
260	__try
261	  {
262	    _Base::resize(__sz);
263	  }
264	__catch(...)
265	  {
266	    this->_M_revalidate_singular();
267	    __throw_exception_again;
268	  }
269      }
270
271      void
272      resize(size_type __sz, const _Tp& __c)
273      {
274	this->_M_detach_singular();
275
276	// if __sz < size(), invalidate all iterators in [begin + __sz, end())
277	_Base_iterator __victim = _Base::begin();
278	_Base_iterator __end = _Base::end();
279	for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
280	  ++__victim;
281
282	for (; __victim != __end; ++__victim)
283	  this->_M_invalidate_if(_Equal(__victim));
284
285	__try
286	  {
287	    _Base::resize(__sz, __c);
288	  }
289	__catch(...)
290	  {
291	    this->_M_revalidate_singular();
292	    __throw_exception_again;
293	  }
294      }
295#else
296      void
297      resize(size_type __sz, _Tp __c = _Tp())
298      {
299	this->_M_detach_singular();
300
301	// if __sz < size(), invalidate all iterators in [begin + __sz, end())
302	_Base_iterator __victim = _Base::begin();
303	_Base_iterator __end = _Base::end();
304	for (size_type __i = __sz; __victim != __end && __i > 0; --__i)
305	  ++__victim;
306
307	for (; __victim != __end; ++__victim)
308	  this->_M_invalidate_if(_Equal(__victim));
309
310	__try
311	  {
312	    _Base::resize(__sz, __c);
313	  }
314	__catch(...)
315	  {
316	    this->_M_revalidate_singular();
317	    __throw_exception_again;
318	  }
319      }
320#endif
321
322      // element access:
323      reference
324      front() _GLIBCXX_NOEXCEPT
325      {
326	__glibcxx_check_nonempty();
327	return _Base::front();
328      }
329
330      const_reference
331      front() const _GLIBCXX_NOEXCEPT
332      {
333	__glibcxx_check_nonempty();
334	return _Base::front();
335      }
336
337      reference
338      back() _GLIBCXX_NOEXCEPT
339      {
340	__glibcxx_check_nonempty();
341	return _Base::back();
342      }
343
344      const_reference
345      back() const _GLIBCXX_NOEXCEPT
346      {
347	__glibcxx_check_nonempty();
348	return _Base::back();
349      }
350
351      // 23.2.2.3 modifiers:
352      using _Base::push_front;
353
354#if __cplusplus >= 201103L
355      using _Base::emplace_front;
356#endif
357
358      void
359      pop_front() _GLIBCXX_NOEXCEPT
360      {
361	__glibcxx_check_nonempty();
362	this->_M_invalidate_if(_Equal(_Base::begin()));
363	_Base::pop_front();
364      }
365
366      using _Base::push_back;
367
368#if __cplusplus >= 201103L
369      using _Base::emplace_back;
370#endif
371
372      void
373      pop_back() _GLIBCXX_NOEXCEPT
374      {
375	__glibcxx_check_nonempty();
376	this->_M_invalidate_if(_Equal(--_Base::end()));
377	_Base::pop_back();
378      }
379
380#if __cplusplus >= 201103L
381      template<typename... _Args>
382	iterator
383	emplace(const_iterator __position, _Args&&... __args)
384	{
385	  __glibcxx_check_insert(__position);
386	  return iterator(_Base::emplace(__position.base(),
387					std::forward<_Args>(__args)...), this);
388	}
389#endif
390
391     iterator
392#if __cplusplus >= 201103L
393     insert(const_iterator __position, const _Tp& __x)
394#else
395     insert(iterator __position, const _Tp& __x)
396#endif
397     {
398       __glibcxx_check_insert(__position);
399       return iterator(_Base::insert(__position.base(), __x), this);
400     }
401
402#if __cplusplus >= 201103L
403      iterator
404      insert(const_iterator __position, _Tp&& __x)
405      { return emplace(__position, std::move(__x)); }
406
407      iterator
408      insert(const_iterator __p, initializer_list<value_type> __l)
409      {
410	__glibcxx_check_insert(__p);
411	return iterator(_Base::insert(__p.base(), __l), this);
412      }
413#endif
414
415#if __cplusplus >= 201103L
416      iterator
417      insert(const_iterator __position, size_type __n, const _Tp& __x)
418      {
419	__glibcxx_check_insert(__position);
420	return iterator(_Base::insert(__position.base(), __n, __x), this);
421      }
422#else
423      void
424      insert(iterator __position, size_type __n, const _Tp& __x)
425      {
426	__glibcxx_check_insert(__position);
427	_Base::insert(__position.base(), __n, __x);
428      }
429#endif
430
431#if __cplusplus >= 201103L
432      template<class _InputIterator,
433	       typename = std::_RequireInputIter<_InputIterator>>
434	iterator
435	insert(const_iterator __position, _InputIterator __first,
436	       _InputIterator __last)
437	{
438	  __glibcxx_check_insert_range(__position, __first, __last);
439	  return iterator(_Base::insert(__position.base(),
440					__gnu_debug::__base(__first),
441					__gnu_debug::__base(__last)),
442			  this);
443	}
444#else
445      template<class _InputIterator>
446	void
447	insert(iterator __position, _InputIterator __first,
448	       _InputIterator __last)
449	{
450	  __glibcxx_check_insert_range(__position, __first, __last);
451	  _Base::insert(__position.base(), __gnu_debug::__base(__first),
452					   __gnu_debug::__base(__last));
453	}
454#endif
455
456    private:
457      _Base_iterator
458#if __cplusplus >= 201103L
459      _M_erase(_Base_const_iterator __position) noexcept
460#else
461      _M_erase(_Base_iterator __position)
462#endif
463      {
464	this->_M_invalidate_if(_Equal(__position));
465	return _Base::erase(__position);
466      }
467
468    public:
469      iterator
470#if __cplusplus >= 201103L
471      erase(const_iterator __position) noexcept
472#else
473      erase(iterator __position)
474#endif
475      {
476	__glibcxx_check_erase(__position);
477	return iterator(_M_erase(__position.base()), this);
478      }
479
480      iterator
481#if __cplusplus >= 201103L
482      erase(const_iterator __first, const_iterator __last) noexcept
483#else
484      erase(iterator __first, iterator __last)
485#endif
486      {
487	// _GLIBCXX_RESOLVE_LIB_DEFECTS
488	// 151. can't currently clear() empty container
489	__glibcxx_check_erase_range(__first, __last);
490	for (_Base_const_iterator __victim = __first.base();
491	     __victim != __last.base(); ++__victim)
492	  {
493	    _GLIBCXX_DEBUG_VERIFY(__victim != _Base::end(),
494				  _M_message(__gnu_debug::__msg_valid_range)
495				  ._M_iterator(__first, "position")
496				  ._M_iterator(__last, "last"));
497	    this->_M_invalidate_if(_Equal(__victim));
498	  }
499	return iterator(_Base::erase(__first.base(), __last.base()), this);
500      }
501
502      void
503      swap(list& __x)
504#if __cplusplus >= 201103L
505	noexcept( noexcept(declval<_Base>().swap(__x)) )
506#endif
507      {
508	_Safe::_M_swap(__x);
509	_Base::swap(__x);
510      }
511
512      void
513      clear() _GLIBCXX_NOEXCEPT
514      {
515	_Base::clear();
516	this->_M_invalidate_all();
517      }
518
519      // 23.2.2.4 list operations:
520      void
521#if __cplusplus >= 201103L
522      splice(const_iterator __position, list&& __x) noexcept
523#else
524      splice(iterator __position, list& __x)
525#endif
526      {
527	_GLIBCXX_DEBUG_VERIFY(&__x != this,
528			      _M_message(__gnu_debug::__msg_self_splice)
529			      ._M_sequence(*this, "this"));
530	this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end()));
531	_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()));
532      }
533
534#if __cplusplus >= 201103L
535      void
536      splice(const_iterator __position, list& __x) noexcept
537      { splice(__position, std::move(__x)); }
538#endif
539
540      void
541#if __cplusplus >= 201103L
542      splice(const_iterator __position, list&& __x, const_iterator __i) noexcept
543#else
544      splice(iterator __position, list& __x, iterator __i)
545#endif
546      {
547	__glibcxx_check_insert(__position);
548
549	// We used to perform the splice_alloc check:  not anymore, redundant
550	// after implementing the relevant bits of N1599.
551
552	_GLIBCXX_DEBUG_VERIFY(__i._M_dereferenceable(),
553			      _M_message(__gnu_debug::__msg_splice_bad)
554			      ._M_iterator(__i, "__i"));
555	_GLIBCXX_DEBUG_VERIFY(__i._M_attached_to(&__x),
556			      _M_message(__gnu_debug::__msg_splice_other)
557			     ._M_iterator(__i, "__i")._M_sequence(__x, "__x"));
558
559	// _GLIBCXX_RESOLVE_LIB_DEFECTS
560	// 250. splicing invalidates iterators
561	this->_M_transfer_from_if(__x, _Equal(__i.base()));
562	_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
563		      __i.base());
564      }
565
566#if __cplusplus >= 201103L
567      void
568      splice(const_iterator __position, list& __x, const_iterator __i) noexcept
569      { splice(__position, std::move(__x), __i); }
570#endif
571
572      void
573#if __cplusplus >= 201103L
574      splice(const_iterator __position, list&& __x, const_iterator __first,
575	     const_iterator __last) noexcept
576#else
577      splice(iterator __position, list& __x, iterator __first,
578	     iterator __last)
579#endif
580      {
581	__glibcxx_check_insert(__position);
582	__glibcxx_check_valid_range(__first, __last);
583	_GLIBCXX_DEBUG_VERIFY(__first._M_attached_to(&__x),
584			      _M_message(__gnu_debug::__msg_splice_other)
585			      ._M_sequence(__x, "x")
586			      ._M_iterator(__first, "first"));
587
588	// We used to perform the splice_alloc check:  not anymore, redundant
589	// after implementing the relevant bits of N1599.
590
591	for (_Base_const_iterator __tmp = __first.base();
592	     __tmp != __last.base(); ++__tmp)
593	  {
594	    _GLIBCXX_DEBUG_VERIFY(__tmp != _Base::end(),
595				  _M_message(__gnu_debug::__msg_valid_range)
596				  ._M_iterator(__first, "first")
597				  ._M_iterator(__last, "last"));
598	    _GLIBCXX_DEBUG_VERIFY(&__x != this || __tmp != __position.base(),
599				_M_message(__gnu_debug::__msg_splice_overlap)
600				  ._M_iterator(__tmp, "position")
601				  ._M_iterator(__first, "first")
602				  ._M_iterator(__last, "last"));
603	    // _GLIBCXX_RESOLVE_LIB_DEFECTS
604	    // 250. splicing invalidates iterators
605	    this->_M_transfer_from_if(__x, _Equal(__tmp));
606	  }
607
608	_Base::splice(__position.base(), _GLIBCXX_MOVE(__x._M_base()),
609		      __first.base(), __last.base());
610      }
611
612#if __cplusplus >= 201103L
613      void
614      splice(const_iterator __position, list& __x,
615	     const_iterator __first, const_iterator __last) noexcept
616      { splice(__position, std::move(__x), __first, __last); }
617#endif
618
619      void
620      remove(const _Tp& __value)
621      {
622	for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); )
623	  {
624	    if (*__x == __value)
625	      __x = _M_erase(__x);
626	    else
627	      ++__x;
628	  }
629      }
630
631      template<class _Predicate>
632	void
633	remove_if(_Predicate __pred)
634	{
635	  for (_Base_iterator __x = _Base::begin(); __x != _Base::end(); )
636	    {
637	      if (__pred(*__x))
638		__x = _M_erase(__x);
639	      else
640		++__x;
641	    }
642	}
643
644      void
645      unique()
646      {
647	_Base_iterator __first = _Base::begin();
648	_Base_iterator __last = _Base::end();
649	if (__first == __last)
650	  return;
651	_Base_iterator __next = __first; ++__next;
652	while (__next != __last)
653	  {
654	    if (*__first == *__next)
655	      __next = _M_erase(__next);
656	    else
657	      __first = __next++;
658	  }
659      }
660
661      template<class _BinaryPredicate>
662	void
663	unique(_BinaryPredicate __binary_pred)
664	{
665	  _Base_iterator __first = _Base::begin();
666	  _Base_iterator __last = _Base::end();
667	  if (__first == __last)
668	    return;
669	  _Base_iterator __next = __first; ++__next;
670	  while (__next != __last)
671	    {
672	      if (__binary_pred(*__first, *__next))
673		__next = _M_erase(__next);
674	      else
675		__first = __next++;
676	    }
677	}
678
679      void
680#if __cplusplus >= 201103L
681      merge(list&& __x)
682#else
683      merge(list& __x)
684#endif
685      {
686	// _GLIBCXX_RESOLVE_LIB_DEFECTS
687	// 300. list::merge() specification incomplete
688	if (this != &__x)
689	  {
690	    __glibcxx_check_sorted(_Base::begin(), _Base::end());
691	    __glibcxx_check_sorted(__x.begin().base(), __x.end().base());
692	    this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end()));
693	    _Base::merge(_GLIBCXX_MOVE(__x._M_base()));
694	  }
695      }
696
697#if __cplusplus >= 201103L
698      void
699      merge(list& __x)
700      { merge(std::move(__x)); }
701#endif
702
703      template<class _Compare>
704	void
705#if __cplusplus >= 201103L
706	merge(list&& __x, _Compare __comp)
707#else
708	merge(list& __x, _Compare __comp)
709#endif
710	{
711	  // _GLIBCXX_RESOLVE_LIB_DEFECTS
712	  // 300. list::merge() specification incomplete
713	  if (this != &__x)
714	    {
715	      __glibcxx_check_sorted_pred(_Base::begin(), _Base::end(),
716					  __comp);
717	      __glibcxx_check_sorted_pred(__x.begin().base(), __x.end().base(),
718					  __comp);
719	      this->_M_transfer_from_if(__x, _Not_equal(__x._M_base().end()));
720	      _Base::merge(_GLIBCXX_MOVE(__x._M_base()), __comp);
721	    }
722	}
723
724#if __cplusplus >= 201103L
725      template<typename _Compare>
726	void
727	merge(list& __x, _Compare __comp)
728	{ merge(std::move(__x), __comp); }
729#endif
730
731      void
732      sort() { _Base::sort(); }
733
734      template<typename _StrictWeakOrdering>
735	void
736	sort(_StrictWeakOrdering __pred) { _Base::sort(__pred); }
737
738      using _Base::reverse;
739
740      _Base&
741      _M_base() _GLIBCXX_NOEXCEPT	{ return *this; }
742
743      const _Base&
744      _M_base() const _GLIBCXX_NOEXCEPT	{ return *this; }
745    };
746
747  template<typename _Tp, typename _Alloc>
748    inline bool
749    operator==(const list<_Tp, _Alloc>& __lhs,
750	       const list<_Tp, _Alloc>& __rhs)
751    { return __lhs._M_base() == __rhs._M_base(); }
752
753  template<typename _Tp, typename _Alloc>
754    inline bool
755    operator!=(const list<_Tp, _Alloc>& __lhs,
756	       const list<_Tp, _Alloc>& __rhs)
757    { return __lhs._M_base() != __rhs._M_base(); }
758
759  template<typename _Tp, typename _Alloc>
760    inline bool
761    operator<(const list<_Tp, _Alloc>& __lhs,
762	      const list<_Tp, _Alloc>& __rhs)
763    { return __lhs._M_base() < __rhs._M_base(); }
764
765  template<typename _Tp, typename _Alloc>
766    inline bool
767    operator<=(const list<_Tp, _Alloc>& __lhs,
768	       const list<_Tp, _Alloc>& __rhs)
769    { return __lhs._M_base() <= __rhs._M_base(); }
770
771  template<typename _Tp, typename _Alloc>
772    inline bool
773    operator>=(const list<_Tp, _Alloc>& __lhs,
774	       const list<_Tp, _Alloc>& __rhs)
775    { return __lhs._M_base() >= __rhs._M_base(); }
776
777  template<typename _Tp, typename _Alloc>
778    inline bool
779    operator>(const list<_Tp, _Alloc>& __lhs,
780	      const list<_Tp, _Alloc>& __rhs)
781    { return __lhs._M_base() > __rhs._M_base(); }
782
783  template<typename _Tp, typename _Alloc>
784    inline void
785    swap(list<_Tp, _Alloc>& __lhs, list<_Tp, _Alloc>& __rhs)
786    { __lhs.swap(__rhs); }
787
788} // namespace __debug
789} // namespace std
790
791#ifndef _GLIBCXX_DEBUG_PEDANTIC
792namespace __gnu_debug
793{
794  template<class _Tp, class _Alloc>
795    struct _Insert_range_from_self_is_safe<std::__debug::list<_Tp, _Alloc> >
796    { enum { __value = 1 }; };
797}
798#endif
799
800#endif
801