1 : // Iterators -*- C++ -*-
2 :
3 : // Copyright (C) 2001, 2002, 2003, 2004, 2005 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 2, 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 : // You should have received a copy of the GNU General Public License along
17 : // with this library; see the file COPYING. If not, write to the Free
18 : // Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
19 : // USA.
20 :
21 : // As a special exception, you may use this file as part of a free software
22 : // library without restriction. Specifically, if other files instantiate
23 : // templates or use macros or inline functions from this file, or you compile
24 : // this file and link it with other files to produce an executable, this
25 : // file does not by itself cause the resulting executable to be covered by
26 : // the GNU General Public License. This exception does not however
27 : // invalidate any other reasons why the executable file might be covered by
28 : // the GNU General Public License.
29 :
30 : /*
31 : *
32 : * Copyright (c) 1994
33 : * Hewlett-Packard Company
34 : *
35 : * Permission to use, copy, modify, distribute and sell this software
36 : * and its documentation for any purpose is hereby granted without fee,
37 : * provided that the above copyright notice appear in all copies and
38 : * that both that copyright notice and this permission notice appear
39 : * in supporting documentation. Hewlett-Packard Company makes no
40 : * representations about the suitability of this software for any
41 : * purpose. It is provided "as is" without express or implied warranty.
42 : *
43 : *
44 : * Copyright (c) 1996-1998
45 : * Silicon Graphics Computer Systems, Inc.
46 : *
47 : * Permission to use, copy, modify, distribute and sell this software
48 : * and its documentation for any purpose is hereby granted without fee,
49 : * provided that the above copyright notice appear in all copies and
50 : * that both that copyright notice and this permission notice appear
51 : * in supporting documentation. Silicon Graphics makes no
52 : * representations about the suitability of this software for any
53 : * purpose. It is provided "as is" without express or implied warranty.
54 : */
55 :
56 : /** @file stl_iterator.h
57 : * This is an internal header file, included by other library headers.
58 : * You should not attempt to use it directly.
59 : *
60 : * This file implements reverse_iterator, back_insert_iterator,
61 : * front_insert_iterator, insert_iterator, __normal_iterator, and their
62 : * supporting functions and overloaded operators.
63 : */
64 :
65 : #ifndef _ITERATOR_H
66 : #define _ITERATOR_H 1
67 :
68 : #include <bits/cpp_type_traits.h>
69 :
70 : namespace std
71 : {
72 : // 24.4.1 Reverse iterators
73 : /**
74 : * "Bidirectional and random access iterators have corresponding reverse
75 : * %iterator adaptors that iterate through the data structure in the
76 : * opposite direction. They have the same signatures as the corresponding
77 : * iterators. The fundamental relation between a reverse %iterator and its
78 : * corresponding %iterator @c i is established by the identity:
79 : * @code
80 : * &*(reverse_iterator(i)) == &*(i - 1)
81 : * @endcode
82 : *
83 : * This mapping is dictated by the fact that while there is always a
84 : * pointer past the end of an array, there might not be a valid pointer
85 : * before the beginning of an array." [24.4.1]/1,2
86 : *
87 : * Reverse iterators can be tricky and surprising at first. Their
88 : * semantics make sense, however, and the trickiness is a side effect of
89 : * the requirement that the iterators must be safe.
90 : */
91 : template<typename _Iterator>
92 : class reverse_iterator
93 : : public iterator<typename iterator_traits<_Iterator>::iterator_category,
94 : typename iterator_traits<_Iterator>::value_type,
95 : typename iterator_traits<_Iterator>::difference_type,
96 : typename iterator_traits<_Iterator>::pointer,
97 : typename iterator_traits<_Iterator>::reference>
98 : {
99 : protected:
100 : _Iterator current;
101 :
102 : public:
103 : typedef _Iterator iterator_type;
104 : typedef typename iterator_traits<_Iterator>::difference_type
105 : difference_type;
106 : typedef typename iterator_traits<_Iterator>::reference reference;
107 : typedef typename iterator_traits<_Iterator>::pointer pointer;
108 :
109 : public:
110 : /**
111 : * The default constructor default-initializes member @p current.
112 : * If it is a pointer, that means it is zero-initialized.
113 : */
114 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
115 : // 235 No specification of default ctor for reverse_iterator
116 : reverse_iterator() : current() { }
117 :
118 : /**
119 : * This %iterator will move in the opposite direction that @p x does.
120 : */
121 : explicit
122 937 : reverse_iterator(iterator_type __x) : current(__x) { }
123 :
124 : /**
125 : * The copy constructor is normal.
126 : */
127 375 : reverse_iterator(const reverse_iterator& __x)
128 375 : : current(__x.current) { }
129 :
130 : /**
131 : * A reverse_iterator across other types can be copied in the normal
132 : * fashion.
133 : */
134 : template<typename _Iter>
135 : reverse_iterator(const reverse_iterator<_Iter>& __x)
136 : : current(__x.base()) { }
137 :
138 : /**
139 : * @return @c current, the %iterator used for underlying work.
140 : */
141 : iterator_type
142 1312 : base() const
143 1312 : { return current; }
144 :
145 : /**
146 : * @return TODO
147 : *
148 : * @doctodo
149 : */
150 : reference
151 375 : operator*() const
152 : {
153 375 : _Iterator __tmp = current;
154 375 : return *--__tmp;
155 : }
156 :
157 : /**
158 : * @return TODO
159 : *
160 : * @doctodo
161 : */
162 : pointer
163 : operator->() const
164 : { return &(operator*()); }
165 :
166 : /**
167 : * @return TODO
168 : *
169 : * @doctodo
170 : */
171 : reverse_iterator&
172 : operator++()
173 : {
174 : --current;
175 : return *this;
176 : }
177 :
178 : /**
179 : * @return TODO
180 : *
181 : * @doctodo
182 : */
183 : reverse_iterator
184 375 : operator++(int)
185 : {
186 375 : reverse_iterator __tmp = *this;
187 375 : --current;
188 : return __tmp;
189 : }
190 :
191 : /**
192 : * @return TODO
193 : *
194 : * @doctodo
195 : */
196 : reverse_iterator&
197 : operator--()
198 : {
199 : ++current;
200 : return *this;
201 : }
202 :
203 : /**
204 : * @return TODO
205 : *
206 : * @doctodo
207 : */
208 : reverse_iterator
209 : operator--(int)
210 : {
211 : reverse_iterator __tmp = *this;
212 : ++current;
213 : return __tmp;
214 : }
215 :
216 : /**
217 : * @return TODO
218 : *
219 : * @doctodo
220 : */
221 : reverse_iterator
222 : operator+(difference_type __n) const
223 : { return reverse_iterator(current - __n); }
224 :
225 : /**
226 : * @return TODO
227 : *
228 : * @doctodo
229 : */
230 : reverse_iterator&
231 : operator+=(difference_type __n)
232 : {
233 : current -= __n;
234 : return *this;
235 : }
236 :
237 : /**
238 : * @return TODO
239 : *
240 : * @doctodo
241 : */
242 : reverse_iterator
243 : operator-(difference_type __n) const
244 : { return reverse_iterator(current + __n); }
245 :
246 : /**
247 : * @return TODO
248 : *
249 : * @doctodo
250 : */
251 : reverse_iterator&
252 : operator-=(difference_type __n)
253 : {
254 : current += __n;
255 : return *this;
256 : }
257 :
258 : /**
259 : * @return TODO
260 : *
261 : * @doctodo
262 : */
263 : reference
264 : operator[](difference_type __n) const
265 : { return *(*this + __n); }
266 : };
267 :
268 : //@{
269 : /**
270 : * @param x A %reverse_iterator.
271 : * @param y A %reverse_iterator.
272 : * @return A simple bool.
273 : *
274 : * Reverse iterators forward many operations to their underlying base()
275 : * iterators. Others are implemented in terms of one another.
276 : *
277 : */
278 : template<typename _Iterator>
279 : inline bool
280 : operator==(const reverse_iterator<_Iterator>& __x,
281 656 : const reverse_iterator<_Iterator>& __y)
282 656 : { return __x.base() == __y.base(); }
283 :
284 : template<typename _Iterator>
285 : inline bool
286 : operator<(const reverse_iterator<_Iterator>& __x,
287 : const reverse_iterator<_Iterator>& __y)
288 : { return __y.base() < __x.base(); }
289 :
290 : template<typename _Iterator>
291 : inline bool
292 : operator!=(const reverse_iterator<_Iterator>& __x,
293 656 : const reverse_iterator<_Iterator>& __y)
294 656 : { return !(__x == __y); }
295 :
296 : template<typename _Iterator>
297 : inline bool
298 : operator>(const reverse_iterator<_Iterator>& __x,
299 : const reverse_iterator<_Iterator>& __y)
300 : { return __y < __x; }
301 :
302 : template<typename _Iterator>
303 : inline bool
304 : operator<=(const reverse_iterator<_Iterator>& __x,
305 : const reverse_iterator<_Iterator>& __y)
306 : { return !(__y < __x); }
307 :
308 : template<typename _Iterator>
309 : inline bool
310 : operator>=(const reverse_iterator<_Iterator>& __x,
311 : const reverse_iterator<_Iterator>& __y)
312 : { return !(__x < __y); }
313 :
314 : template<typename _Iterator>
315 : inline typename reverse_iterator<_Iterator>::difference_type
316 : operator-(const reverse_iterator<_Iterator>& __x,
317 : const reverse_iterator<_Iterator>& __y)
318 : { return __y.base() - __x.base(); }
319 :
320 : template<typename _Iterator>
321 : inline reverse_iterator<_Iterator>
322 : operator+(typename reverse_iterator<_Iterator>::difference_type __n,
323 : const reverse_iterator<_Iterator>& __x)
324 : { return reverse_iterator<_Iterator>(__x.base() - __n); }
325 :
326 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
327 : // DR 280. Comparison of reverse_iterator to const reverse_iterator.
328 : template<typename _IteratorL, typename _IteratorR>
329 : inline bool
330 : operator==(const reverse_iterator<_IteratorL>& __x,
331 : const reverse_iterator<_IteratorR>& __y)
332 : { return __x.base() == __y.base(); }
333 :
334 : template<typename _IteratorL, typename _IteratorR>
335 : inline bool
336 : operator<(const reverse_iterator<_IteratorL>& __x,
337 : const reverse_iterator<_IteratorR>& __y)
338 : { return __y.base() < __x.base(); }
339 :
340 : template<typename _IteratorL, typename _IteratorR>
341 : inline bool
342 : operator!=(const reverse_iterator<_IteratorL>& __x,
343 : const reverse_iterator<_IteratorR>& __y)
344 : { return !(__x == __y); }
345 :
346 : template<typename _IteratorL, typename _IteratorR>
347 : inline bool
348 : operator>(const reverse_iterator<_IteratorL>& __x,
349 : const reverse_iterator<_IteratorR>& __y)
350 : { return __y < __x; }
351 :
352 : template<typename _IteratorL, typename _IteratorR>
353 : inline bool
354 : operator<=(const reverse_iterator<_IteratorL>& __x,
355 : const reverse_iterator<_IteratorR>& __y)
356 : { return !(__y < __x); }
357 :
358 : template<typename _IteratorL, typename _IteratorR>
359 : inline bool
360 : operator>=(const reverse_iterator<_IteratorL>& __x,
361 : const reverse_iterator<_IteratorR>& __y)
362 : { return !(__x < __y); }
363 :
364 : template<typename _IteratorL, typename _IteratorR>
365 : inline typename reverse_iterator<_IteratorL>::difference_type
366 : operator-(const reverse_iterator<_IteratorL>& __x,
367 : const reverse_iterator<_IteratorR>& __y)
368 : { return __y.base() - __x.base(); }
369 : //@}
370 :
371 : // 24.4.2.2.1 back_insert_iterator
372 : /**
373 : * @brief Turns assignment into insertion.
374 : *
375 : * These are output iterators, constructed from a container-of-T.
376 : * Assigning a T to the iterator appends it to the container using
377 : * push_back.
378 : *
379 : * Tip: Using the back_inserter function to create these iterators can
380 : * save typing.
381 : */
382 : template<typename _Container>
383 : class back_insert_iterator
384 : : public iterator<output_iterator_tag, void, void, void, void>
385 : {
386 : protected:
387 : _Container* container;
388 :
389 : public:
390 : /// A nested typedef for the type of whatever container you used.
391 : typedef _Container container_type;
392 :
393 : /// The only way to create this %iterator is with a container.
394 : explicit
395 : back_insert_iterator(_Container& __x) : container(&__x) { }
396 :
397 : /**
398 : * @param value An instance of whatever type
399 : * container_type::const_reference is; presumably a
400 : * reference-to-const T for container<T>.
401 : * @return This %iterator, for chained operations.
402 : *
403 : * This kind of %iterator doesn't really have a "position" in the
404 : * container (you can think of the position as being permanently at
405 : * the end, if you like). Assigning a value to the %iterator will
406 : * always append the value to the end of the container.
407 : */
408 : back_insert_iterator&
409 : operator=(typename _Container::const_reference __value)
410 : {
411 : container->push_back(__value);
412 : return *this;
413 : }
414 :
415 : /// Simply returns *this.
416 : back_insert_iterator&
417 : operator*()
418 : { return *this; }
419 :
420 : /// Simply returns *this. (This %iterator does not "move".)
421 : back_insert_iterator&
422 : operator++()
423 : { return *this; }
424 :
425 : /// Simply returns *this. (This %iterator does not "move".)
426 : back_insert_iterator
427 : operator++(int)
428 : { return *this; }
429 : };
430 :
431 : /**
432 : * @param x A container of arbitrary type.
433 : * @return An instance of back_insert_iterator working on @p x.
434 : *
435 : * This wrapper function helps in creating back_insert_iterator instances.
436 : * Typing the name of the %iterator requires knowing the precise full
437 : * type of the container, which can be tedious and impedes generic
438 : * programming. Using this function lets you take advantage of automatic
439 : * template parameter deduction, making the compiler match the correct
440 : * types for you.
441 : */
442 : template<typename _Container>
443 : inline back_insert_iterator<_Container>
444 : back_inserter(_Container& __x)
445 : { return back_insert_iterator<_Container>(__x); }
446 :
447 : /**
448 : * @brief Turns assignment into insertion.
449 : *
450 : * These are output iterators, constructed from a container-of-T.
451 : * Assigning a T to the iterator prepends it to the container using
452 : * push_front.
453 : *
454 : * Tip: Using the front_inserter function to create these iterators can
455 : * save typing.
456 : */
457 : template<typename _Container>
458 : class front_insert_iterator
459 : : public iterator<output_iterator_tag, void, void, void, void>
460 : {
461 : protected:
462 : _Container* container;
463 :
464 : public:
465 : /// A nested typedef for the type of whatever container you used.
466 : typedef _Container container_type;
467 :
468 : /// The only way to create this %iterator is with a container.
469 : explicit front_insert_iterator(_Container& __x) : container(&__x) { }
470 :
471 : /**
472 : * @param value An instance of whatever type
473 : * container_type::const_reference is; presumably a
474 : * reference-to-const T for container<T>.
475 : * @return This %iterator, for chained operations.
476 : *
477 : * This kind of %iterator doesn't really have a "position" in the
478 : * container (you can think of the position as being permanently at
479 : * the front, if you like). Assigning a value to the %iterator will
480 : * always prepend the value to the front of the container.
481 : */
482 : front_insert_iterator&
483 : operator=(typename _Container::const_reference __value)
484 : {
485 : container->push_front(__value);
486 : return *this;
487 : }
488 :
489 : /// Simply returns *this.
490 : front_insert_iterator&
491 : operator*()
492 : { return *this; }
493 :
494 : /// Simply returns *this. (This %iterator does not "move".)
495 : front_insert_iterator&
496 : operator++()
497 : { return *this; }
498 :
499 : /// Simply returns *this. (This %iterator does not "move".)
500 : front_insert_iterator
501 : operator++(int)
502 : { return *this; }
503 : };
504 :
505 : /**
506 : * @param x A container of arbitrary type.
507 : * @return An instance of front_insert_iterator working on @p x.
508 : *
509 : * This wrapper function helps in creating front_insert_iterator instances.
510 : * Typing the name of the %iterator requires knowing the precise full
511 : * type of the container, which can be tedious and impedes generic
512 : * programming. Using this function lets you take advantage of automatic
513 : * template parameter deduction, making the compiler match the correct
514 : * types for you.
515 : */
516 : template<typename _Container>
517 : inline front_insert_iterator<_Container>
518 : front_inserter(_Container& __x)
519 : { return front_insert_iterator<_Container>(__x); }
520 :
521 : /**
522 : * @brief Turns assignment into insertion.
523 : *
524 : * These are output iterators, constructed from a container-of-T.
525 : * Assigning a T to the iterator inserts it in the container at the
526 : * %iterator's position, rather than overwriting the value at that
527 : * position.
528 : *
529 : * (Sequences will actually insert a @e copy of the value before the
530 : * %iterator's position.)
531 : *
532 : * Tip: Using the inserter function to create these iterators can
533 : * save typing.
534 : */
535 : template<typename _Container>
536 : class insert_iterator
537 : : public iterator<output_iterator_tag, void, void, void, void>
538 : {
539 : protected:
540 : _Container* container;
541 : typename _Container::iterator iter;
542 :
543 : public:
544 : /// A nested typedef for the type of whatever container you used.
545 : typedef _Container container_type;
546 :
547 : /**
548 : * The only way to create this %iterator is with a container and an
549 : * initial position (a normal %iterator into the container).
550 : */
551 891457 : insert_iterator(_Container& __x, typename _Container::iterator __i)
552 891457 : : container(&__x), iter(__i) {}
553 :
554 : /**
555 : * @param value An instance of whatever type
556 : * container_type::const_reference is; presumably a
557 : * reference-to-const T for container<T>.
558 : * @return This %iterator, for chained operations.
559 : *
560 : * This kind of %iterator maintains its own position in the
561 : * container. Assigning a value to the %iterator will insert the
562 : * value into the container at the place before the %iterator.
563 : *
564 : * The position is maintained such that subsequent assignments will
565 : * insert values immediately after one another. For example,
566 : * @code
567 : * // vector v contains A and Z
568 : *
569 : * insert_iterator i (v, ++v.begin());
570 : * i = 1;
571 : * i = 2;
572 : * i = 3;
573 : *
574 : * // vector v contains A, 1, 2, 3, and Z
575 : * @endcode
576 : */
577 : insert_iterator&
578 536881 : operator=(const typename _Container::const_reference __value)
579 : {
580 536881 : iter = container->insert(iter, __value);
581 536881 : ++iter;
582 536881 : return *this;
583 : }
584 :
585 : /// Simply returns *this.
586 : insert_iterator&
587 536881 : operator*()
588 536881 : { return *this; }
589 :
590 : /// Simply returns *this. (This %iterator does not "move".)
591 : insert_iterator&
592 536881 : operator++()
593 536881 : { return *this; }
594 :
595 : /// Simply returns *this. (This %iterator does not "move".)
596 : insert_iterator&
597 : operator++(int)
598 : { return *this; }
599 : };
600 :
601 : /**
602 : * @param x A container of arbitrary type.
603 : * @return An instance of insert_iterator working on @p x.
604 : *
605 : * This wrapper function helps in creating insert_iterator instances.
606 : * Typing the name of the %iterator requires knowing the precise full
607 : * type of the container, which can be tedious and impedes generic
608 : * programming. Using this function lets you take advantage of automatic
609 : * template parameter deduction, making the compiler match the correct
610 : * types for you.
611 : */
612 : template<typename _Container, typename _Iterator>
613 : inline insert_iterator<_Container>
614 : inserter(_Container& __x, _Iterator __i)
615 : {
616 : return insert_iterator<_Container>(__x,
617 : typename _Container::iterator(__i));
618 : }
619 : } // namespace std
620 :
621 : namespace __gnu_cxx
622 : {
623 : // This iterator adapter is 'normal' in the sense that it does not
624 : // change the semantics of any of the operators of its iterator
625 : // parameter. Its primary purpose is to convert an iterator that is
626 : // not a class, e.g. a pointer, into an iterator that is a class.
627 : // The _Container parameter exists solely so that different containers
628 : // using this template can instantiate different types, even if the
629 : // _Iterator parameter is the same.
630 : using std::iterator_traits;
631 : using std::iterator;
632 : template<typename _Iterator, typename _Container>
633 : class __normal_iterator
634 : {
635 : protected:
636 : _Iterator _M_current;
637 :
638 : public:
639 : typedef typename iterator_traits<_Iterator>::iterator_category
640 : iterator_category;
641 : typedef typename iterator_traits<_Iterator>::value_type value_type;
642 : typedef typename iterator_traits<_Iterator>::difference_type
643 : difference_type;
644 : typedef typename iterator_traits<_Iterator>::reference reference;
645 : typedef typename iterator_traits<_Iterator>::pointer pointer;
646 :
647 : __normal_iterator() : _M_current(_Iterator()) { }
648 :
649 : explicit
650 18738410686 : __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
651 :
652 : // Allow iterator to const_iterator conversion
653 : template<typename _Iter>
654 : __normal_iterator(const __normal_iterator<_Iter,
655 : typename std::__enable_if<_Container,
656 : (std::__are_same<_Iter,
657 : typename _Container::pointer>::__value)
658 109188 : >::__type>& __i)
659 109188 : : _M_current(__i.base()) { }
660 :
661 : // Forward iterator requirements
662 : reference
663 3083238685 : operator*() const
664 3083238685 : { return *_M_current; }
665 :
666 : pointer
667 183860 : operator->() const
668 183860 : { return _M_current; }
669 :
670 : __normal_iterator&
671 85233407 : operator++()
672 : {
673 85233407 : ++_M_current;
674 85233407 : return *this;
675 : }
676 :
677 : __normal_iterator
678 755738 : operator++(int)
679 755738 : { return __normal_iterator(_M_current++); }
680 :
681 : // Bidirectional iterator requirements
682 : __normal_iterator&
683 3230 : operator--()
684 : {
685 3230 : --_M_current;
686 3230 : return *this;
687 : }
688 :
689 : __normal_iterator
690 0 : operator--(int)
691 0 : { return __normal_iterator(_M_current--); }
692 :
693 : // Random access iterator requirements
694 : reference
695 : operator[](const difference_type& __n) const
696 : { return _M_current[__n]; }
697 :
698 : __normal_iterator&
699 54509 : operator+=(const difference_type& __n)
700 54509 : { _M_current += __n; return *this; }
701 :
702 : __normal_iterator
703 3603041380 : operator+(const difference_type& __n) const
704 3603041380 : { return __normal_iterator(_M_current + __n); }
705 :
706 : __normal_iterator&
707 : operator-=(const difference_type& __n)
708 : { _M_current -= __n; return *this; }
709 :
710 : __normal_iterator
711 63 : operator-(const difference_type& __n) const
712 63 : { return __normal_iterator(_M_current - __n); }
713 :
714 : const _Iterator&
715 12310873039 : base() const
716 12310873039 : { return _M_current; }
717 : };
718 :
719 : // Note: In what follows, the left- and right-hand-side iterators are
720 : // allowed to vary in types (conceptually in cv-qualification) so that
721 : // comparaison between cv-qualified and non-cv-qualified iterators be
722 : // valid. However, the greedy and unfriendly operators in std::rel_ops
723 : // will make overload resolution ambiguous (when in scope) if we don't
724 : // provide overloads whose operands are of the same type. Can someone
725 : // remind me what generic programming is about? -- Gaby
726 :
727 : // Forward iterator requirements
728 : template<typename _IteratorL, typename _IteratorR, typename _Container>
729 : inline bool
730 : operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
731 : const __normal_iterator<_IteratorR, _Container>& __rhs)
732 : { return __lhs.base() == __rhs.base(); }
733 :
734 : template<typename _Iterator, typename _Container>
735 : inline bool
736 : operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
737 13581783 : const __normal_iterator<_Iterator, _Container>& __rhs)
738 13581783 : { return __lhs.base() == __rhs.base(); }
739 :
740 : template<typename _IteratorL, typename _IteratorR, typename _Container>
741 : inline bool
742 : operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
743 : const __normal_iterator<_IteratorR, _Container>& __rhs)
744 : { return __lhs.base() != __rhs.base(); }
745 :
746 : template<typename _Iterator, typename _Container>
747 : inline bool
748 : operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
749 587922559 : const __normal_iterator<_Iterator, _Container>& __rhs)
750 587922559 : { return __lhs.base() != __rhs.base(); }
751 :
752 : // Random access iterator requirements
753 : template<typename _IteratorL, typename _IteratorR, typename _Container>
754 : inline bool
755 : operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
756 : const __normal_iterator<_IteratorR, _Container>& __rhs)
757 : { return __lhs.base() < __rhs.base(); }
758 :
759 : template<typename _Iterator, typename _Container>
760 : inline bool
761 : operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
762 1727 : const __normal_iterator<_Iterator, _Container>& __rhs)
763 1727 : { return __lhs.base() < __rhs.base(); }
764 :
765 : template<typename _IteratorL, typename _IteratorR, typename _Container>
766 : inline bool
767 : operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
768 : const __normal_iterator<_IteratorR, _Container>& __rhs)
769 : { return __lhs.base() > __rhs.base(); }
770 :
771 : template<typename _Iterator, typename _Container>
772 : inline bool
773 : operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
774 : const __normal_iterator<_Iterator, _Container>& __rhs)
775 : { return __lhs.base() > __rhs.base(); }
776 :
777 : template<typename _IteratorL, typename _IteratorR, typename _Container>
778 : inline bool
779 : operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
780 : const __normal_iterator<_IteratorR, _Container>& __rhs)
781 : { return __lhs.base() <= __rhs.base(); }
782 :
783 : template<typename _Iterator, typename _Container>
784 : inline bool
785 : operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
786 : const __normal_iterator<_Iterator, _Container>& __rhs)
787 : { return __lhs.base() <= __rhs.base(); }
788 :
789 : template<typename _IteratorL, typename _IteratorR, typename _Container>
790 : inline bool
791 : operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
792 : const __normal_iterator<_IteratorR, _Container>& __rhs)
793 : { return __lhs.base() >= __rhs.base(); }
794 :
795 : template<typename _Iterator, typename _Container>
796 : inline bool
797 : operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
798 : const __normal_iterator<_Iterator, _Container>& __rhs)
799 : { return __lhs.base() >= __rhs.base(); }
800 :
801 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
802 : // According to the resolution of DR179 not only the various comparison
803 : // operators but also operator- must accept mixed iterator/const_iterator
804 : // parameters.
805 : template<typename _IteratorL, typename _IteratorR, typename _Container>
806 : inline typename __normal_iterator<_IteratorL, _Container>::difference_type
807 : operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
808 5304922703 : const __normal_iterator<_IteratorR, _Container>& __rhs)
809 5304922703 : { return __lhs.base() - __rhs.base(); }
810 :
811 : template<typename _Iterator, typename _Container>
812 : inline __normal_iterator<_Iterator, _Container>
813 : operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
814 : __n, const __normal_iterator<_Iterator, _Container>& __i)
815 : { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
816 : } // namespace __gnu_cxx
817 :
818 : #endif
819 :
820 : // Local Variables:
821 : // mode:C++
822 : // End:
|
