contrib/gcc-4.7/libstdc++-v3/include/debug/safe_iterator.h

   1 // Safe iterator implementation  -*- C++ -*-
   2
   3 // Copyright (C) 2003, 2004, 2005, 2006, 2009, 2010, 2011, 2012
   4 // Free Software Foundation, Inc.
   5 //
   6 // This file is part of the GNU ISO C++ Library.  This library is free
   7 // software; you can redistribute it and/or modify it under the
   8 // terms of the GNU General Public License as published by the
   9 // Free Software Foundation; either version 3, or (at your option)
  10 // any later version.
  11
  12 // This library is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16
  17 // Under Section 7 of GPL version 3, you are granted additional
  18 // permissions described in the GCC Runtime Library Exception, version
  19 // 3.1, as published by the Free Software Foundation.
  20
  21 // You should have received a copy of the GNU General Public License and
  22 // a copy of the GCC Runtime Library Exception along with this program;
  23 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24 // <http://www.gnu.org/licenses/>.
  25
  26 /** @file debug/safe_iterator.h
  27  *  This file is a GNU debug extension to the Standard C++ Library.
  28  */
  29
  30 #ifndef _GLIBCXX_DEBUG_SAFE_ITERATOR_H
  31 #define _GLIBCXX_DEBUG_SAFE_ITERATOR_H 1
  32
  33 #include <debug/debug.h>
  34 #include <debug/macros.h>
  35 #include <debug/functions.h>
  36 #include <debug/safe_base.h>
  37 #include <bits/stl_pair.h>
  38 #include <bits/stl_iterator_base_types.h> // for _Iter_base
  39 #include <ext/type_traits.h>
  40
  41 namespace __gnu_debug
  42 {
  43   /** Helper struct to deal with sequence offering a before_begin
  44    *  iterator.
  45    **/
  46   template <typename _Sequence>
  47     struct _BeforeBeginHelper
  48     {
  49       typedef typename _Sequence::const_iterator _It;
  50       typedef typename _It::iterator_type _BaseIt;
  51
  52       static bool
  53       _S_Is(_BaseIt, const _Sequence*)
  54       { return false; }
  55
  56       static bool
  57       _S_Is_Beginnest(_BaseIt __it, const _Sequence* __seq)
  58       { return __it == __seq->_M_base().begin(); }
  59     };
  60
  61   /** Iterators that derive from _Safe_iterator_base but that aren't
  62    *  _Safe_iterators can be determined singular or non-singular via
  63    *  _Safe_iterator_base.
  64    */
  65   inline bool
  66   __check_singular_aux(const _Safe_iterator_base* __x)
  67   { return __x->_M_singular(); }
  68
  69   /** The precision to which we can calculate the distance between
  70    *  two iterators.
  71    */
  72   enum _Distance_precision
  73     {
  74       __dp_equality, //< Can compare iterator equality, only
  75       __dp_sign,     //< Can determine equality and ordering
  76       __dp_exact     //< Can determine distance precisely
  77     };
  78
  79   /** Determine the distance between two iterators with some known
  80    *    precision.
  81   */
  82   template<typename _Iterator1, typename _Iterator2>
  83     inline std::pair<typename std::iterator_traits<_Iterator1>::difference_type,
  84                      _Distance_precision>
  85     __get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs,
  86                    std::random_access_iterator_tag)
  87     { return std::make_pair(__rhs - __lhs, __dp_exact); }
  88
  89   template<typename _Iterator1, typename _Iterator2>
  90     inline std::pair<typename std::iterator_traits<_Iterator1>::difference_type,
  91                      _Distance_precision>
  92     __get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs,
  93                    std::forward_iterator_tag)
  94     { return std::make_pair(__lhs == __rhs? 0 : 1, __dp_equality); }
  95
  96   template<typename _Iterator1, typename _Iterator2>
  97     inline std::pair<typename std::iterator_traits<_Iterator1>::difference_type,
  98                      _Distance_precision>
  99     __get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs)
 100     {
 101       typedef typename std::iterator_traits<_Iterator1>::iterator_category
 102           _Category;
 103       return __get_distance(__lhs, __rhs, _Category());
 104     }
 105
 106   /** \brief Safe iterator wrapper.
 107    *
 108    *  The class template %_Safe_iterator is a wrapper around an
 109    *  iterator that tracks the iterator's movement among sequences and
 110    *  checks that operations performed on the "safe" iterator are
 111    *  legal. In additional to the basic iterator operations (which are
 112    *  validated, and then passed to the underlying iterator),
 113    *  %_Safe_iterator has member functions for iterator invalidation,
 114    *  attaching/detaching the iterator from sequences, and querying
 115    *  the iterator's state.
 116    */
 117   template<typename _Iterator, typename _Sequence>
 118     class _Safe_iterator : public _Safe_iterator_base
 119     {
 120       typedef _Safe_iterator _Self;
 121
 122       /// The underlying iterator
 123       _Iterator _M_current;
 124
 125       /// Determine if this is a constant iterator.
 126       bool
 127       _M_constant() const
 128       {
 129         typedef typename _Sequence::const_iterator const_iterator;
 130         return std::__are_same<const_iterator, _Safe_iterator>::__value;
 131       }
 132
 133       typedef std::iterator_traits<_Iterator> _Traits;
 134
 135     public:
 136       typedef _Iterator                           iterator_type;
 137       typedef typename _Traits::iterator_category iterator_category;
 138       typedef typename _Traits::value_type        value_type;
 139       typedef typename _Traits::difference_type   difference_type;
 140       typedef typename _Traits::reference         reference;
 141       typedef typename _Traits::pointer           pointer;
 142
 143       /// @post the iterator is singular and unattached
 144       _Safe_iterator() : _M_current() { }
 145
 146       /**
 147        * @brief Safe iterator construction from an unsafe iterator and
 148        * its sequence.
 149        *
 150        * @pre @p seq is not NULL
 151        * @post this is not singular
 152        */
 153       _Safe_iterator(const _Iterator& __i, const _Sequence* __seq)
 154       : _Safe_iterator_base(__seq, _M_constant()), _M_current(__i)
 155       {
 156         _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(),
 157                               _M_message(__msg_init_singular)
 158                               ._M_iterator(*this, "this"));
 159       }
 160
 161       /**
 162        * @brief Copy construction.
 163        */
 164       _Safe_iterator(const _Safe_iterator& __x)
 165       : _Safe_iterator_base(__x, _M_constant()), _M_current(__x._M_current)
 166       {
 167         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 168         // DR 408. Is vector<reverse_iterator<char*> > forbidden?
 169         _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 170                               || __x._M_current == _Iterator(),
 171                               _M_message(__msg_init_copy_singular)
 172                               ._M_iterator(*this, "this")
 173                               ._M_iterator(__x, "other"));
 174       }
 175
 176 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 177       /**
 178        * @brief Move construction.
 179        * @post __x is singular and unattached
 180        */
 181       _Safe_iterator(_Safe_iterator&& __x) : _M_current()
 182       {
 183         _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 184                               || __x._M_current == _Iterator(),
 185                               _M_message(__msg_init_copy_singular)
 186                               ._M_iterator(*this, "this")
 187                               ._M_iterator(__x, "other"));
 188         std::swap(_M_current, __x._M_current);
 189         this->_M_attach(__x._M_sequence);
 190         __x._M_detach();
 191       }
 192 #endif
 193
 194       /**
 195        *  @brief Converting constructor from a mutable iterator to a
 196        *  constant iterator.
 197       */
 198       template<typename _MutableIterator>
 199         _Safe_iterator(
 200           const _Safe_iterator<_MutableIterator,
 201           typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator,
 202                       typename _Sequence::iterator::iterator_type>::__value),
 203                    _Sequence>::__type>& __x)
 204         : _Safe_iterator_base(__x, _M_constant()), _M_current(__x.base())
 205         {
 206           // _GLIBCXX_RESOLVE_LIB_DEFECTS
 207           // DR 408. Is vector<reverse_iterator<char*> > forbidden?
 208           _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 209                                 || __x.base() == _Iterator(),
 210                                 _M_message(__msg_init_const_singular)
 211                                 ._M_iterator(*this, "this")
 212                                 ._M_iterator(__x, "other"));
 213         }
 214
 215       /**
 216        * @brief Copy assignment.
 217        */
 218       _Safe_iterator&
 219       operator=(const _Safe_iterator& __x)
 220       {
 221         // _GLIBCXX_RESOLVE_LIB_DEFECTS
 222         // DR 408. Is vector<reverse_iterator<char*> > forbidden?
 223         _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 224                               || __x._M_current == _Iterator(),
 225                               _M_message(__msg_copy_singular)
 226                               ._M_iterator(*this, "this")
 227                               ._M_iterator(__x, "other"));
 228         _M_current = __x._M_current;
 229         this->_M_attach(__x._M_sequence);
 230         return *this;
 231       }
 232
 233 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 234       /**
 235        * @brief Move assignment.
 236        * @post __x is singular and unattached
 237        */
 238       _Safe_iterator&
 239       operator=(_Safe_iterator&& __x)
 240       {
 241         _GLIBCXX_DEBUG_VERIFY(!__x._M_singular()
 242                               || __x._M_current == _Iterator(),
 243                               _M_message(__msg_copy_singular)
 244                               ._M_iterator(*this, "this")
 245                               ._M_iterator(__x, "other"));
 246         _M_current = __x._M_current;
 247         _M_attach(__x._M_sequence);
 248         __x._M_detach();
 249         __x._M_current = _Iterator();
 250         return *this;
 251       }
 252 #endif
 253
 254       /**
 255        *  @brief Iterator dereference.
 256        *  @pre iterator is dereferenceable
 257        */
 258       reference
 259       operator*() const
 260       {
 261         _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
 262                               _M_message(__msg_bad_deref)
 263                               ._M_iterator(*this, "this"));
 264         return *_M_current;
 265       }
 266
 267       /**
 268        *  @brief Iterator dereference.
 269        *  @pre iterator is dereferenceable
 270        *  @todo Make this correct w.r.t. iterators that return proxies
 271        *  @todo Use addressof() instead of & operator
 272        */
 273       pointer
 274       operator->() const
 275       {
 276         _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(),
 277                               _M_message(__msg_bad_deref)
 278                               ._M_iterator(*this, "this"));
 279         return &*_M_current;
 280       }
 281
 282       // ------ Input iterator requirements ------
 283       /**
 284        *  @brief Iterator preincrement
 285        *  @pre iterator is incrementable
 286        */
 287       _Safe_iterator&
 288       operator++()
 289       {
 290         _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
 291                               _M_message(__msg_bad_inc)
 292                               ._M_iterator(*this, "this"));
 293         ++_M_current;
 294         return *this;
 295       }
 296
 297       /**
 298        *  @brief Iterator postincrement
 299        *  @pre iterator is incrementable
 300        */
 301       _Safe_iterator
 302       operator++(int)
 303       {
 304         _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(),
 305                               _M_message(__msg_bad_inc)
 306                               ._M_iterator(*this, "this"));
 307         _Safe_iterator __tmp(*this);
 308         ++_M_current;
 309         return __tmp;
 310       }
 311
 312       // ------ Bidirectional iterator requirements ------
 313       /**
 314        *  @brief Iterator predecrement
 315        *  @pre iterator is decrementable
 316        */
 317       _Safe_iterator&
 318       operator--()
 319       {
 320         _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
 321                               _M_message(__msg_bad_dec)
 322                               ._M_iterator(*this, "this"));
 323         --_M_current;
 324         return *this;
 325       }
 326
 327       /**
 328        *  @brief Iterator postdecrement
 329        *  @pre iterator is decrementable
 330        */
 331       _Safe_iterator
 332       operator--(int)
 333       {
 334         _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(),
 335                               _M_message(__msg_bad_dec)
 336                               ._M_iterator(*this, "this"));
 337         _Safe_iterator __tmp(*this);
 338         --_M_current;
 339         return __tmp;
 340       }
 341
 342       // ------ Random access iterator requirements ------
 343       reference
 344       operator[](const difference_type& __n) const
 345       {
 346         _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n)
 347                               && this->_M_can_advance(__n+1),
 348                               _M_message(__msg_iter_subscript_oob)
 349                               ._M_iterator(*this)._M_integer(__n));
 350
 351         return _M_current[__n];
 352       }
 353
 354       _Safe_iterator&
 355       operator+=(const difference_type& __n)
 356       {
 357         _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n),
 358                               _M_message(__msg_advance_oob)
 359                               ._M_iterator(*this)._M_integer(__n));
 360         _M_current += __n;
 361         return *this;
 362       }
 363
 364       _Safe_iterator
 365       operator+(const difference_type& __n) const
 366       {
 367         _Safe_iterator __tmp(*this);
 368         __tmp += __n;
 369         return __tmp;
 370       }
 371
 372       _Safe_iterator&
 373       operator-=(const difference_type& __n)
 374       {
 375         _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n),
 376                               _M_message(__msg_retreat_oob)
 377                               ._M_iterator(*this)._M_integer(__n));
 378         _M_current += -__n;
 379         return *this;
 380       }
 381
 382       _Safe_iterator
 383       operator-(const difference_type& __n) const
 384       {
 385         _Safe_iterator __tmp(*this);
 386         __tmp -= __n;
 387         return __tmp;
 388       }
 389
 390       // ------ Utilities ------
 391       /**
 392        * @brief Return the underlying iterator
 393        */
 394       _Iterator
 395       base() const { return _M_current; }
 396
 397       /**
 398        * @brief Conversion to underlying non-debug iterator to allow
 399        * better interaction with non-debug containers.
 400        */
 401       operator _Iterator() const { return _M_current; }
 402
 403       /** Attach iterator to the given sequence. */
 404       void
 405       _M_attach(_Safe_sequence_base* __seq)
 406       {
 407         _Safe_iterator_base::_M_attach(__seq, _M_constant());
 408       }
 409
 410       /** Likewise, but not thread-safe. */
 411       void
 412       _M_attach_single(_Safe_sequence_base* __seq)
 413       {
 414         _Safe_iterator_base::_M_attach_single(__seq, _M_constant());
 415       }
 416
 417       /// Is the iterator dereferenceable?
 418       bool
 419       _M_dereferenceable() const
 420       { return !this->_M_singular() && !_M_is_end() && !_M_is_before_begin(); }
 421
 422       /// Is the iterator before a dereferenceable one?
 423       bool
 424       _M_before_dereferenceable() const
 425       {
 426         if (this->_M_incrementable())
 427         {
 428           _Iterator __base = base();
 429           return ++__base != _M_get_sequence()->_M_base().end();
 430         }
 431         return false;
 432       }
 433
 434       /// Is the iterator incrementable?
 435       bool
 436       _M_incrementable() const
 437       { return !this->_M_singular() && !_M_is_end(); }
 438
 439       // Is the iterator decrementable?
 440       bool
 441       _M_decrementable() const { return !_M_singular() && !_M_is_begin(); }
 442
 443       // Can we advance the iterator @p __n steps (@p __n may be negative)
 444       bool
 445       _M_can_advance(const difference_type& __n) const;
 446
 447       // Is the iterator range [*this, __rhs) valid?
 448       template<typename _Other>
 449         bool
 450         _M_valid_range(const _Safe_iterator<_Other, _Sequence>& __rhs) const;
 451
 452       // The sequence this iterator references.
 453       const _Sequence*
 454       _M_get_sequence() const
 455       { return static_cast<const _Sequence*>(_M_sequence); }
 456
 457       /// Is this iterator equal to the sequence's begin() iterator?
 458       bool _M_is_begin() const
 459       { return base() == _M_get_sequence()->_M_base().begin(); }
 460
 461       /// Is this iterator equal to the sequence's end() iterator?
 462       bool _M_is_end() const
 463       { return base() == _M_get_sequence()->_M_base().end(); }
 464
 465       /// Is this iterator equal to the sequence's before_begin() iterator if
 466       /// any?
 467       bool _M_is_before_begin() const
 468       {
 469         return _BeforeBeginHelper<_Sequence>::_S_Is(base(), _M_get_sequence());
 470       }
 471
 472       /// Is this iterator equal to the sequence's before_begin() iterator if
 473       /// any or begin() otherwise?
 474       bool _M_is_beginnest() const
 475       {
 476         return _BeforeBeginHelper<_Sequence>::_S_Is_Beginnest(base(),
 477                                                           _M_get_sequence());
 478       }
 479     };
 480
 481   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
 482     inline bool
 483     operator==(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 484                const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
 485     {
 486       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 487                             _M_message(__msg_iter_compare_bad)
 488                             ._M_iterator(__lhs, "lhs")
 489                             ._M_iterator(__rhs, "rhs"));
 490       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 491                             _M_message(__msg_compare_different)
 492                             ._M_iterator(__lhs, "lhs")
 493                             ._M_iterator(__rhs, "rhs"));
 494       return __lhs.base() == __rhs.base();
 495     }
 496
 497   template<typename _Iterator, typename _Sequence>
 498     inline bool
 499     operator==(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 500                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
 501     {
 502       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 503                             _M_message(__msg_iter_compare_bad)
 504                             ._M_iterator(__lhs, "lhs")
 505                             ._M_iterator(__rhs, "rhs"));
 506       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 507                             _M_message(__msg_compare_different)
 508                             ._M_iterator(__lhs, "lhs")
 509                             ._M_iterator(__rhs, "rhs"));
 510       return __lhs.base() == __rhs.base();
 511     }
 512
 513   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
 514     inline bool
 515     operator!=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 516                const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
 517     {
 518       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 519                             _M_message(__msg_iter_compare_bad)
 520                             ._M_iterator(__lhs, "lhs")
 521                             ._M_iterator(__rhs, "rhs"));
 522       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 523                             _M_message(__msg_compare_different)
 524                             ._M_iterator(__lhs, "lhs")
 525                             ._M_iterator(__rhs, "rhs"));
 526       return __lhs.base() != __rhs.base();
 527     }
 528
 529   template<typename _Iterator, typename _Sequence>
 530     inline bool
 531     operator!=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 532                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
 533     {
 534       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 535                             _M_message(__msg_iter_compare_bad)
 536                             ._M_iterator(__lhs, "lhs")
 537                             ._M_iterator(__rhs, "rhs"));
 538       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 539                             _M_message(__msg_compare_different)
 540                             ._M_iterator(__lhs, "lhs")
 541                             ._M_iterator(__rhs, "rhs"));
 542       return __lhs.base() != __rhs.base();
 543     }
 544
 545   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
 546     inline bool
 547     operator<(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 548               const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
 549     {
 550       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 551                             _M_message(__msg_iter_order_bad)
 552                             ._M_iterator(__lhs, "lhs")
 553                             ._M_iterator(__rhs, "rhs"));
 554       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 555                             _M_message(__msg_order_different)
 556                             ._M_iterator(__lhs, "lhs")
 557                             ._M_iterator(__rhs, "rhs"));
 558       return __lhs.base() < __rhs.base();
 559     }
 560
 561   template<typename _Iterator, typename _Sequence>
 562     inline bool
 563     operator<(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 564               const _Safe_iterator<_Iterator, _Sequence>& __rhs)
 565     {
 566       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 567                             _M_message(__msg_iter_order_bad)
 568                             ._M_iterator(__lhs, "lhs")
 569                             ._M_iterator(__rhs, "rhs"));
 570       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 571                             _M_message(__msg_order_different)
 572                             ._M_iterator(__lhs, "lhs")
 573                             ._M_iterator(__rhs, "rhs"));
 574       return __lhs.base() < __rhs.base();
 575     }
 576
 577   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
 578     inline bool
 579     operator<=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 580                const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
 581     {
 582       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 583                             _M_message(__msg_iter_order_bad)
 584                             ._M_iterator(__lhs, "lhs")
 585                             ._M_iterator(__rhs, "rhs"));
 586       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 587                             _M_message(__msg_order_different)
 588                             ._M_iterator(__lhs, "lhs")
 589                             ._M_iterator(__rhs, "rhs"));
 590       return __lhs.base() <= __rhs.base();
 591     }
 592
 593   template<typename _Iterator, typename _Sequence>
 594     inline bool
 595     operator<=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 596                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
 597     {
 598       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 599                             _M_message(__msg_iter_order_bad)
 600                             ._M_iterator(__lhs, "lhs")
 601                             ._M_iterator(__rhs, "rhs"));
 602       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 603                             _M_message(__msg_order_different)
 604                             ._M_iterator(__lhs, "lhs")
 605                             ._M_iterator(__rhs, "rhs"));
 606       return __lhs.base() <= __rhs.base();
 607     }
 608
 609   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
 610     inline bool
 611     operator>(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 612               const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
 613     {
 614       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 615                             _M_message(__msg_iter_order_bad)
 616                             ._M_iterator(__lhs, "lhs")
 617                             ._M_iterator(__rhs, "rhs"));
 618       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 619                             _M_message(__msg_order_different)
 620                             ._M_iterator(__lhs, "lhs")
 621                             ._M_iterator(__rhs, "rhs"));
 622       return __lhs.base() > __rhs.base();
 623     }
 624
 625   template<typename _Iterator, typename _Sequence>
 626     inline bool
 627     operator>(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 628               const _Safe_iterator<_Iterator, _Sequence>& __rhs)
 629     {
 630       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 631                             _M_message(__msg_iter_order_bad)
 632                             ._M_iterator(__lhs, "lhs")
 633                             ._M_iterator(__rhs, "rhs"));
 634       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 635                             _M_message(__msg_order_different)
 636                             ._M_iterator(__lhs, "lhs")
 637                             ._M_iterator(__rhs, "rhs"));
 638       return __lhs.base() > __rhs.base();
 639     }
 640
 641   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
 642     inline bool
 643     operator>=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 644                const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
 645     {
 646       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 647                             _M_message(__msg_iter_order_bad)
 648                             ._M_iterator(__lhs, "lhs")
 649                             ._M_iterator(__rhs, "rhs"));
 650       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 651                             _M_message(__msg_order_different)
 652                             ._M_iterator(__lhs, "lhs")
 653                             ._M_iterator(__rhs, "rhs"));
 654       return __lhs.base() >= __rhs.base();
 655     }
 656
 657   template<typename _Iterator, typename _Sequence>
 658     inline bool
 659     operator>=(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 660                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
 661     {
 662       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 663                             _M_message(__msg_iter_order_bad)
 664                             ._M_iterator(__lhs, "lhs")
 665                             ._M_iterator(__rhs, "rhs"));
 666       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 667                             _M_message(__msg_order_different)
 668                             ._M_iterator(__lhs, "lhs")
 669                             ._M_iterator(__rhs, "rhs"));
 670       return __lhs.base() >= __rhs.base();
 671     }
 672
 673   // _GLIBCXX_RESOLVE_LIB_DEFECTS
 674   // According to the resolution of DR179 not only the various comparison
 675   // operators but also operator- must accept mixed iterator/const_iterator
 676   // parameters.
 677   template<typename _IteratorL, typename _IteratorR, typename _Sequence>
 678     inline typename _Safe_iterator<_IteratorL, _Sequence>::difference_type
 679     operator-(const _Safe_iterator<_IteratorL, _Sequence>& __lhs,
 680               const _Safe_iterator<_IteratorR, _Sequence>& __rhs)
 681     {
 682       _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 683                             _M_message(__msg_distance_bad)
 684                             ._M_iterator(__lhs, "lhs")
 685                             ._M_iterator(__rhs, "rhs"));
 686       _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 687                             _M_message(__msg_distance_different)
 688                             ._M_iterator(__lhs, "lhs")
 689                             ._M_iterator(__rhs, "rhs"));
 690       return __lhs.base() - __rhs.base();
 691     }
 692
 693    template<typename _Iterator, typename _Sequence>
 694      inline typename _Safe_iterator<_Iterator, _Sequence>::difference_type
 695      operator-(const _Safe_iterator<_Iterator, _Sequence>& __lhs,
 696                const _Safe_iterator<_Iterator, _Sequence>& __rhs)
 697      {
 698        _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(),
 699                              _M_message(__msg_distance_bad)
 700                              ._M_iterator(__lhs, "lhs")
 701                              ._M_iterator(__rhs, "rhs"));
 702        _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs),
 703                              _M_message(__msg_distance_different)
 704                              ._M_iterator(__lhs, "lhs")
 705                              ._M_iterator(__rhs, "rhs"));
 706        return __lhs.base() - __rhs.base();
 707      }
 708
 709   template<typename _Iterator, typename _Sequence>
 710     inline _Safe_iterator<_Iterator, _Sequence>
 711     operator+(typename _Safe_iterator<_Iterator,_Sequence>::difference_type __n,
 712               const _Safe_iterator<_Iterator, _Sequence>& __i)
 713     { return __i + __n; }
 714
 715   // Helper struct to detect random access safe iterators.
 716   template<typename _Iterator>
 717     struct __is_safe_random_iterator
 718     {
 719       enum { __value = 0 };
 720       typedef std::__false_type __type;
 721     };
 722
 723   template<typename _Iterator, typename _Sequence>
 724     struct __is_safe_random_iterator<_Safe_iterator<_Iterator, _Sequence> >
 725     : std::__are_same<std::random_access_iterator_tag,
 726                       typename std::iterator_traits<_Iterator>::
 727                       iterator_category>
 728     { };
 729
 730   template<typename _Iterator>
 731     struct _Siter_base
 732     : std::_Iter_base<_Iterator, __is_safe_random_iterator<_Iterator>::__value>
 733     { };
 734
 735   /** Helper function to extract base iterator of random access safe iterator
 736       in order to reduce performance impact of debug mode.  Limited to random
 737       access iterator because it is the only category for which it is possible
 738       to check for correct iterators order in the __valid_range function
 739       thanks to the < operator.
 740   */
 741   template<typename _Iterator>
 742     inline typename _Siter_base<_Iterator>::iterator_type
 743     __base(_Iterator __it)
 744     { return _Siter_base<_Iterator>::_S_base(__it); }
 745 } // namespace __gnu_debug
 746
 747 #include <debug/safe_iterator.tcc>
 748
 749 #endif