1// Safe iterator implementation -*- C++ -*- 2 3// Copyright (C) 2003, 2004, 2005, 2006 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 2, 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// You should have received a copy of the GNU General Public License along 18// with this library; see the file COPYING. If not, write to the Free 19// Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 20// USA. 21 22// As a special exception, you may use this file as part of a free software 23// library without restriction. Specifically, if other files instantiate 24// templates or use macros or inline functions from this file, or you compile 25// this file and link it with other files to produce an executable, this 26// file does not by itself cause the resulting executable to be covered by 27// the GNU General Public License. This exception does not however 28// invalidate any other reasons why the executable file might be covered by 29// the GNU General Public License. 30 31/** @file debug/safe_iterator.h 32 * This file is a GNU debug extension to the Standard C++ Library. 33 */ 34 35#ifndef _GLIBCXX_DEBUG_SAFE_ITERATOR_H 36#define _GLIBCXX_DEBUG_SAFE_ITERATOR_H 1 37 38#include <debug/debug.h> 39#include <debug/macros.h> 40#include <debug/functions.h> 41#include <debug/formatter.h> 42#include <debug/safe_base.h> 43#include <bits/stl_pair.h> 44#include <ext/type_traits.h> 45 46namespace __gnu_debug 47{ 48 /** Iterators that derive from _Safe_iterator_base but that aren't 49 * _Safe_iterators can be determined singular or non-singular via 50 * _Safe_iterator_base. 51 */ 52 inline bool 53 __check_singular_aux(const _Safe_iterator_base* __x) 54 { return __x->_M_singular(); } 55 56 /** \brief Safe iterator wrapper. 57 * 58 * The class template %_Safe_iterator is a wrapper around an 59 * iterator that tracks the iterator's movement among sequences and 60 * checks that operations performed on the "safe" iterator are 61 * legal. In additional to the basic iterator operations (which are 62 * validated, and then passed to the underlying iterator), 63 * %_Safe_iterator has member functions for iterator invalidation, 64 * attaching/detaching the iterator from sequences, and querying 65 * the iterator's state. 66 */ 67 template<typename _Iterator, typename _Sequence> 68 class _Safe_iterator : public _Safe_iterator_base 69 { 70 typedef _Safe_iterator _Self; 71 72 /** The precision to which we can calculate the distance between 73 * two iterators. 74 */ 75 enum _Distance_precision 76 { 77 __dp_equality, //< Can compare iterator equality, only 78 __dp_sign, //< Can determine equality and ordering 79 __dp_exact //< Can determine distance precisely 80 }; 81 82 /// The underlying iterator 83 _Iterator _M_current; 84 85 /// Determine if this is a constant iterator. 86 bool 87 _M_constant() const 88 { 89 typedef typename _Sequence::const_iterator const_iterator; 90 return __is_same<const_iterator, _Safe_iterator>::value; 91 } 92 93 typedef std::iterator_traits<_Iterator> _Traits; 94 95 public: 96 typedef _Iterator _Base_iterator; 97 typedef typename _Traits::iterator_category iterator_category; 98 typedef typename _Traits::value_type value_type; 99 typedef typename _Traits::difference_type difference_type; 100 typedef typename _Traits::reference reference; 101 typedef typename _Traits::pointer pointer; 102 103 /// @post the iterator is singular and unattached 104 _Safe_iterator() : _M_current() { } 105 106 /** 107 * @brief Safe iterator construction from an unsafe iterator and 108 * its sequence. 109 * 110 * @pre @p seq is not NULL 111 * @post this is not singular 112 */ 113 _Safe_iterator(const _Iterator& __i, const _Sequence* __seq) 114 : _Safe_iterator_base(__seq, _M_constant()), _M_current(__i) 115 { 116 _GLIBCXX_DEBUG_VERIFY(! this->_M_singular(), 117 _M_message(__msg_init_singular) 118 ._M_iterator(*this, "this")); 119 } 120 121 /** 122 * @brief Copy construction. 123 * @pre @p x is not singular 124 */ 125 _Safe_iterator(const _Safe_iterator& __x) 126 : _Safe_iterator_base(__x, _M_constant()), _M_current(__x._M_current) 127 { 128 _GLIBCXX_DEBUG_VERIFY(!__x._M_singular(), 129 _M_message(__msg_init_copy_singular) 130 ._M_iterator(*this, "this") 131 ._M_iterator(__x, "other")); 132 } 133 134 /** 135 * @brief Converting constructor from a mutable iterator to a 136 * constant iterator. 137 * 138 * @pre @p x is not singular 139 */ 140 template<typename _MutableIterator> 141 _Safe_iterator( 142 const _Safe_iterator<_MutableIterator, 143 typename __gnu_cxx::__enable_if<(std::__are_same<_MutableIterator, 144 typename _Sequence::iterator::_Base_iterator>::__value), 145 _Sequence>::__type>& __x) 146 : _Safe_iterator_base(__x, _M_constant()), _M_current(__x.base()) 147 { 148 _GLIBCXX_DEBUG_VERIFY(!__x._M_singular(), 149 _M_message(__msg_init_const_singular) 150 ._M_iterator(*this, "this") 151 ._M_iterator(__x, "other")); 152 } 153 154 /** 155 * @brief Copy assignment. 156 * @pre @p x is not singular 157 */ 158 _Safe_iterator& 159 operator=(const _Safe_iterator& __x) 160 { 161 _GLIBCXX_DEBUG_VERIFY(!__x._M_singular(), 162 _M_message(__msg_copy_singular) 163 ._M_iterator(*this, "this") 164 ._M_iterator(__x, "other")); 165 _M_current = __x._M_current; 166 this->_M_attach(static_cast<_Sequence*>(__x._M_sequence)); 167 return *this; 168 } 169 170 /** 171 * @brief Iterator dereference. 172 * @pre iterator is dereferenceable 173 */ 174 reference 175 operator*() const 176 { 177 178 _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(), 179 _M_message(__msg_bad_deref) 180 ._M_iterator(*this, "this")); 181 return *_M_current; 182 } 183 184 /** 185 * @brief Iterator dereference. 186 * @pre iterator is dereferenceable 187 * @todo Make this correct w.r.t. iterators that return proxies 188 * @todo Use addressof() instead of & operator 189 */ 190 pointer 191 operator->() const 192 { 193 _GLIBCXX_DEBUG_VERIFY(this->_M_dereferenceable(), 194 _M_message(__msg_bad_deref) 195 ._M_iterator(*this, "this")); 196 return &*_M_current; 197 } 198 199 // ------ Input iterator requirements ------ 200 /** 201 * @brief Iterator preincrement 202 * @pre iterator is incrementable 203 */ 204 _Safe_iterator& 205 operator++() 206 { 207 _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), 208 _M_message(__msg_bad_inc) 209 ._M_iterator(*this, "this")); 210 ++_M_current; 211 return *this; 212 } 213 214 /** 215 * @brief Iterator postincrement 216 * @pre iterator is incrementable 217 */ 218 _Safe_iterator 219 operator++(int) 220 { 221 _GLIBCXX_DEBUG_VERIFY(this->_M_incrementable(), 222 _M_message(__msg_bad_inc) 223 ._M_iterator(*this, "this")); 224 _Safe_iterator __tmp(*this); 225 ++_M_current; 226 return __tmp; 227 } 228 229 // ------ Bidirectional iterator requirements ------ 230 /** 231 * @brief Iterator predecrement 232 * @pre iterator is decrementable 233 */ 234 _Safe_iterator& 235 operator--() 236 { 237 _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(), 238 _M_message(__msg_bad_dec) 239 ._M_iterator(*this, "this")); 240 --_M_current; 241 return *this; 242 } 243 244 /** 245 * @brief Iterator postdecrement 246 * @pre iterator is decrementable 247 */ 248 _Safe_iterator 249 operator--(int) 250 { 251 _GLIBCXX_DEBUG_VERIFY(this->_M_decrementable(), 252 _M_message(__msg_bad_dec) 253 ._M_iterator(*this, "this")); 254 _Safe_iterator __tmp(*this); 255 --_M_current; 256 return __tmp; 257 } 258 259 // ------ Random access iterator requirements ------ 260 reference 261 operator[](const difference_type& __n) const 262 { 263 _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n) 264 && this->_M_can_advance(__n+1), 265 _M_message(__msg_iter_subscript_oob) 266 ._M_iterator(*this)._M_integer(__n)); 267 268 return _M_current[__n]; 269 } 270 271 _Safe_iterator& 272 operator+=(const difference_type& __n) 273 { 274 _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(__n), 275 _M_message(__msg_advance_oob) 276 ._M_iterator(*this)._M_integer(__n)); 277 _M_current += __n; 278 return *this; 279 } 280 281 _Safe_iterator 282 operator+(const difference_type& __n) const 283 { 284 _Safe_iterator __tmp(*this); 285 __tmp += __n; 286 return __tmp; 287 } 288 289 _Safe_iterator& 290 operator-=(const difference_type& __n) 291 { 292 _GLIBCXX_DEBUG_VERIFY(this->_M_can_advance(-__n), 293 _M_message(__msg_retreat_oob) 294 ._M_iterator(*this)._M_integer(__n)); 295 _M_current += -__n; 296 return *this; 297 } 298 299 _Safe_iterator 300 operator-(const difference_type& __n) const 301 { 302 _Safe_iterator __tmp(*this); 303 __tmp -= __n; 304 return __tmp; 305 } 306 307 // ------ Utilities ------ 308 /** 309 * @brief Return the underlying iterator 310 */ 311 _Iterator 312 base() const { return _M_current; } 313 314 /** 315 * @brief Conversion to underlying non-debug iterator to allow 316 * better interaction with non-debug containers. 317 */ 318 operator _Iterator() const { return _M_current; } 319 320 /** Attach iterator to the given sequence. */ 321 void 322 _M_attach(const _Sequence* __seq) 323 { 324 _Safe_iterator_base::_M_attach(const_cast<_Sequence*>(__seq), 325 _M_constant()); 326 } 327 328 /** Likewise, but not thread-safe. */ 329 void 330 _M_attach_single(const _Sequence* __seq) 331 { 332 _Safe_iterator_base::_M_attach_single(const_cast<_Sequence*>(__seq), 333 _M_constant()); 334 } 335 336 /** Invalidate the iterator, making it singular. */ 337 void 338 _M_invalidate(); 339 340 /** Likewise, but not thread-safe. */ 341 void 342 _M_invalidate_single(); 343 344 /// Is the iterator dereferenceable? 345 bool 346 _M_dereferenceable() const 347 { return !this->_M_singular() && !_M_is_end(); } 348 349 /// Is the iterator incrementable? 350 bool 351 _M_incrementable() const { return this->_M_dereferenceable(); } 352 353 // Is the iterator decrementable? 354 bool 355 _M_decrementable() const { return !_M_singular() && !_M_is_begin(); } 356 357 // Can we advance the iterator @p __n steps (@p __n may be negative) 358 bool 359 _M_can_advance(const difference_type& __n) const; 360 361 // Is the iterator range [*this, __rhs) valid? 362 template<typename _Other> 363 bool 364 _M_valid_range(const _Safe_iterator<_Other, _Sequence>& __rhs) const; 365 366 // The sequence this iterator references. 367 const _Sequence* 368 _M_get_sequence() const 369 { return static_cast<const _Sequence*>(_M_sequence); } 370 371 /** Determine the distance between two iterators with some known 372 * precision. 373 */ 374 template<typename _Iterator1, typename _Iterator2> 375 static std::pair<difference_type, _Distance_precision> 376 _M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs) 377 { 378 typedef typename std::iterator_traits<_Iterator1>::iterator_category 379 _Category; 380 return _M_get_distance(__lhs, __rhs, _Category()); 381 } 382 383 template<typename _Iterator1, typename _Iterator2> 384 static std::pair<difference_type, _Distance_precision> 385 _M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs, 386 std::random_access_iterator_tag) 387 { 388 return std::make_pair(__rhs.base() - __lhs.base(), __dp_exact); 389 } 390 391 template<typename _Iterator1, typename _Iterator2> 392 static std::pair<difference_type, _Distance_precision> 393 _M_get_distance(const _Iterator1& __lhs, const _Iterator2& __rhs, 394 std::forward_iterator_tag) 395 { 396 return std::make_pair(__lhs.base() == __rhs.base()? 0 : 1, 397 __dp_equality); 398 } 399 400 /// Is this iterator equal to the sequence's begin() iterator? 401 bool _M_is_begin() const 402 { return *this == static_cast<const _Sequence*>(_M_sequence)->begin(); } 403 404 /// Is this iterator equal to the sequence's end() iterator? 405 bool _M_is_end() const 406 { return *this == static_cast<const _Sequence*>(_M_sequence)->end(); } 407 }; 408 409 template<typename _IteratorL, typename _IteratorR, typename _Sequence> 410 inline bool 411 operator==(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, 412 const _Safe_iterator<_IteratorR, _Sequence>& __rhs) 413 { 414 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 415 _M_message(__msg_iter_compare_bad) 416 ._M_iterator(__lhs, "lhs") 417 ._M_iterator(__rhs, "rhs")); 418 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 419 _M_message(__msg_compare_different) 420 ._M_iterator(__lhs, "lhs") 421 ._M_iterator(__rhs, "rhs")); 422 return __lhs.base() == __rhs.base(); 423 } 424 425 template<typename _Iterator, typename _Sequence> 426 inline bool 427 operator==(const _Safe_iterator<_Iterator, _Sequence>& __lhs, 428 const _Safe_iterator<_Iterator, _Sequence>& __rhs) 429 { 430 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 431 _M_message(__msg_iter_compare_bad) 432 ._M_iterator(__lhs, "lhs") 433 ._M_iterator(__rhs, "rhs")); 434 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 435 _M_message(__msg_compare_different) 436 ._M_iterator(__lhs, "lhs") 437 ._M_iterator(__rhs, "rhs")); 438 return __lhs.base() == __rhs.base(); 439 } 440 441 template<typename _IteratorL, typename _IteratorR, typename _Sequence> 442 inline bool 443 operator!=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, 444 const _Safe_iterator<_IteratorR, _Sequence>& __rhs) 445 { 446 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 447 _M_message(__msg_iter_compare_bad) 448 ._M_iterator(__lhs, "lhs") 449 ._M_iterator(__rhs, "rhs")); 450 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 451 _M_message(__msg_compare_different) 452 ._M_iterator(__lhs, "lhs") 453 ._M_iterator(__rhs, "rhs")); 454 return __lhs.base() != __rhs.base(); 455 } 456 457 template<typename _Iterator, typename _Sequence> 458 inline bool 459 operator!=(const _Safe_iterator<_Iterator, _Sequence>& __lhs, 460 const _Safe_iterator<_Iterator, _Sequence>& __rhs) 461 { 462 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 463 _M_message(__msg_iter_compare_bad) 464 ._M_iterator(__lhs, "lhs") 465 ._M_iterator(__rhs, "rhs")); 466 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 467 _M_message(__msg_compare_different) 468 ._M_iterator(__lhs, "lhs") 469 ._M_iterator(__rhs, "rhs")); 470 return __lhs.base() != __rhs.base(); 471 } 472 473 template<typename _IteratorL, typename _IteratorR, typename _Sequence> 474 inline bool 475 operator<(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, 476 const _Safe_iterator<_IteratorR, _Sequence>& __rhs) 477 { 478 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 479 _M_message(__msg_iter_order_bad) 480 ._M_iterator(__lhs, "lhs") 481 ._M_iterator(__rhs, "rhs")); 482 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 483 _M_message(__msg_order_different) 484 ._M_iterator(__lhs, "lhs") 485 ._M_iterator(__rhs, "rhs")); 486 return __lhs.base() < __rhs.base(); 487 } 488 489 template<typename _Iterator, typename _Sequence> 490 inline bool 491 operator<(const _Safe_iterator<_Iterator, _Sequence>& __lhs, 492 const _Safe_iterator<_Iterator, _Sequence>& __rhs) 493 { 494 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 495 _M_message(__msg_iter_order_bad) 496 ._M_iterator(__lhs, "lhs") 497 ._M_iterator(__rhs, "rhs")); 498 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 499 _M_message(__msg_order_different) 500 ._M_iterator(__lhs, "lhs") 501 ._M_iterator(__rhs, "rhs")); 502 return __lhs.base() < __rhs.base(); 503 } 504 505 template<typename _IteratorL, typename _IteratorR, typename _Sequence> 506 inline bool 507 operator<=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, 508 const _Safe_iterator<_IteratorR, _Sequence>& __rhs) 509 { 510 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 511 _M_message(__msg_iter_order_bad) 512 ._M_iterator(__lhs, "lhs") 513 ._M_iterator(__rhs, "rhs")); 514 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 515 _M_message(__msg_order_different) 516 ._M_iterator(__lhs, "lhs") 517 ._M_iterator(__rhs, "rhs")); 518 return __lhs.base() <= __rhs.base(); 519 } 520 521 template<typename _Iterator, typename _Sequence> 522 inline bool 523 operator<=(const _Safe_iterator<_Iterator, _Sequence>& __lhs, 524 const _Safe_iterator<_Iterator, _Sequence>& __rhs) 525 { 526 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 527 _M_message(__msg_iter_order_bad) 528 ._M_iterator(__lhs, "lhs") 529 ._M_iterator(__rhs, "rhs")); 530 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 531 _M_message(__msg_order_different) 532 ._M_iterator(__lhs, "lhs") 533 ._M_iterator(__rhs, "rhs")); 534 return __lhs.base() <= __rhs.base(); 535 } 536 537 template<typename _IteratorL, typename _IteratorR, typename _Sequence> 538 inline bool 539 operator>(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, 540 const _Safe_iterator<_IteratorR, _Sequence>& __rhs) 541 { 542 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 543 _M_message(__msg_iter_order_bad) 544 ._M_iterator(__lhs, "lhs") 545 ._M_iterator(__rhs, "rhs")); 546 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 547 _M_message(__msg_order_different) 548 ._M_iterator(__lhs, "lhs") 549 ._M_iterator(__rhs, "rhs")); 550 return __lhs.base() > __rhs.base(); 551 } 552 553 template<typename _Iterator, typename _Sequence> 554 inline bool 555 operator>(const _Safe_iterator<_Iterator, _Sequence>& __lhs, 556 const _Safe_iterator<_Iterator, _Sequence>& __rhs) 557 { 558 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 559 _M_message(__msg_iter_order_bad) 560 ._M_iterator(__lhs, "lhs") 561 ._M_iterator(__rhs, "rhs")); 562 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 563 _M_message(__msg_order_different) 564 ._M_iterator(__lhs, "lhs") 565 ._M_iterator(__rhs, "rhs")); 566 return __lhs.base() > __rhs.base(); 567 } 568 569 template<typename _IteratorL, typename _IteratorR, typename _Sequence> 570 inline bool 571 operator>=(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, 572 const _Safe_iterator<_IteratorR, _Sequence>& __rhs) 573 { 574 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 575 _M_message(__msg_iter_order_bad) 576 ._M_iterator(__lhs, "lhs") 577 ._M_iterator(__rhs, "rhs")); 578 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 579 _M_message(__msg_order_different) 580 ._M_iterator(__lhs, "lhs") 581 ._M_iterator(__rhs, "rhs")); 582 return __lhs.base() >= __rhs.base(); 583 } 584 585 template<typename _Iterator, typename _Sequence> 586 inline bool 587 operator>=(const _Safe_iterator<_Iterator, _Sequence>& __lhs, 588 const _Safe_iterator<_Iterator, _Sequence>& __rhs) 589 { 590 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 591 _M_message(__msg_iter_order_bad) 592 ._M_iterator(__lhs, "lhs") 593 ._M_iterator(__rhs, "rhs")); 594 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 595 _M_message(__msg_order_different) 596 ._M_iterator(__lhs, "lhs") 597 ._M_iterator(__rhs, "rhs")); 598 return __lhs.base() >= __rhs.base(); 599 } 600 601 // _GLIBCXX_RESOLVE_LIB_DEFECTS 602 // According to the resolution of DR179 not only the various comparison 603 // operators but also operator- must accept mixed iterator/const_iterator 604 // parameters. 605 template<typename _IteratorL, typename _IteratorR, typename _Sequence> 606 inline typename _Safe_iterator<_IteratorL, _Sequence>::difference_type 607 operator-(const _Safe_iterator<_IteratorL, _Sequence>& __lhs, 608 const _Safe_iterator<_IteratorR, _Sequence>& __rhs) 609 { 610 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 611 _M_message(__msg_distance_bad) 612 ._M_iterator(__lhs, "lhs") 613 ._M_iterator(__rhs, "rhs")); 614 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 615 _M_message(__msg_distance_different) 616 ._M_iterator(__lhs, "lhs") 617 ._M_iterator(__rhs, "rhs")); 618 return __lhs.base() - __rhs.base(); 619 } 620 621 template<typename _Iterator, typename _Sequence> 622 inline typename _Safe_iterator<_Iterator, _Sequence>::difference_type 623 operator-(const _Safe_iterator<_Iterator, _Sequence>& __lhs, 624 const _Safe_iterator<_Iterator, _Sequence>& __rhs) 625 { 626 _GLIBCXX_DEBUG_VERIFY(! __lhs._M_singular() && ! __rhs._M_singular(), 627 _M_message(__msg_distance_bad) 628 ._M_iterator(__lhs, "lhs") 629 ._M_iterator(__rhs, "rhs")); 630 _GLIBCXX_DEBUG_VERIFY(__lhs._M_can_compare(__rhs), 631 _M_message(__msg_distance_different) 632 ._M_iterator(__lhs, "lhs") 633 ._M_iterator(__rhs, "rhs")); 634 return __lhs.base() - __rhs.base(); 635 } 636 637 template<typename _Iterator, typename _Sequence> 638 inline _Safe_iterator<_Iterator, _Sequence> 639 operator+(typename _Safe_iterator<_Iterator,_Sequence>::difference_type __n, 640 const _Safe_iterator<_Iterator, _Sequence>& __i) 641 { return __i + __n; } 642} // namespace __gnu_debug 643 644#ifndef _GLIBCXX_EXPORT_TEMPLATE 645# include <debug/safe_iterator.tcc> 646#endif 647 648#endif 649