libstdc++
stl_iterator.h
Go to the documentation of this file.
1 // Iterators -*- C++ -*-
2 
3 // Copyright (C) 2001-2013 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>
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  */
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>
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  */
183  {
184  --current;
185  return *this;
186  }
187 
188  /**
189  * @return The original value of @c *this
190  *
191  * Decrements the underlying iterator.
192  */
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  */
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  */
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  */
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  */
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  */
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  */
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>
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  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
430  operator=(typename _Container::const_reference __value)
431  {
432  container->push_back(__value);
433  return *this;
434  }
435 #else
437  operator=(const typename _Container::value_type& __value)
438  {
439  container->push_back(__value);
440  return *this;
441  }
442 
444  operator=(typename _Container::value_type&& __value)
445  {
446  container->push_back(std::move(__value));
447  return *this;
448  }
449 #endif
450 
451  /// Simply returns *this.
454  { return *this; }
455 
456  /// Simply returns *this. (This %iterator does not @a move.)
459  { return *this; }
460 
461  /// Simply returns *this. (This %iterator does not @a move.)
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  back_inserter(_Container& __x)
481  { 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>
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
520  operator=(typename _Container::const_reference __value)
521  {
522  container->push_front(__value);
523  return *this;
524  }
525 #else
527  operator=(const typename _Container::value_type& __value)
528  {
529  container->push_front(__value);
530  return *this;
531  }
532 
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.
544  { return *this; }
545 
546  /// Simply returns *this. (This %iterator does not @a move.)
549  { return *this; }
550 
551  /// Simply returns *this. (This %iterator does not @a move.)
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>
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
631  operator=(typename _Container::const_reference __value)
632  {
633  iter = container->insert(iter, __value);
634  ++iter;
635  return *this;
636  }
637 #else
639  operator=(const typename _Container::value_type& __value)
640  {
641  iter = container->insert(iter, __value);
642  ++iter;
643  return *this;
644  }
645 
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.
658  { return *this; }
659 
660  /// Simply returns *this. (This %iterator does not @a move.)
663  { return *this; }
664 
665  /// Simply returns *this. (This %iterator does not @a move.)
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  _GLIBCXX_CONSTEXPR __normal_iterator() : _M_current(_Iterator()) { }
725 
726  explicit
727  __normal_iterator(const _Iterator& __i) : _M_current(__i) { }
728 
729  // Allow iterator to const_iterator conversion
730  template<typename _Iter>
731  __normal_iterator(const __normal_iterator<_Iter,
732  typename __enable_if<
733  (std::__are_same<_Iter, typename _Container::pointer>::__value),
734  _Container>::__type>& __i)
735  : _M_current(__i.base()) { }
736 
737 #if __cplusplus >= 201103L
738  __normal_iterator<typename _Container::pointer, _Container>
739  _M_const_cast() const
740  {
742  return __normal_iterator<typename _Container::pointer, _Container>
743  (_PTraits::pointer_to(const_cast<typename _PTraits::element_type&>
744  (*_M_current)));
745  }
746 #else
747  __normal_iterator
748  _M_const_cast() const
749  { return *this; }
750 #endif
751 
752  // Forward iterator requirements
753  reference
754  operator*() const
755  { return *_M_current; }
756 
757  pointer
758  operator->() const
759  { return _M_current; }
760 
761  __normal_iterator&
762  operator++()
763  {
764  ++_M_current;
765  return *this;
766  }
767 
768  __normal_iterator
769  operator++(int)
770  { return __normal_iterator(_M_current++); }
771 
772  // Bidirectional iterator requirements
773  __normal_iterator&
774  operator--()
775  {
776  --_M_current;
777  return *this;
778  }
779 
780  __normal_iterator
781  operator--(int)
782  { return __normal_iterator(_M_current--); }
783 
784  // Random access iterator requirements
785  reference
786  operator[](const difference_type& __n) const
787  { return _M_current[__n]; }
788 
789  __normal_iterator&
790  operator+=(const difference_type& __n)
791  { _M_current += __n; return *this; }
792 
793  __normal_iterator
794  operator+(const difference_type& __n) const
795  { return __normal_iterator(_M_current + __n); }
796 
797  __normal_iterator&
798  operator-=(const difference_type& __n)
799  { _M_current -= __n; return *this; }
800 
801  __normal_iterator
802  operator-(const difference_type& __n) const
803  { return __normal_iterator(_M_current - __n); }
804 
805  const _Iterator&
806  base() const
807  { return _M_current; }
808  };
809 
810  // Note: In what follows, the left- and right-hand-side iterators are
811  // allowed to vary in types (conceptually in cv-qualification) so that
812  // comparison between cv-qualified and non-cv-qualified iterators be
813  // valid. However, the greedy and unfriendly operators in std::rel_ops
814  // will make overload resolution ambiguous (when in scope) if we don't
815  // provide overloads whose operands are of the same type. Can someone
816  // remind me what generic programming is about? -- Gaby
817 
818  // Forward iterator requirements
819  template<typename _IteratorL, typename _IteratorR, typename _Container>
820  inline bool
821  operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
822  const __normal_iterator<_IteratorR, _Container>& __rhs)
823  { return __lhs.base() == __rhs.base(); }
824 
825  template<typename _Iterator, typename _Container>
826  inline bool
827  operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
828  const __normal_iterator<_Iterator, _Container>& __rhs)
829  { return __lhs.base() == __rhs.base(); }
830 
831  template<typename _IteratorL, typename _IteratorR, typename _Container>
832  inline bool
833  operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
834  const __normal_iterator<_IteratorR, _Container>& __rhs)
835  { return __lhs.base() != __rhs.base(); }
836 
837  template<typename _Iterator, typename _Container>
838  inline bool
839  operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
840  const __normal_iterator<_Iterator, _Container>& __rhs)
841  { return __lhs.base() != __rhs.base(); }
842 
843  // Random access iterator requirements
844  template<typename _IteratorL, typename _IteratorR, typename _Container>
845  inline bool
846  operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
847  const __normal_iterator<_IteratorR, _Container>& __rhs)
848  { return __lhs.base() < __rhs.base(); }
849 
850  template<typename _Iterator, typename _Container>
851  inline bool
852  operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
853  const __normal_iterator<_Iterator, _Container>& __rhs)
854  { return __lhs.base() < __rhs.base(); }
855 
856  template<typename _IteratorL, typename _IteratorR, typename _Container>
857  inline bool
858  operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
859  const __normal_iterator<_IteratorR, _Container>& __rhs)
860  { return __lhs.base() > __rhs.base(); }
861 
862  template<typename _Iterator, typename _Container>
863  inline bool
864  operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
865  const __normal_iterator<_Iterator, _Container>& __rhs)
866  { return __lhs.base() > __rhs.base(); }
867 
868  template<typename _IteratorL, typename _IteratorR, typename _Container>
869  inline bool
870  operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
871  const __normal_iterator<_IteratorR, _Container>& __rhs)
872  { return __lhs.base() <= __rhs.base(); }
873 
874  template<typename _Iterator, typename _Container>
875  inline bool
876  operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
877  const __normal_iterator<_Iterator, _Container>& __rhs)
878  { return __lhs.base() <= __rhs.base(); }
879 
880  template<typename _IteratorL, typename _IteratorR, typename _Container>
881  inline bool
882  operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
883  const __normal_iterator<_IteratorR, _Container>& __rhs)
884  { return __lhs.base() >= __rhs.base(); }
885 
886  template<typename _Iterator, typename _Container>
887  inline bool
888  operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
889  const __normal_iterator<_Iterator, _Container>& __rhs)
890  { return __lhs.base() >= __rhs.base(); }
891 
892  // _GLIBCXX_RESOLVE_LIB_DEFECTS
893  // According to the resolution of DR179 not only the various comparison
894  // operators but also operator- must accept mixed iterator/const_iterator
895  // parameters.
896  template<typename _IteratorL, typename _IteratorR, typename _Container>
897 #if __cplusplus >= 201103L
898  // DR 685.
899  inline auto
900  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
901  const __normal_iterator<_IteratorR, _Container>& __rhs)
902  -> decltype(__lhs.base() - __rhs.base())
903 #else
904  inline typename __normal_iterator<_IteratorL, _Container>::difference_type
905  operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
906  const __normal_iterator<_IteratorR, _Container>& __rhs)
907 #endif
908  { return __lhs.base() - __rhs.base(); }
909 
910  template<typename _Iterator, typename _Container>
911  inline typename __normal_iterator<_Iterator, _Container>::difference_type
912  operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
913  const __normal_iterator<_Iterator, _Container>& __rhs)
914  { 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  { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
921 
922 _GLIBCXX_END_NAMESPACE_VERSION
923 } // namespace
924 
925 #if __cplusplus >= 201103L
926 
927 namespace std _GLIBCXX_VISIBILITY(default)
928 {
929 _GLIBCXX_BEGIN_NAMESPACE_VERSION
930 
931  /**
932  * @addtogroup iterators
933  * @{
934  */
935 
936  // 24.4.3 Move iterators
937  /**
938  * Class template move_iterator is an iterator adapter with the same
939  * behavior as the underlying iterator except that its dereference
940  * operator implicitly converts the value returned by the underlying
941  * iterator's dereference operator to an rvalue reference. Some
942  * generic algorithms can be called with move iterators to replace
943  * copying with moving.
944  */
945  template<typename _Iterator>
946  class move_iterator
947  {
948  protected:
949  _Iterator _M_current;
950 
951  typedef iterator_traits<_Iterator> __traits_type;
952 
953  public:
954  typedef _Iterator iterator_type;
955  typedef typename __traits_type::iterator_category iterator_category;
956  typedef typename __traits_type::value_type value_type;
957  typedef typename __traits_type::difference_type difference_type;
958  // NB: DR 680.
959  typedef _Iterator pointer;
960  typedef value_type&& reference;
961 
962  move_iterator()
963  : _M_current() { }
964 
965  explicit
966  move_iterator(iterator_type __i)
967  : _M_current(__i) { }
968 
969  template<typename _Iter>
970  move_iterator(const move_iterator<_Iter>& __i)
971  : _M_current(__i.base()) { }
972 
973  iterator_type
974  base() const
975  { return _M_current; }
976 
977  reference
978  operator*() const
979  { return std::move(*_M_current); }
980 
981  pointer
982  operator->() const
983  { return _M_current; }
984 
985  move_iterator&
986  operator++()
987  {
988  ++_M_current;
989  return *this;
990  }
991 
992  move_iterator
993  operator++(int)
994  {
995  move_iterator __tmp = *this;
996  ++_M_current;
997  return __tmp;
998  }
999 
1000  move_iterator&
1001  operator--()
1002  {
1003  --_M_current;
1004  return *this;
1005  }
1006 
1007  move_iterator
1008  operator--(int)
1009  {
1010  move_iterator __tmp = *this;
1011  --_M_current;
1012  return __tmp;
1013  }
1014 
1015  move_iterator
1016  operator+(difference_type __n) const
1017  { return move_iterator(_M_current + __n); }
1018 
1019  move_iterator&
1020  operator+=(difference_type __n)
1021  {
1022  _M_current += __n;
1023  return *this;
1024  }
1025 
1026  move_iterator
1027  operator-(difference_type __n) const
1028  { return move_iterator(_M_current - __n); }
1029 
1030  move_iterator&
1031  operator-=(difference_type __n)
1032  {
1033  _M_current -= __n;
1034  return *this;
1035  }
1036 
1037  reference
1038  operator[](difference_type __n) const
1039  { return std::move(_M_current[__n]); }
1040  };
1041 
1042  // Note: See __normal_iterator operators note from Gaby to understand
1043  // why there are always 2 versions for most of the move_iterator
1044  // operators.
1045  template<typename _IteratorL, typename _IteratorR>
1046  inline bool
1047  operator==(const move_iterator<_IteratorL>& __x,
1048  const move_iterator<_IteratorR>& __y)
1049  { return __x.base() == __y.base(); }
1050 
1051  template<typename _Iterator>
1052  inline bool
1053  operator==(const move_iterator<_Iterator>& __x,
1054  const move_iterator<_Iterator>& __y)
1055  { return __x.base() == __y.base(); }
1056 
1057  template<typename _IteratorL, typename _IteratorR>
1058  inline bool
1059  operator!=(const move_iterator<_IteratorL>& __x,
1060  const move_iterator<_IteratorR>& __y)
1061  { return !(__x == __y); }
1062 
1063  template<typename _Iterator>
1064  inline bool
1065  operator!=(const move_iterator<_Iterator>& __x,
1066  const move_iterator<_Iterator>& __y)
1067  { return !(__x == __y); }
1068 
1069  template<typename _IteratorL, typename _IteratorR>
1070  inline bool
1071  operator<(const move_iterator<_IteratorL>& __x,
1072  const move_iterator<_IteratorR>& __y)
1073  { return __x.base() < __y.base(); }
1074 
1075  template<typename _Iterator>
1076  inline bool
1077  operator<(const move_iterator<_Iterator>& __x,
1078  const move_iterator<_Iterator>& __y)
1079  { return __x.base() < __y.base(); }
1080 
1081  template<typename _IteratorL, typename _IteratorR>
1082  inline bool
1083  operator<=(const move_iterator<_IteratorL>& __x,
1084  const move_iterator<_IteratorR>& __y)
1085  { return !(__y < __x); }
1086 
1087  template<typename _Iterator>
1088  inline bool
1089  operator<=(const move_iterator<_Iterator>& __x,
1090  const move_iterator<_Iterator>& __y)
1091  { return !(__y < __x); }
1092 
1093  template<typename _IteratorL, typename _IteratorR>
1094  inline bool
1095  operator>(const move_iterator<_IteratorL>& __x,
1096  const move_iterator<_IteratorR>& __y)
1097  { return __y < __x; }
1098 
1099  template<typename _Iterator>
1100  inline bool
1101  operator>(const move_iterator<_Iterator>& __x,
1102  const move_iterator<_Iterator>& __y)
1103  { return __y < __x; }
1104 
1105  template<typename _IteratorL, typename _IteratorR>
1106  inline bool
1107  operator>=(const move_iterator<_IteratorL>& __x,
1108  const move_iterator<_IteratorR>& __y)
1109  { return !(__x < __y); }
1110 
1111  template<typename _Iterator>
1112  inline bool
1113  operator>=(const move_iterator<_Iterator>& __x,
1114  const move_iterator<_Iterator>& __y)
1115  { return !(__x < __y); }
1116 
1117  // DR 685.
1118  template<typename _IteratorL, typename _IteratorR>
1119  inline auto
1120  operator-(const move_iterator<_IteratorL>& __x,
1121  const move_iterator<_IteratorR>& __y)
1122  -> decltype(__x.base() - __y.base())
1123  { return __x.base() - __y.base(); }
1124 
1125  template<typename _Iterator>
1126  inline auto
1127  operator-(const move_iterator<_Iterator>& __x,
1128  const move_iterator<_Iterator>& __y)
1129  -> decltype(__x.base() - __y.base())
1130  { return __x.base() - __y.base(); }
1131 
1132  template<typename _Iterator>
1133  inline move_iterator<_Iterator>
1134  operator+(typename move_iterator<_Iterator>::difference_type __n,
1135  const move_iterator<_Iterator>& __x)
1136  { return __x + __n; }
1137 
1138  template<typename _Iterator>
1139  inline move_iterator<_Iterator>
1140  make_move_iterator(_Iterator __i)
1141  { return move_iterator<_Iterator>(__i); }
1142 
1143  template<typename _Iterator, typename _ReturnType
1144  = typename conditional<__move_if_noexcept_cond
1145  <typename iterator_traits<_Iterator>::value_type>::value,
1146  _Iterator, move_iterator<_Iterator>>::type>
1147  inline _ReturnType
1148  __make_move_if_noexcept_iterator(_Iterator __i)
1149  { return _ReturnType(__i); }
1150 
1151  // @} group iterators
1152 
1153 _GLIBCXX_END_NAMESPACE_VERSION
1154 } // namespace
1155 
1156 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
1157 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
1158  std::__make_move_if_noexcept_iterator(_Iter)
1159 #else
1160 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
1161 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
1162 #endif // C++11
1163 
1164 #endif