Line data Source code
1 : // Iterators -*- C++ -*-
2 :
3 : // Copyright (C) 2001-2014 Free Software Foundation, Inc.
4 : //
5 : // This file is part of the GNU ISO C++ Library. This library is free
6 : // software; you can redistribute it and/or modify it under the
7 : // terms of the GNU General Public License as published by the
8 : // Free Software Foundation; either version 3, or (at your option)
9 : // any later version.
10 :
11 : // This library is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 :
16 : // Under Section 7 of GPL version 3, you are granted additional
17 : // permissions described in the GCC Runtime Library Exception, version
18 : // 3.1, as published by the Free Software Foundation.
19 :
20 : // You should have received a copy of the GNU General Public License and
21 : // a copy of the GCC Runtime Library Exception along with this program;
22 : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 : // <http://www.gnu.org/licenses/>.
24 :
25 : /*
26 : *
27 : * Copyright (c) 1994
28 : * Hewlett-Packard Company
29 : *
30 : * Permission to use, copy, modify, distribute and sell this software
31 : * and its documentation for any purpose is hereby granted without fee,
32 : * provided that the above copyright notice appear in all copies and
33 : * that both that copyright notice and this permission notice appear
34 : * in supporting documentation. Hewlett-Packard Company makes no
35 : * representations about the suitability of this software for any
36 : * purpose. It is provided "as is" without express or implied warranty.
37 : *
38 : *
39 : * Copyright (c) 1996-1998
40 : * Silicon Graphics Computer Systems, Inc.
41 : *
42 : * Permission to use, copy, modify, distribute and sell this software
43 : * and its documentation for any purpose is hereby granted without fee,
44 : * provided that the above copyright notice appear in all copies and
45 : * that both that copyright notice and this permission notice appear
46 : * in supporting documentation. Silicon Graphics makes no
47 : * representations about the suitability of this software for any
48 : * purpose. It is provided "as is" without express or implied warranty.
49 : */
50 :
51 : /** @file bits/stl_iterator.h
52 : * This is an internal header file, included by other library headers.
53 : * Do not attempt to use it directly. @headername{iterator}
54 : *
55 : * This file implements reverse_iterator, back_insert_iterator,
56 : * front_insert_iterator, insert_iterator, __normal_iterator, and their
57 : * supporting functions and overloaded operators.
58 : */
59 :
60 : #ifndef _STL_ITERATOR_H
61 : #define _STL_ITERATOR_H 1
62 :
63 : #include <bits/cpp_type_traits.h>
64 : #include <ext/type_traits.h>
65 : #include <bits/move.h>
66 : #include <bits/ptr_traits.h>
67 :
68 : namespace std _GLIBCXX_VISIBILITY(default)
69 : {
70 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
71 :
72 : /**
73 : * @addtogroup iterators
74 : * @{
75 : */
76 :
77 : // 24.4.1 Reverse iterators
78 : /**
79 : * Bidirectional and random access iterators have corresponding reverse
80 : * %iterator adaptors that iterate through the data structure in the
81 : * opposite direction. They have the same signatures as the corresponding
82 : * iterators. The fundamental relation between a reverse %iterator and its
83 : * corresponding %iterator @c i is established by the identity:
84 : * @code
85 : * &*(reverse_iterator(i)) == &*(i - 1)
86 : * @endcode
87 : *
88 : * <em>This mapping is dictated by the fact that while there is always a
89 : * pointer past the end of an array, there might not be a valid pointer
90 : * before the beginning of an array.</em> [24.4.1]/1,2
91 : *
92 : * Reverse iterators can be tricky and surprising at first. Their
93 : * semantics make sense, however, and the trickiness is a side effect of
94 : * the requirement that the iterators must be safe.
95 : */
96 : template<typename _Iterator>
97 : class reverse_iterator
98 : : public iterator<typename iterator_traits<_Iterator>::iterator_category,
99 : typename iterator_traits<_Iterator>::value_type,
100 : typename iterator_traits<_Iterator>::difference_type,
101 : typename iterator_traits<_Iterator>::pointer,
102 : typename iterator_traits<_Iterator>::reference>
103 : {
104 : protected:
105 : _Iterator current;
106 :
107 : typedef iterator_traits<_Iterator> __traits_type;
108 :
109 : public:
110 : typedef _Iterator iterator_type;
111 : typedef typename __traits_type::difference_type difference_type;
112 : typedef typename __traits_type::pointer pointer;
113 : typedef typename __traits_type::reference reference;
114 :
115 : /**
116 : * The default constructor value-initializes member @p current.
117 : * If it is a pointer, that means it is zero-initialized.
118 : */
119 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
120 : // 235 No specification of default ctor for reverse_iterator
121 : reverse_iterator() : current() { }
122 :
123 : /**
124 : * This %iterator will move in the opposite direction that @p x does.
125 : */
126 : explicit
127 : reverse_iterator(iterator_type __x) : current(__x) { }
128 :
129 : /**
130 : * The copy constructor is normal.
131 : */
132 : reverse_iterator(const reverse_iterator& __x)
133 : : current(__x.current) { }
134 :
135 : /**
136 : * A %reverse_iterator across other types can be copied if the
137 : * underlying %iterator can be converted to the type of @c current.
138 : */
139 : template<typename _Iter>
140 : reverse_iterator(const reverse_iterator<_Iter>& __x)
141 : : current(__x.base()) { }
142 :
143 : /**
144 : * @return @c current, the %iterator used for underlying work.
145 : */
146 : iterator_type
147 : base() const
148 : { return current; }
149 :
150 : /**
151 : * @return A reference to the value at @c --current
152 : *
153 : * This requires that @c --current is dereferenceable.
154 : *
155 : * @warning This implementation requires that for an iterator of the
156 : * underlying iterator type, @c x, a reference obtained by
157 : * @c *x remains valid after @c x has been modified or
158 : * destroyed. This is a bug: http://gcc.gnu.org/PR51823
159 : */
160 : reference
161 : operator*() const
162 : {
163 : _Iterator __tmp = current;
164 : return *--__tmp;
165 : }
166 :
167 : /**
168 : * @return A pointer to the value at @c --current
169 : *
170 : * This requires that @c --current is dereferenceable.
171 : */
172 : pointer
173 : operator->() const
174 : { return &(operator*()); }
175 :
176 : /**
177 : * @return @c *this
178 : *
179 : * Decrements the underlying iterator.
180 : */
181 : reverse_iterator&
182 : operator++()
183 : {
184 : --current;
185 : return *this;
186 : }
187 :
188 : /**
189 : * @return The original value of @c *this
190 : *
191 : * Decrements the underlying iterator.
192 : */
193 : reverse_iterator
194 : operator++(int)
195 : {
196 : reverse_iterator __tmp = *this;
197 : --current;
198 : return __tmp;
199 : }
200 :
201 : /**
202 : * @return @c *this
203 : *
204 : * Increments the underlying iterator.
205 : */
206 : reverse_iterator&
207 : operator--()
208 : {
209 : ++current;
210 : return *this;
211 : }
212 :
213 : /**
214 : * @return A reverse_iterator with the previous value of @c *this
215 : *
216 : * Increments the underlying iterator.
217 : */
218 : reverse_iterator
219 : operator--(int)
220 : {
221 : reverse_iterator __tmp = *this;
222 : ++current;
223 : return __tmp;
224 : }
225 :
226 : /**
227 : * @return A reverse_iterator that refers to @c current - @a __n
228 : *
229 : * The underlying iterator must be a Random Access Iterator.
230 : */
231 : reverse_iterator
232 : operator+(difference_type __n) const
233 : { return reverse_iterator(current - __n); }
234 :
235 : /**
236 : * @return *this
237 : *
238 : * Moves the underlying iterator backwards @a __n steps.
239 : * The underlying iterator must be a Random Access Iterator.
240 : */
241 : reverse_iterator&
242 : operator+=(difference_type __n)
243 : {
244 : current -= __n;
245 : return *this;
246 : }
247 :
248 : /**
249 : * @return A reverse_iterator that refers to @c current - @a __n
250 : *
251 : * The underlying iterator must be a Random Access Iterator.
252 : */
253 : reverse_iterator
254 : operator-(difference_type __n) const
255 : { return reverse_iterator(current + __n); }
256 :
257 : /**
258 : * @return *this
259 : *
260 : * Moves the underlying iterator forwards @a __n steps.
261 : * The underlying iterator must be a Random Access Iterator.
262 : */
263 : reverse_iterator&
264 : operator-=(difference_type __n)
265 : {
266 : current += __n;
267 : return *this;
268 : }
269 :
270 : /**
271 : * @return The value at @c current - @a __n - 1
272 : *
273 : * The underlying iterator must be a Random Access Iterator.
274 : */
275 : reference
276 : operator[](difference_type __n) const
277 : { return *(*this + __n); }
278 : };
279 :
280 : //@{
281 : /**
282 : * @param __x A %reverse_iterator.
283 : * @param __y A %reverse_iterator.
284 : * @return A simple bool.
285 : *
286 : * Reverse iterators forward many operations to their underlying base()
287 : * iterators. Others are implemented in terms of one another.
288 : *
289 : */
290 : template<typename _Iterator>
291 : inline bool
292 : operator==(const reverse_iterator<_Iterator>& __x,
293 : const reverse_iterator<_Iterator>& __y)
294 : { return __x.base() == __y.base(); }
295 :
296 : template<typename _Iterator>
297 : inline bool
298 : operator<(const reverse_iterator<_Iterator>& __x,
299 : const reverse_iterator<_Iterator>& __y)
300 : { return __y.base() < __x.base(); }
301 :
302 : template<typename _Iterator>
303 : inline bool
304 : operator!=(const reverse_iterator<_Iterator>& __x,
305 : const reverse_iterator<_Iterator>& __y)
306 : { return !(__x == __y); }
307 :
308 : template<typename _Iterator>
309 : inline bool
310 : operator>(const reverse_iterator<_Iterator>& __x,
311 : const reverse_iterator<_Iterator>& __y)
312 : { return __y < __x; }
313 :
314 : template<typename _Iterator>
315 : inline bool
316 : operator<=(const reverse_iterator<_Iterator>& __x,
317 : const reverse_iterator<_Iterator>& __y)
318 : { return !(__y < __x); }
319 :
320 : template<typename _Iterator>
321 : inline bool
322 : operator>=(const reverse_iterator<_Iterator>& __x,
323 : const reverse_iterator<_Iterator>& __y)
324 : { return !(__x < __y); }
325 :
326 : template<typename _Iterator>
327 : inline typename reverse_iterator<_Iterator>::difference_type
328 : operator-(const reverse_iterator<_Iterator>& __x,
329 : const reverse_iterator<_Iterator>& __y)
330 : { return __y.base() - __x.base(); }
331 :
332 : template<typename _Iterator>
333 : inline reverse_iterator<_Iterator>
334 : operator+(typename reverse_iterator<_Iterator>::difference_type __n,
335 : const reverse_iterator<_Iterator>& __x)
336 : { return reverse_iterator<_Iterator>(__x.base() - __n); }
337 :
338 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
339 : // DR 280. Comparison of reverse_iterator to const reverse_iterator.
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.base() == __y.base(); }
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.base() < __x.base(); }
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 !(__x == __y); }
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 __y < __x; }
363 :
364 : template<typename _IteratorL, typename _IteratorR>
365 : inline bool
366 : operator<=(const reverse_iterator<_IteratorL>& __x,
367 : const reverse_iterator<_IteratorR>& __y)
368 : { return !(__y < __x); }
369 :
370 : template<typename _IteratorL, typename _IteratorR>
371 : inline bool
372 : operator>=(const reverse_iterator<_IteratorL>& __x,
373 : const reverse_iterator<_IteratorR>& __y)
374 : { return !(__x < __y); }
375 :
376 : template<typename _IteratorL, typename _IteratorR>
377 : #if __cplusplus >= 201103L
378 : // DR 685.
379 : inline auto
380 : operator-(const reverse_iterator<_IteratorL>& __x,
381 : const reverse_iterator<_IteratorR>& __y)
382 : -> decltype(__y.base() - __x.base())
383 : #else
384 : inline typename reverse_iterator<_IteratorL>::difference_type
385 : operator-(const reverse_iterator<_IteratorL>& __x,
386 : const reverse_iterator<_IteratorR>& __y)
387 : #endif
388 : { return __y.base() - __x.base(); }
389 : //@}
390 :
391 : // 24.4.2.2.1 back_insert_iterator
392 : /**
393 : * @brief Turns assignment into insertion.
394 : *
395 : * These are output iterators, constructed from a container-of-T.
396 : * Assigning a T to the iterator appends it to the container using
397 : * push_back.
398 : *
399 : * Tip: Using the back_inserter function to create these iterators can
400 : * save typing.
401 : */
402 : template<typename _Container>
403 : class back_insert_iterator
404 : : public iterator<output_iterator_tag, void, void, void, void>
405 : {
406 : protected:
407 : _Container* container;
408 :
409 : public:
410 : /// A nested typedef for the type of whatever container you used.
411 : typedef _Container container_type;
412 :
413 : /// The only way to create this %iterator is with a container.
414 : explicit
415 0 : back_insert_iterator(_Container& __x) : container(&__x) { }
416 :
417 : /**
418 : * @param __value An instance of whatever type
419 : * container_type::const_reference is; presumably a
420 : * reference-to-const T for container<T>.
421 : * @return This %iterator, for chained operations.
422 : *
423 : * This kind of %iterator doesn't really have a @a position in the
424 : * container (you can think of the position as being permanently at
425 : * the end, if you like). Assigning a value to the %iterator will
426 : * always append the value to the end of the container.
427 : */
428 : #if __cplusplus < 201103L
429 : back_insert_iterator&
430 : operator=(typename _Container::const_reference __value)
431 : {
432 : container->push_back(__value);
433 : return *this;
434 : }
435 : #else
436 : back_insert_iterator&
437 0 : operator=(const typename _Container::value_type& __value)
438 : {
439 0 : container->push_back(__value);
440 0 : return *this;
441 : }
442 :
443 : back_insert_iterator&
444 0 : operator=(typename _Container::value_type&& __value)
445 : {
446 0 : container->push_back(std::move(__value));
447 0 : return *this;
448 : }
449 : #endif
450 :
451 : /// Simply returns *this.
452 : back_insert_iterator&
453 0 : operator*()
454 0 : { return *this; }
455 :
456 : /// Simply returns *this. (This %iterator does not @a move.)
457 : back_insert_iterator&
458 0 : operator++()
459 0 : { return *this; }
460 :
461 : /// Simply returns *this. (This %iterator does not @a move.)
462 : back_insert_iterator
463 : operator++(int)
464 : { return *this; }
465 : };
466 :
467 : /**
468 : * @param __x A container of arbitrary type.
469 : * @return An instance of back_insert_iterator working on @p __x.
470 : *
471 : * This wrapper function helps in creating back_insert_iterator instances.
472 : * Typing the name of the %iterator requires knowing the precise full
473 : * type of the container, which can be tedious and impedes generic
474 : * programming. Using this function lets you take advantage of automatic
475 : * template parameter deduction, making the compiler match the correct
476 : * types for you.
477 : */
478 : template<typename _Container>
479 : inline back_insert_iterator<_Container>
480 0 : back_inserter(_Container& __x)
481 0 : { return back_insert_iterator<_Container>(__x); }
482 :
483 : /**
484 : * @brief Turns assignment into insertion.
485 : *
486 : * These are output iterators, constructed from a container-of-T.
487 : * Assigning a T to the iterator prepends it to the container using
488 : * push_front.
489 : *
490 : * Tip: Using the front_inserter function to create these iterators can
491 : * save typing.
492 : */
493 : template<typename _Container>
494 : class front_insert_iterator
495 : : public iterator<output_iterator_tag, void, void, void, void>
496 : {
497 : protected:
498 : _Container* container;
499 :
500 : public:
501 : /// A nested typedef for the type of whatever container you used.
502 : typedef _Container container_type;
503 :
504 : /// The only way to create this %iterator is with a container.
505 : explicit front_insert_iterator(_Container& __x) : container(&__x) { }
506 :
507 : /**
508 : * @param __value An instance of whatever type
509 : * container_type::const_reference is; presumably a
510 : * reference-to-const T for container<T>.
511 : * @return This %iterator, for chained operations.
512 : *
513 : * This kind of %iterator doesn't really have a @a position in the
514 : * container (you can think of the position as being permanently at
515 : * the front, if you like). Assigning a value to the %iterator will
516 : * always prepend the value to the front of the container.
517 : */
518 : #if __cplusplus < 201103L
519 : front_insert_iterator&
520 : operator=(typename _Container::const_reference __value)
521 : {
522 : container->push_front(__value);
523 : return *this;
524 : }
525 : #else
526 : front_insert_iterator&
527 : operator=(const typename _Container::value_type& __value)
528 : {
529 : container->push_front(__value);
530 : return *this;
531 : }
532 :
533 : front_insert_iterator&
534 : operator=(typename _Container::value_type&& __value)
535 : {
536 : container->push_front(std::move(__value));
537 : return *this;
538 : }
539 : #endif
540 :
541 : /// Simply returns *this.
542 : front_insert_iterator&
543 : operator*()
544 : { return *this; }
545 :
546 : /// Simply returns *this. (This %iterator does not @a move.)
547 : front_insert_iterator&
548 : operator++()
549 : { return *this; }
550 :
551 : /// Simply returns *this. (This %iterator does not @a move.)
552 : front_insert_iterator
553 : operator++(int)
554 : { return *this; }
555 : };
556 :
557 : /**
558 : * @param __x A container of arbitrary type.
559 : * @return An instance of front_insert_iterator working on @p x.
560 : *
561 : * This wrapper function helps in creating front_insert_iterator instances.
562 : * Typing the name of the %iterator requires knowing the precise full
563 : * type of the container, which can be tedious and impedes generic
564 : * programming. Using this function lets you take advantage of automatic
565 : * template parameter deduction, making the compiler match the correct
566 : * types for you.
567 : */
568 : template<typename _Container>
569 : inline front_insert_iterator<_Container>
570 : front_inserter(_Container& __x)
571 : { return front_insert_iterator<_Container>(__x); }
572 :
573 : /**
574 : * @brief Turns assignment into insertion.
575 : *
576 : * These are output iterators, constructed from a container-of-T.
577 : * Assigning a T to the iterator inserts it in the container at the
578 : * %iterator's position, rather than overwriting the value at that
579 : * position.
580 : *
581 : * (Sequences will actually insert a @e copy of the value before the
582 : * %iterator's position.)
583 : *
584 : * Tip: Using the inserter function to create these iterators can
585 : * save typing.
586 : */
587 : template<typename _Container>
588 : class insert_iterator
589 : : public iterator<output_iterator_tag, void, void, void, void>
590 : {
591 : protected:
592 : _Container* container;
593 : typename _Container::iterator iter;
594 :
595 : public:
596 : /// A nested typedef for the type of whatever container you used.
597 : typedef _Container container_type;
598 :
599 : /**
600 : * The only way to create this %iterator is with a container and an
601 : * initial position (a normal %iterator into the container).
602 : */
603 : insert_iterator(_Container& __x, typename _Container::iterator __i)
604 : : container(&__x), iter(__i) {}
605 :
606 : /**
607 : * @param __value An instance of whatever type
608 : * container_type::const_reference is; presumably a
609 : * reference-to-const T for container<T>.
610 : * @return This %iterator, for chained operations.
611 : *
612 : * This kind of %iterator maintains its own position in the
613 : * container. Assigning a value to the %iterator will insert the
614 : * value into the container at the place before the %iterator.
615 : *
616 : * The position is maintained such that subsequent assignments will
617 : * insert values immediately after one another. For example,
618 : * @code
619 : * // vector v contains A and Z
620 : *
621 : * insert_iterator i (v, ++v.begin());
622 : * i = 1;
623 : * i = 2;
624 : * i = 3;
625 : *
626 : * // vector v contains A, 1, 2, 3, and Z
627 : * @endcode
628 : */
629 : #if __cplusplus < 201103L
630 : insert_iterator&
631 : operator=(typename _Container::const_reference __value)
632 : {
633 : iter = container->insert(iter, __value);
634 : ++iter;
635 : return *this;
636 : }
637 : #else
638 : insert_iterator&
639 : operator=(const typename _Container::value_type& __value)
640 : {
641 : iter = container->insert(iter, __value);
642 : ++iter;
643 : return *this;
644 : }
645 :
646 : insert_iterator&
647 : operator=(typename _Container::value_type&& __value)
648 : {
649 : iter = container->insert(iter, std::move(__value));
650 : ++iter;
651 : return *this;
652 : }
653 : #endif
654 :
655 : /// Simply returns *this.
656 : insert_iterator&
657 : operator*()
658 : { return *this; }
659 :
660 : /// Simply returns *this. (This %iterator does not @a move.)
661 : insert_iterator&
662 : operator++()
663 : { return *this; }
664 :
665 : /// Simply returns *this. (This %iterator does not @a move.)
666 : insert_iterator&
667 : operator++(int)
668 : { return *this; }
669 : };
670 :
671 : /**
672 : * @param __x A container of arbitrary type.
673 : * @return An instance of insert_iterator working on @p __x.
674 : *
675 : * This wrapper function helps in creating insert_iterator instances.
676 : * Typing the name of the %iterator requires knowing the precise full
677 : * type of the container, which can be tedious and impedes generic
678 : * programming. Using this function lets you take advantage of automatic
679 : * template parameter deduction, making the compiler match the correct
680 : * types for you.
681 : */
682 : template<typename _Container, typename _Iterator>
683 : inline insert_iterator<_Container>
684 : inserter(_Container& __x, _Iterator __i)
685 : {
686 : return insert_iterator<_Container>(__x,
687 : typename _Container::iterator(__i));
688 : }
689 :
690 : // @} group iterators
691 :
692 : _GLIBCXX_END_NAMESPACE_VERSION
693 : } // namespace
694 :
695 : namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
696 : {
697 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
698 :
699 : // This iterator adapter is @a normal in the sense that it does not
700 : // change the semantics of any of the operators of its iterator
701 : // parameter. Its primary purpose is to convert an iterator that is
702 : // not a class, e.g. a pointer, into an iterator that is a class.
703 : // The _Container parameter exists solely so that different containers
704 : // using this template can instantiate different types, even if the
705 : // _Iterator parameter is the same.
706 : using std::iterator_traits;
707 : using std::iterator;
708 : template<typename _Iterator, typename _Container>
709 : class __normal_iterator
710 : {
711 : protected:
712 : _Iterator _M_current;
713 :
714 : typedef iterator_traits<_Iterator> __traits_type;
715 :
716 : public:
717 : typedef _Iterator iterator_type;
718 : typedef typename __traits_type::iterator_category iterator_category;
719 : typedef typename __traits_type::value_type value_type;
720 : typedef typename __traits_type::difference_type difference_type;
721 : typedef typename __traits_type::reference reference;
722 : typedef typename __traits_type::pointer pointer;
723 :
724 0 : _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
725 0 : : _M_current(_Iterator()) { }
726 :
727 : explicit
728 308 : __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
729 308 : : _M_current(__i) { }
730 :
731 : // Allow iterator to const_iterator conversion
732 : template<typename _Iter>
733 0 : __normal_iterator(const __normal_iterator<_Iter,
734 : typename __enable_if<
735 : (std::__are_same<_Iter, typename _Container::pointer>::__value),
736 : _Container>::__type>& __i) _GLIBCXX_NOEXCEPT
737 0 : : _M_current(__i.base()) { }
738 :
739 : // Forward iterator requirements
740 : reference
741 144 : operator*() const _GLIBCXX_NOEXCEPT
742 144 : { return *_M_current; }
743 :
744 : pointer
745 22 : operator->() const _GLIBCXX_NOEXCEPT
746 22 : { return _M_current; }
747 :
748 : __normal_iterator&
749 111 : operator++() _GLIBCXX_NOEXCEPT
750 : {
751 111 : ++_M_current;
752 111 : return *this;
753 : }
754 :
755 : __normal_iterator
756 0 : operator++(int) _GLIBCXX_NOEXCEPT
757 0 : { return __normal_iterator(_M_current++); }
758 :
759 : // Bidirectional iterator requirements
760 : __normal_iterator&
761 0 : operator--() _GLIBCXX_NOEXCEPT
762 : {
763 0 : --_M_current;
764 0 : return *this;
765 : }
766 :
767 : __normal_iterator
768 : operator--(int) _GLIBCXX_NOEXCEPT
769 : { return __normal_iterator(_M_current--); }
770 :
771 : // Random access iterator requirements
772 : reference
773 : operator[](difference_type __n) const _GLIBCXX_NOEXCEPT
774 : { return _M_current[__n]; }
775 :
776 : __normal_iterator&
777 0 : operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
778 0 : { _M_current += __n; return *this; }
779 :
780 : __normal_iterator
781 0 : operator+(difference_type __n) const _GLIBCXX_NOEXCEPT
782 0 : { return __normal_iterator(_M_current + __n); }
783 :
784 : __normal_iterator&
785 : operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
786 : { _M_current -= __n; return *this; }
787 :
788 : __normal_iterator
789 0 : operator-(difference_type __n) const _GLIBCXX_NOEXCEPT
790 0 : { return __normal_iterator(_M_current - __n); }
791 :
792 : const _Iterator&
793 499 : base() const _GLIBCXX_NOEXCEPT
794 499 : { return _M_current; }
795 : };
796 :
797 : // Note: In what follows, the left- and right-hand-side iterators are
798 : // allowed to vary in types (conceptually in cv-qualification) so that
799 : // comparison between cv-qualified and non-cv-qualified iterators be
800 : // valid. However, the greedy and unfriendly operators in std::rel_ops
801 : // will make overload resolution ambiguous (when in scope) if we don't
802 : // provide overloads whose operands are of the same type. Can someone
803 : // remind me what generic programming is about? -- Gaby
804 :
805 : // Forward iterator requirements
806 : template<typename _IteratorL, typename _IteratorR, typename _Container>
807 : inline bool
808 : operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
809 : const __normal_iterator<_IteratorR, _Container>& __rhs)
810 : _GLIBCXX_NOEXCEPT
811 : { return __lhs.base() == __rhs.base(); }
812 :
813 : template<typename _Iterator, typename _Container>
814 : inline bool
815 6 : operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
816 : const __normal_iterator<_Iterator, _Container>& __rhs)
817 : _GLIBCXX_NOEXCEPT
818 6 : { return __lhs.base() == __rhs.base(); }
819 :
820 : template<typename _IteratorL, typename _IteratorR, typename _Container>
821 : inline bool
822 0 : operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
823 : const __normal_iterator<_IteratorR, _Container>& __rhs)
824 : _GLIBCXX_NOEXCEPT
825 0 : { return __lhs.base() != __rhs.base(); }
826 :
827 : template<typename _Iterator, typename _Container>
828 : inline bool
829 239 : operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
830 : const __normal_iterator<_Iterator, _Container>& __rhs)
831 : _GLIBCXX_NOEXCEPT
832 239 : { return __lhs.base() != __rhs.base(); }
833 :
834 : // Random access iterator requirements
835 : template<typename _IteratorL, typename _IteratorR, typename _Container>
836 : inline bool
837 : operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
838 : const __normal_iterator<_IteratorR, _Container>& __rhs)
839 : _GLIBCXX_NOEXCEPT
840 : { return __lhs.base() < __rhs.base(); }
841 :
842 : template<typename _Iterator, typename _Container>
843 : inline bool
844 0 : operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
845 : const __normal_iterator<_Iterator, _Container>& __rhs)
846 : _GLIBCXX_NOEXCEPT
847 0 : { return __lhs.base() < __rhs.base(); }
848 :
849 : template<typename _IteratorL, typename _IteratorR, typename _Container>
850 : inline bool
851 : operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
852 : const __normal_iterator<_IteratorR, _Container>& __rhs)
853 : _GLIBCXX_NOEXCEPT
854 : { return __lhs.base() > __rhs.base(); }
855 :
856 : template<typename _Iterator, typename _Container>
857 : inline bool
858 : operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
859 : const __normal_iterator<_Iterator, _Container>& __rhs)
860 : _GLIBCXX_NOEXCEPT
861 : { return __lhs.base() > __rhs.base(); }
862 :
863 : template<typename _IteratorL, typename _IteratorR, typename _Container>
864 : inline bool
865 : operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
866 : const __normal_iterator<_IteratorR, _Container>& __rhs)
867 : _GLIBCXX_NOEXCEPT
868 : { return __lhs.base() <= __rhs.base(); }
869 :
870 : template<typename _Iterator, typename _Container>
871 : inline bool
872 : operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
873 : const __normal_iterator<_Iterator, _Container>& __rhs)
874 : _GLIBCXX_NOEXCEPT
875 : { return __lhs.base() <= __rhs.base(); }
876 :
877 : template<typename _IteratorL, typename _IteratorR, typename _Container>
878 : inline bool
879 : operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
880 : const __normal_iterator<_IteratorR, _Container>& __rhs)
881 : _GLIBCXX_NOEXCEPT
882 : { return __lhs.base() >= __rhs.base(); }
883 :
884 : template<typename _Iterator, typename _Container>
885 : inline bool
886 : operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
887 : const __normal_iterator<_Iterator, _Container>& __rhs)
888 : _GLIBCXX_NOEXCEPT
889 : { return __lhs.base() >= __rhs.base(); }
890 :
891 : // _GLIBCXX_RESOLVE_LIB_DEFECTS
892 : // According to the resolution of DR179 not only the various comparison
893 : // operators but also operator- must accept mixed iterator/const_iterator
894 : // parameters.
895 : template<typename _IteratorL, typename _IteratorR, typename _Container>
896 : #if __cplusplus >= 201103L
897 : // DR 685.
898 : inline auto
899 : operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
900 : const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
901 : -> decltype(__lhs.base() - __rhs.base())
902 : #else
903 : inline typename __normal_iterator<_IteratorL, _Container>::difference_type
904 : operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
905 : const __normal_iterator<_IteratorR, _Container>& __rhs)
906 : #endif
907 : { return __lhs.base() - __rhs.base(); }
908 :
909 : template<typename _Iterator, typename _Container>
910 : inline typename __normal_iterator<_Iterator, _Container>::difference_type
911 0 : operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
912 : const __normal_iterator<_Iterator, _Container>& __rhs)
913 : _GLIBCXX_NOEXCEPT
914 0 : { return __lhs.base() - __rhs.base(); }
915 :
916 : template<typename _Iterator, typename _Container>
917 : inline __normal_iterator<_Iterator, _Container>
918 : operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
919 : __n, const __normal_iterator<_Iterator, _Container>& __i)
920 : _GLIBCXX_NOEXCEPT
921 : { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
922 :
923 : _GLIBCXX_END_NAMESPACE_VERSION
924 : } // namespace
925 :
926 : #if __cplusplus >= 201103L
927 :
928 : namespace std _GLIBCXX_VISIBILITY(default)
929 : {
930 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
931 :
932 : /**
933 : * @addtogroup iterators
934 : * @{
935 : */
936 :
937 : // 24.4.3 Move iterators
938 : /**
939 : * Class template move_iterator is an iterator adapter with the same
940 : * behavior as the underlying iterator except that its dereference
941 : * operator implicitly converts the value returned by the underlying
942 : * iterator's dereference operator to an rvalue reference. Some
943 : * generic algorithms can be called with move iterators to replace
944 : * copying with moving.
945 : */
946 : template<typename _Iterator>
947 : class move_iterator
948 : {
949 : protected:
950 : _Iterator _M_current;
951 :
952 : typedef iterator_traits<_Iterator> __traits_type;
953 :
954 : public:
955 : typedef _Iterator iterator_type;
956 : typedef typename __traits_type::iterator_category iterator_category;
957 : typedef typename __traits_type::value_type value_type;
958 : typedef typename __traits_type::difference_type difference_type;
959 : // NB: DR 680.
960 : typedef _Iterator pointer;
961 : typedef value_type&& reference;
962 :
963 : move_iterator()
964 : : _M_current() { }
965 :
966 : explicit
967 180 : move_iterator(iterator_type __i)
968 180 : : _M_current(__i) { }
969 :
970 : template<typename _Iter>
971 : move_iterator(const move_iterator<_Iter>& __i)
972 : : _M_current(__i.base()) { }
973 :
974 : iterator_type
975 202 : base() const
976 202 : { return _M_current; }
977 :
978 : reference
979 11 : operator*() const
980 11 : { return std::move(*_M_current); }
981 :
982 : pointer
983 : operator->() const
984 : { return _M_current; }
985 :
986 : move_iterator&
987 11 : operator++()
988 : {
989 11 : ++_M_current;
990 11 : return *this;
991 : }
992 :
993 : move_iterator
994 : operator++(int)
995 : {
996 : move_iterator __tmp = *this;
997 : ++_M_current;
998 : return __tmp;
999 : }
1000 :
1001 : move_iterator&
1002 : operator--()
1003 : {
1004 : --_M_current;
1005 : return *this;
1006 : }
1007 :
1008 : move_iterator
1009 : operator--(int)
1010 : {
1011 : move_iterator __tmp = *this;
1012 : --_M_current;
1013 : return __tmp;
1014 : }
1015 :
1016 : move_iterator
1017 : operator+(difference_type __n) const
1018 : { return move_iterator(_M_current + __n); }
1019 :
1020 : move_iterator&
1021 : operator+=(difference_type __n)
1022 : {
1023 : _M_current += __n;
1024 : return *this;
1025 : }
1026 :
1027 : move_iterator
1028 : operator-(difference_type __n) const
1029 : { return move_iterator(_M_current - __n); }
1030 :
1031 : move_iterator&
1032 : operator-=(difference_type __n)
1033 : {
1034 : _M_current -= __n;
1035 : return *this;
1036 : }
1037 :
1038 : reference
1039 : operator[](difference_type __n) const
1040 : { return std::move(_M_current[__n]); }
1041 : };
1042 :
1043 : // Note: See __normal_iterator operators note from Gaby to understand
1044 : // why there are always 2 versions for most of the move_iterator
1045 : // operators.
1046 : template<typename _IteratorL, typename _IteratorR>
1047 : inline bool
1048 : operator==(const move_iterator<_IteratorL>& __x,
1049 : const move_iterator<_IteratorR>& __y)
1050 : { return __x.base() == __y.base(); }
1051 :
1052 : template<typename _Iterator>
1053 : inline bool
1054 100 : operator==(const move_iterator<_Iterator>& __x,
1055 : const move_iterator<_Iterator>& __y)
1056 100 : { return __x.base() == __y.base(); }
1057 :
1058 : template<typename _IteratorL, typename _IteratorR>
1059 : inline bool
1060 : operator!=(const move_iterator<_IteratorL>& __x,
1061 : const move_iterator<_IteratorR>& __y)
1062 : { return !(__x == __y); }
1063 :
1064 : template<typename _Iterator>
1065 : inline bool
1066 100 : operator!=(const move_iterator<_Iterator>& __x,
1067 : const move_iterator<_Iterator>& __y)
1068 100 : { return !(__x == __y); }
1069 :
1070 : template<typename _IteratorL, typename _IteratorR>
1071 : inline bool
1072 : operator<(const move_iterator<_IteratorL>& __x,
1073 : const move_iterator<_IteratorR>& __y)
1074 : { return __x.base() < __y.base(); }
1075 :
1076 : template<typename _Iterator>
1077 : inline bool
1078 : operator<(const move_iterator<_Iterator>& __x,
1079 : const move_iterator<_Iterator>& __y)
1080 : { return __x.base() < __y.base(); }
1081 :
1082 : template<typename _IteratorL, typename _IteratorR>
1083 : inline bool
1084 : operator<=(const move_iterator<_IteratorL>& __x,
1085 : const move_iterator<_IteratorR>& __y)
1086 : { return !(__y < __x); }
1087 :
1088 : template<typename _Iterator>
1089 : inline bool
1090 : operator<=(const move_iterator<_Iterator>& __x,
1091 : const move_iterator<_Iterator>& __y)
1092 : { return !(__y < __x); }
1093 :
1094 : template<typename _IteratorL, typename _IteratorR>
1095 : inline bool
1096 : operator>(const move_iterator<_IteratorL>& __x,
1097 : const move_iterator<_IteratorR>& __y)
1098 : { return __y < __x; }
1099 :
1100 : template<typename _Iterator>
1101 : inline bool
1102 : operator>(const move_iterator<_Iterator>& __x,
1103 : const move_iterator<_Iterator>& __y)
1104 : { return __y < __x; }
1105 :
1106 : template<typename _IteratorL, typename _IteratorR>
1107 : inline bool
1108 : operator>=(const move_iterator<_IteratorL>& __x,
1109 : const move_iterator<_IteratorR>& __y)
1110 : { return !(__x < __y); }
1111 :
1112 : template<typename _Iterator>
1113 : inline bool
1114 : operator>=(const move_iterator<_Iterator>& __x,
1115 : const move_iterator<_Iterator>& __y)
1116 : { return !(__x < __y); }
1117 :
1118 : // DR 685.
1119 : template<typename _IteratorL, typename _IteratorR>
1120 : inline auto
1121 : operator-(const move_iterator<_IteratorL>& __x,
1122 : const move_iterator<_IteratorR>& __y)
1123 : -> decltype(__x.base() - __y.base())
1124 : { return __x.base() - __y.base(); }
1125 :
1126 : template<typename _Iterator>
1127 : inline auto
1128 : operator-(const move_iterator<_Iterator>& __x,
1129 : const move_iterator<_Iterator>& __y)
1130 : -> decltype(__x.base() - __y.base())
1131 : { return __x.base() - __y.base(); }
1132 :
1133 : template<typename _Iterator>
1134 : inline move_iterator<_Iterator>
1135 : operator+(typename move_iterator<_Iterator>::difference_type __n,
1136 : const move_iterator<_Iterator>& __x)
1137 : { return __x + __n; }
1138 :
1139 : template<typename _Iterator>
1140 : inline move_iterator<_Iterator>
1141 : make_move_iterator(_Iterator __i)
1142 : { return move_iterator<_Iterator>(__i); }
1143 :
1144 : template<typename _Iterator, typename _ReturnType
1145 : = typename conditional<__move_if_noexcept_cond
1146 : <typename iterator_traits<_Iterator>::value_type>::value,
1147 : _Iterator, move_iterator<_Iterator>>::type>
1148 : inline _ReturnType
1149 180 : __make_move_if_noexcept_iterator(_Iterator __i)
1150 180 : { return _ReturnType(__i); }
1151 :
1152 : // @} group iterators
1153 :
1154 : _GLIBCXX_END_NAMESPACE_VERSION
1155 : } // namespace
1156 :
1157 : #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
1158 : #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
1159 : std::__make_move_if_noexcept_iterator(_Iter)
1160 : #else
1161 : #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
1162 : #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
1163 : #endif // C++11
1164 :
1165 : #endif
|
