libstdc++-v3/include/debug/vector

   1 // Debugging vector implementation -*- C++ -*-
   2
   3 // Copyright (C) 2003-2016 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/vector
  26  *  This file is a GNU debug extension to the Standard C++ Library.
  27  */
  28
  29 #ifndef _GLIBCXX_DEBUG_VECTOR
  30 #define _GLIBCXX_DEBUG_VECTOR 1
  31
  32 #pragma GCC system_header
  33
  34 #include <vector>
  35 #include <utility>
  36 #include <debug/safe_sequence.h>
  37 #include <debug/safe_container.h>
  38 #include <debug/safe_iterator.h>
  39
  40 namespace __gnu_debug
  41 {
  42   /** @brief Base class for Debug Mode vector.
  43    *
  44    * Adds information about the guaranteed capacity, which is useful for
  45    * detecting code which relies on non-portable implementation details of
  46    * the libstdc++ reallocation policy.
  47    */
  48   template<typename _SafeSequence,
  49            typename _BaseSequence>
  50     class _Safe_vector
  51     {
  52       typedef typename _BaseSequence::size_type size_type;
  53
  54       const _SafeSequence&
  55       _M_seq() const { return *static_cast<const _SafeSequence*>(this); }
  56
  57     protected:
  58       _Safe_vector() _GLIBCXX_NOEXCEPT
  59         : _M_guaranteed_capacity(0)
  60       { _M_update_guaranteed_capacity(); }
  61
  62       _Safe_vector(const _Safe_vector&) _GLIBCXX_NOEXCEPT
  63         : _M_guaranteed_capacity(0)
  64       { _M_update_guaranteed_capacity(); }
  65
  66       _Safe_vector(size_type __n) _GLIBCXX_NOEXCEPT
  67         : _M_guaranteed_capacity(__n)
  68       { }
  69
  70 #if __cplusplus >= 201103L
  71       _Safe_vector(_Safe_vector&& __x) noexcept
  72         : _Safe_vector()
  73       { __x._M_guaranteed_capacity = 0; }
  74
  75       _Safe_vector&
  76       operator=(const _Safe_vector&) noexcept
  77       {
  78         _M_update_guaranteed_capacity();
  79         return *this;
  80       }
  81
  82       _Safe_vector&
  83       operator=(_Safe_vector&& __x) noexcept
  84       {
  85         _M_update_guaranteed_capacity();
  86         __x._M_guaranteed_capacity = 0;
  87         return *this;
  88       }
  89 #endif
  90
  91       size_type _M_guaranteed_capacity;
  92
  93       bool
  94       _M_requires_reallocation(size_type __elements) const _GLIBCXX_NOEXCEPT
  95       { return __elements > _M_seq().capacity(); }
  96
  97       void
  98       _M_update_guaranteed_capacity() _GLIBCXX_NOEXCEPT
  99       {
 100         if (_M_seq().size() > _M_guaranteed_capacity)
 101           _M_guaranteed_capacity = _M_seq().size();
 102       }
 103     };
 104 }
 105
 106 namespace std _GLIBCXX_VISIBILITY(default)
 107 {
 108 namespace __debug
 109 {
 110   /// Class std::vector with safety/checking/debug instrumentation.
 111   template<typename _Tp,
 112            typename _Allocator = std::allocator<_Tp> >
 113     class vector
 114     : public __gnu_debug::_Safe_container<
 115         vector<_Tp, _Allocator>, _Allocator, __gnu_debug::_Safe_sequence>,
 116       public _GLIBCXX_STD_C::vector<_Tp, _Allocator>,
 117       public __gnu_debug::_Safe_vector<
 118         vector<_Tp, _Allocator>,
 119         _GLIBCXX_STD_C::vector<_Tp, _Allocator> >
 120     {
 121       typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator>           _Base;
 122       typedef __gnu_debug::_Safe_container<
 123         vector, _Allocator, __gnu_debug::_Safe_sequence>        _Safe;
 124       typedef __gnu_debug::_Safe_vector<vector, _Base>          _Safe_vector;
 125
 126       typedef typename _Base::iterator          _Base_iterator;
 127       typedef typename _Base::const_iterator    _Base_const_iterator;
 128       typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;
 129
 130     public:
 131       typedef typename _Base::reference                 reference;
 132       typedef typename _Base::const_reference           const_reference;
 133
 134       typedef __gnu_debug::_Safe_iterator<
 135         _Base_iterator, vector>                         iterator;
 136       typedef __gnu_debug::_Safe_iterator<
 137         _Base_const_iterator, vector>                   const_iterator;
 138
 139       typedef typename _Base::size_type                 size_type;
 140       typedef typename _Base::difference_type           difference_type;
 141
 142       typedef _Tp                                       value_type;
 143       typedef _Allocator                                allocator_type;
 144       typedef typename _Base::pointer                   pointer;
 145       typedef typename _Base::const_pointer             const_pointer;
 146       typedef std::reverse_iterator<iterator>           reverse_iterator;
 147       typedef std::reverse_iterator<const_iterator>     const_reverse_iterator;
 148
 149       // 23.2.4.1 construct/copy/destroy:
 150
 151 #if __cplusplus < 201103L
 152       vector() _GLIBCXX_NOEXCEPT
 153       : _Base() { }
 154 #else
 155       vector() = default;
 156 #endif
 157
 158       explicit
 159       vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT
 160       : _Base(__a) { }
 161
 162 #if __cplusplus >= 201103L
 163       explicit
 164       vector(size_type __n, const _Allocator& __a = _Allocator())
 165       : _Base(__n, __a), _Safe_vector(__n) { }
 166
 167       vector(size_type __n, const _Tp& __value,
 168              const _Allocator& __a = _Allocator())
 169       : _Base(__n, __value, __a) { }
 170 #else
 171       explicit
 172       vector(size_type __n, const _Tp& __value = _Tp(),
 173              const _Allocator& __a = _Allocator())
 174       : _Base(__n, __value, __a) { }
 175 #endif
 176
 177 #if __cplusplus >= 201103L
 178       template<class _InputIterator,
 179                typename = std::_RequireInputIter<_InputIterator>>
 180 #else
 181       template<class _InputIterator>
 182 #endif
 183         vector(_InputIterator __first, _InputIterator __last,
 184                const _Allocator& __a = _Allocator())
 185         : _Base(__gnu_debug::__base(__gnu_debug::__check_valid_range(__first,
 186                                                                      __last)),
 187                 __gnu_debug::__base(__last), __a) { }
 188
 189 #if __cplusplus < 201103L
 190       vector(const vector& __x)
 191       : _Base(__x) { }
 192
 193       ~vector() _GLIBCXX_NOEXCEPT { }
 194 #else
 195       vector(const vector&) = default;
 196       vector(vector&&) = default;
 197
 198       vector(const vector& __x, const allocator_type& __a)
 199       : _Base(__x, __a) { }
 200
 201       vector(vector&& __x, const allocator_type& __a)
 202       : _Safe(std::move(__x._M_safe()), __a),
 203         _Base(std::move(__x._M_base()), __a),
 204         _Safe_vector(std::move(__x)) { }
 205
 206       vector(initializer_list<value_type> __l,
 207              const allocator_type& __a = allocator_type())
 208       : _Base(__l, __a) { }
 209
 210       ~vector() = default;
 211 #endif
 212
 213       /// Construction from a normal-mode vector
 214       vector(const _Base& __x)
 215       : _Base(__x) { }
 216
 217 #if __cplusplus < 201103L
 218       vector&
 219       operator=(const vector& __x)
 220       {
 221         this->_M_safe() = __x;
 222         _M_base() = __x;
 223         this->_M_update_guaranteed_capacity();
 224         return *this;
 225       }
 226 #else
 227       vector&
 228       operator=(const vector&) = default;
 229
 230       vector&
 231       operator=(vector&&) = default;
 232
 233       vector&
 234       operator=(initializer_list<value_type> __l)
 235       {
 236         _M_base() = __l;
 237         this->_M_invalidate_all();
 238         this->_M_update_guaranteed_capacity();
 239         return *this;
 240       }
 241 #endif
 242
 243 #if __cplusplus >= 201103L
 244       template<typename _InputIterator,
 245                typename = std::_RequireInputIter<_InputIterator>>
 246 #else
 247       template<typename _InputIterator>
 248 #endif
 249         void
 250         assign(_InputIterator __first, _InputIterator __last)
 251         {
 252           typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
 253           __glibcxx_check_valid_range2(__first, __last, __dist);
 254
 255           if (__dist.second >= __gnu_debug::__dp_sign)
 256             _Base::assign(__gnu_debug::__unsafe(__first),
 257                           __gnu_debug::__unsafe(__last));
 258           else
 259             _Base::assign(__first, __last);
 260
 261           this->_M_invalidate_all();
 262           this->_M_update_guaranteed_capacity();
 263         }
 264
 265       void
 266       assign(size_type __n, const _Tp& __u)
 267       {
 268         _Base::assign(__n, __u);
 269         this->_M_invalidate_all();
 270         this->_M_update_guaranteed_capacity();
 271       }
 272
 273 #if __cplusplus >= 201103L
 274       void
 275       assign(initializer_list<value_type> __l)
 276       {
 277         _Base::assign(__l);
 278         this->_M_invalidate_all();
 279         this->_M_update_guaranteed_capacity();
 280       }
 281 #endif
 282
 283       using _Base::get_allocator;
 284
 285       // iterators:
 286       iterator
 287       begin() _GLIBCXX_NOEXCEPT
 288       { return iterator(_Base::begin(), this); }
 289
 290       const_iterator
 291       begin() const _GLIBCXX_NOEXCEPT
 292       { return const_iterator(_Base::begin(), this); }
 293
 294       iterator
 295       end() _GLIBCXX_NOEXCEPT
 296       { return iterator(_Base::end(), this); }
 297
 298       const_iterator
 299       end() const _GLIBCXX_NOEXCEPT
 300       { return const_iterator(_Base::end(), this); }
 301
 302       reverse_iterator
 303       rbegin() _GLIBCXX_NOEXCEPT
 304       { return reverse_iterator(end()); }
 305
 306       const_reverse_iterator
 307       rbegin() const _GLIBCXX_NOEXCEPT
 308       { return const_reverse_iterator(end()); }
 309
 310       reverse_iterator
 311       rend() _GLIBCXX_NOEXCEPT
 312       { return reverse_iterator(begin()); }
 313
 314       const_reverse_iterator
 315       rend() const _GLIBCXX_NOEXCEPT
 316       { return const_reverse_iterator(begin()); }
 317
 318 #if __cplusplus >= 201103L
 319       const_iterator
 320       cbegin() const noexcept
 321       { return const_iterator(_Base::begin(), this); }
 322
 323       const_iterator
 324       cend() const noexcept
 325       { return const_iterator(_Base::end(), this); }
 326
 327       const_reverse_iterator
 328       crbegin() const noexcept
 329       { return const_reverse_iterator(end()); }
 330
 331       const_reverse_iterator
 332       crend() const noexcept
 333       { return const_reverse_iterator(begin()); }
 334 #endif
 335
 336       // 23.2.4.2 capacity:
 337       using _Base::size;
 338       using _Base::max_size;
 339
 340 #if __cplusplus >= 201103L
 341       void
 342       resize(size_type __sz)
 343       {
 344         bool __realloc = this->_M_requires_reallocation(__sz);
 345         if (__sz < this->size())
 346           this->_M_invalidate_after_nth(__sz);
 347         _Base::resize(__sz);
 348         if (__realloc)
 349           this->_M_invalidate_all();
 350         this->_M_update_guaranteed_capacity();
 351       }
 352
 353       void
 354       resize(size_type __sz, const _Tp& __c)
 355       {
 356         bool __realloc = this->_M_requires_reallocation(__sz);
 357         if (__sz < this->size())
 358           this->_M_invalidate_after_nth(__sz);
 359         _Base::resize(__sz, __c);
 360         if (__realloc)
 361           this->_M_invalidate_all();
 362         this->_M_update_guaranteed_capacity();
 363       }
 364 #else
 365       void
 366       resize(size_type __sz, _Tp __c = _Tp())
 367       {
 368         bool __realloc = this->_M_requires_reallocation(__sz);
 369         if (__sz < this->size())
 370           this->_M_invalidate_after_nth(__sz);
 371         _Base::resize(__sz, __c);
 372         if (__realloc)
 373           this->_M_invalidate_all();
 374         this->_M_update_guaranteed_capacity();
 375       }
 376 #endif
 377
 378 #if __cplusplus >= 201103L
 379       void
 380       shrink_to_fit()
 381       {
 382         if (_Base::_M_shrink_to_fit())
 383           {
 384             this->_M_guaranteed_capacity = _Base::capacity();
 385             this->_M_invalidate_all();
 386           }
 387       }
 388 #endif
 389
 390       size_type
 391       capacity() const _GLIBCXX_NOEXCEPT
 392       {
 393 #ifdef _GLIBCXX_DEBUG_PEDANTIC
 394         return this->_M_guaranteed_capacity;
 395 #else
 396         return _Base::capacity();
 397 #endif
 398       }
 399
 400       using _Base::empty;
 401
 402       void
 403       reserve(size_type __n)
 404       {
 405         bool __realloc = this->_M_requires_reallocation(__n);
 406         _Base::reserve(__n);
 407         if (__n > this->_M_guaranteed_capacity)
 408           this->_M_guaranteed_capacity = __n;
 409         if (__realloc)
 410           this->_M_invalidate_all();
 411       }
 412
 413       // element access:
 414       reference
 415       operator[](size_type __n) _GLIBCXX_NOEXCEPT
 416       {
 417         __glibcxx_check_subscript(__n);
 418         return _M_base()[__n];
 419       }
 420
 421       const_reference
 422       operator[](size_type __n) const _GLIBCXX_NOEXCEPT
 423       {
 424         __glibcxx_check_subscript(__n);
 425         return _M_base()[__n];
 426       }
 427
 428       using _Base::at;
 429
 430       reference
 431       front() _GLIBCXX_NOEXCEPT
 432       {
 433         __glibcxx_check_nonempty();
 434         return _Base::front();
 435       }
 436
 437       const_reference
 438       front() const _GLIBCXX_NOEXCEPT
 439       {
 440         __glibcxx_check_nonempty();
 441         return _Base::front();
 442       }
 443
 444       reference
 445       back() _GLIBCXX_NOEXCEPT
 446       {
 447         __glibcxx_check_nonempty();
 448         return _Base::back();
 449       }
 450
 451       const_reference
 452       back() const _GLIBCXX_NOEXCEPT
 453       {
 454         __glibcxx_check_nonempty();
 455         return _Base::back();
 456       }
 457
 458       // _GLIBCXX_RESOLVE_LIB_DEFECTS
 459       // DR 464. Suggestion for new member functions in standard containers.
 460       using _Base::data;
 461
 462       // 23.2.4.3 modifiers:
 463       void
 464       push_back(const _Tp& __x)
 465       {
 466         bool __realloc = this->_M_requires_reallocation(this->size() + 1);
 467         _Base::push_back(__x);
 468         if (__realloc)
 469           this->_M_invalidate_all();
 470         this->_M_update_guaranteed_capacity();
 471       }
 472
 473 #if __cplusplus >= 201103L
 474       template<typename _Up = _Tp>
 475         typename __gnu_cxx::__enable_if<!std::__are_same<_Up, bool>::__value,
 476                                         void>::__type
 477         push_back(_Tp&& __x)
 478         { emplace_back(std::move(__x)); }
 479
 480       template<typename... _Args>
 481         void
 482         emplace_back(_Args&&... __args)
 483         {
 484           bool __realloc = this->_M_requires_reallocation(this->size() + 1);
 485           _Base::emplace_back(std::forward<_Args>(__args)...);
 486           if (__realloc)
 487             this->_M_invalidate_all();
 488           this->_M_update_guaranteed_capacity();
 489         }
 490 #endif
 491
 492       void
 493       pop_back() _GLIBCXX_NOEXCEPT
 494       {
 495         __glibcxx_check_nonempty();
 496         this->_M_invalidate_if(_Equal(--_Base::end()));
 497         _Base::pop_back();
 498       }
 499
 500 #if __cplusplus >= 201103L
 501       template<typename... _Args>
 502         iterator
 503         emplace(const_iterator __position, _Args&&... __args)
 504         {
 505           __glibcxx_check_insert(__position);
 506           bool __realloc = this->_M_requires_reallocation(this->size() + 1);
 507           difference_type __offset = __position.base() - _Base::begin();
 508           _Base_iterator __res = _Base::emplace(__position.base(),
 509                                                 std::forward<_Args>(__args)...);
 510           if (__realloc)
 511             this->_M_invalidate_all();
 512           else
 513             this->_M_invalidate_after_nth(__offset);
 514           this->_M_update_guaranteed_capacity();
 515           return iterator(__res, this);
 516         }
 517 #endif
 518
 519       iterator
 520 #if __cplusplus >= 201103L
 521       insert(const_iterator __position, const _Tp& __x)
 522 #else
 523       insert(iterator __position, const _Tp& __x)
 524 #endif
 525       {
 526         __glibcxx_check_insert(__position);
 527         bool __realloc = this->_M_requires_reallocation(this->size() + 1);
 528         difference_type __offset = __position.base() - _Base::begin();
 529         _Base_iterator __res = _Base::insert(__position.base(), __x);
 530         if (__realloc)
 531           this->_M_invalidate_all();
 532         else
 533           this->_M_invalidate_after_nth(__offset);
 534         this->_M_update_guaranteed_capacity();
 535         return iterator(__res, this);
 536       }
 537
 538 #if __cplusplus >= 201103L
 539       template<typename _Up = _Tp>
 540         typename __gnu_cxx::__enable_if<!std::__are_same<_Up, bool>::__value,
 541                                         iterator>::__type
 542         insert(const_iterator __position, _Tp&& __x)
 543         { return emplace(__position, std::move(__x)); }
 544
 545       iterator
 546       insert(const_iterator __position, initializer_list<value_type> __l)
 547       { return this->insert(__position, __l.begin(), __l.end()); }
 548 #endif
 549
 550 #if __cplusplus >= 201103L
 551       iterator
 552       insert(const_iterator __position, size_type __n, const _Tp& __x)
 553       {
 554         __glibcxx_check_insert(__position);
 555         bool __realloc = this->_M_requires_reallocation(this->size() + __n);
 556         difference_type __offset = __position.base() - _Base::cbegin();
 557         _Base_iterator __res = _Base::insert(__position.base(), __n, __x);
 558         if (__realloc)
 559           this->_M_invalidate_all();
 560         else
 561           this->_M_invalidate_after_nth(__offset);
 562         this->_M_update_guaranteed_capacity();
 563         return iterator(__res, this);
 564       }
 565 #else
 566       void
 567       insert(iterator __position, size_type __n, const _Tp& __x)
 568       {
 569         __glibcxx_check_insert(__position);
 570         bool __realloc = this->_M_requires_reallocation(this->size() + __n);
 571         difference_type __offset = __position.base() - _Base::begin();
 572         _Base::insert(__position.base(), __n, __x);
 573         if (__realloc)
 574           this->_M_invalidate_all();
 575         else
 576           this->_M_invalidate_after_nth(__offset);
 577         this->_M_update_guaranteed_capacity();
 578       }
 579 #endif
 580
 581 #if __cplusplus >= 201103L
 582       template<class _InputIterator,
 583                typename = std::_RequireInputIter<_InputIterator>>
 584         iterator
 585         insert(const_iterator __position,
 586                _InputIterator __first, _InputIterator __last)
 587         {
 588           typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
 589           __glibcxx_check_insert_range(__position, __first, __last, __dist);
 590
 591           /* Hard to guess if invalidation will occur, because __last
 592              - __first can't be calculated in all cases, so we just
 593              punt here by checking if it did occur. */
 594           _Base_iterator __old_begin = _M_base().begin();
 595           difference_type __offset = __position.base() - _Base::cbegin();
 596           _Base_iterator __res;
 597           if (__dist.second >= __gnu_debug::__dp_sign)
 598             __res = _Base::insert(__position.base(),
 599                                   __gnu_debug::__unsafe(__first),
 600                                   __gnu_debug::__unsafe(__last));
 601           else
 602             __res = _Base::insert(__position.base(), __first, __last);
 603
 604           if (_M_base().begin() != __old_begin)
 605             this->_M_invalidate_all();
 606           else
 607             this->_M_invalidate_after_nth(__offset);
 608           this->_M_update_guaranteed_capacity();
 609           return iterator(__res, this);
 610         }
 611 #else
 612       template<class _InputIterator>
 613         void
 614         insert(iterator __position,
 615                _InputIterator __first, _InputIterator __last)
 616         {
 617           typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
 618           __glibcxx_check_insert_range(__position, __first, __last, __dist);
 619
 620           /* Hard to guess if invalidation will occur, because __last
 621              - __first can't be calculated in all cases, so we just
 622              punt here by checking if it did occur. */
 623           _Base_iterator __old_begin = _M_base().begin();
 624           difference_type __offset = __position.base() - _Base::begin();
 625           if (__dist.second >= __gnu_debug::__dp_sign)
 626             _Base::insert(__position.base(), __gnu_debug::__unsafe(__first),
 627                                              __gnu_debug::__unsafe(__last));
 628           else
 629             _Base::insert(__position.base(), __first, __last);
 630
 631           if (_M_base().begin() != __old_begin)
 632             this->_M_invalidate_all();
 633           else
 634             this->_M_invalidate_after_nth(__offset);
 635           this->_M_update_guaranteed_capacity();
 636         }
 637 #endif
 638
 639       iterator
 640 #if __cplusplus >= 201103L
 641       erase(const_iterator __position)
 642 #else
 643       erase(iterator __position)
 644 #endif
 645       {
 646         __glibcxx_check_erase(__position);
 647         difference_type __offset = __position.base() - _Base::begin();
 648         _Base_iterator __res = _Base::erase(__position.base());
 649         this->_M_invalidate_after_nth(__offset);
 650         return iterator(__res, this);
 651       }
 652
 653       iterator
 654 #if __cplusplus >= 201103L
 655       erase(const_iterator __first, const_iterator __last)
 656 #else
 657       erase(iterator __first, iterator __last)
 658 #endif
 659       {
 660         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 661         // 151. can't currently clear() empty container
 662         __glibcxx_check_erase_range(__first, __last);
 663
 664         if (__first.base() != __last.base())
 665           {
 666             difference_type __offset = __first.base() - _Base::begin();
 667             _Base_iterator __res = _Base::erase(__first.base(),
 668                                                 __last.base());
 669             this->_M_invalidate_after_nth(__offset);
 670             return iterator(__res, this);
 671           }
 672         else
 673 #if __cplusplus >= 201103L
 674           return begin() + (__first.base() - cbegin().base());
 675 #else
 676           return __first;
 677 #endif
 678       }
 679
 680       void
 681       swap(vector& __x)
 682       _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
 683       {
 684         _Safe::_M_swap(__x);
 685         _Base::swap(__x);
 686         std::swap(this->_M_guaranteed_capacity, __x._M_guaranteed_capacity);
 687       }
 688
 689       void
 690       clear() _GLIBCXX_NOEXCEPT
 691       {
 692         _Base::clear();
 693         this->_M_invalidate_all();
 694       }
 695
 696       _Base&
 697       _M_base() _GLIBCXX_NOEXCEPT { return *this; }
 698
 699       const _Base&
 700       _M_base() const _GLIBCXX_NOEXCEPT { return *this; }
 701
 702     private:
 703       void
 704       _M_invalidate_after_nth(difference_type __n) _GLIBCXX_NOEXCEPT
 705       {
 706         typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
 707         this->_M_invalidate_if(_After_nth(__n, _Base::begin()));
 708       }
 709     };
 710
 711   template<typename _Tp, typename _Alloc>
 712     inline bool
 713     operator==(const vector<_Tp, _Alloc>& __lhs,
 714                const vector<_Tp, _Alloc>& __rhs)
 715     { return __lhs._M_base() == __rhs._M_base(); }
 716
 717   template<typename _Tp, typename _Alloc>
 718     inline bool
 719     operator!=(const vector<_Tp, _Alloc>& __lhs,
 720                const vector<_Tp, _Alloc>& __rhs)
 721     { return __lhs._M_base() != __rhs._M_base(); }
 722
 723   template<typename _Tp, typename _Alloc>
 724     inline bool
 725     operator<(const vector<_Tp, _Alloc>& __lhs,
 726               const vector<_Tp, _Alloc>& __rhs)
 727     { return __lhs._M_base() < __rhs._M_base(); }
 728
 729   template<typename _Tp, typename _Alloc>
 730     inline bool
 731     operator<=(const vector<_Tp, _Alloc>& __lhs,
 732                const vector<_Tp, _Alloc>& __rhs)
 733     { return __lhs._M_base() <= __rhs._M_base(); }
 734
 735   template<typename _Tp, typename _Alloc>
 736     inline bool
 737     operator>=(const vector<_Tp, _Alloc>& __lhs,
 738                const vector<_Tp, _Alloc>& __rhs)
 739     { return __lhs._M_base() >= __rhs._M_base(); }
 740
 741   template<typename _Tp, typename _Alloc>
 742     inline bool
 743     operator>(const vector<_Tp, _Alloc>& __lhs,
 744               const vector<_Tp, _Alloc>& __rhs)
 745     { return __lhs._M_base() > __rhs._M_base(); }
 746
 747   template<typename _Tp, typename _Alloc>
 748     inline void
 749     swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
 750     _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
 751     { __lhs.swap(__rhs); }
 752
 753 } // namespace __debug
 754
 755 #if __cplusplus >= 201103L
 756   // DR 1182.
 757   /// std::hash specialization for vector<bool>.
 758   template<typename _Alloc>
 759     struct hash<__debug::vector<bool, _Alloc>>
 760     : public __hash_base<size_t, __debug::vector<bool, _Alloc>>
 761     {
 762       size_t
 763       operator()(const __debug::vector<bool, _Alloc>& __b) const noexcept
 764       { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>()(__b); }
 765     };
 766 #endif
 767
 768 } // namespace std
 769
 770 namespace __gnu_debug
 771 {
 772   template<typename _Tp, typename _Alloc>
 773     struct _Is_contiguous_sequence<std::__debug::vector<_Tp, _Alloc> >
 774     : std::__true_type
 775     { };
 776
 777   template<typename _Alloc>
 778     struct _Is_contiguous_sequence<std::__debug::vector<bool, _Alloc> >
 779     : std::__false_type
 780     { };
 781 }
 782
 783 #endif