libstdc++
safe_iterator.h
Go to the documentation of this file.
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