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