libstdc++-v3/include/debug/list

   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
  37 namespace std _GLIBCXX_VISIBILITY(default)
  38 {
  39 namespace __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
 792 namespace __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