1 // Iterators -*- C++ -*-
2
3 // Copyright (C) 2001-2022 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 <bits/stl_iterator_base_types.h>
65 #include <ext/type_traits.h>
66 #include <bits/move.h>
67 #include <bits/ptr_traits.h>
68
69 #if __cplusplus >= 201103L
70 # include <type_traits>
71 #endif
72
73 #if __cplusplus > 201703L
74 # define __cpp_lib_array_constexpr 201811L
75 # define __cpp_lib_constexpr_iterator 201811L
76 #elif __cplusplus == 201703L
77 # define __cpp_lib_array_constexpr 201803L
78 #endif
79
80 #if __cplusplus >= 202002L
81 # include <compare>
82 # include <new>
83 # include <bits/exception_defines.h>
84 # include <bits/iterator_concepts.h>
85 # include <bits/stl_construct.h>
86 #endif
87
_GLIBCXX_VISIBILITY(default)88 namespace std _GLIBCXX_VISIBILITY(default)
89 {
90 _GLIBCXX_BEGIN_NAMESPACE_VERSION
91
92 /**
93 * @addtogroup iterators
94 * @{
95 */
96
97 #if __cpp_lib_concepts
98 namespace __detail
99 {
100 // Weaken iterator_category _Cat to _Limit if it is derived from that,
101 // otherwise use _Otherwise.
102 template<typename _Cat, typename _Limit, typename _Otherwise = _Cat>
103 using __clamp_iter_cat
104 = __conditional_t<derived_from<_Cat, _Limit>, _Limit, _Otherwise>;
105 }
106 #endif
107
108 // Ignore warnings about std::iterator.
109 #pragma GCC diagnostic push
110 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
111
112 // 24.4.1 Reverse iterators
113 /**
114 * Bidirectional and random access iterators have corresponding reverse
115 * %iterator adaptors that iterate through the data structure in the
116 * opposite direction. They have the same signatures as the corresponding
117 * iterators. The fundamental relation between a reverse %iterator and its
118 * corresponding %iterator @c i is established by the identity:
119 * @code
120 * &*(reverse_iterator(i)) == &*(i - 1)
121 * @endcode
122 *
123 * <em>This mapping is dictated by the fact that while there is always a
124 * pointer past the end of an array, there might not be a valid pointer
125 * before the beginning of an array.</em> [24.4.1]/1,2
126 *
127 * Reverse iterators can be tricky and surprising at first. Their
128 * semantics make sense, however, and the trickiness is a side effect of
129 * the requirement that the iterators must be safe.
130 */
131 template<typename _Iterator>
132 class reverse_iterator
133 : public iterator<typename iterator_traits<_Iterator>::iterator_category,
134 typename iterator_traits<_Iterator>::value_type,
135 typename iterator_traits<_Iterator>::difference_type,
136 typename iterator_traits<_Iterator>::pointer,
137 typename iterator_traits<_Iterator>::reference>
138 {
139 template<typename _Iter>
140 friend class reverse_iterator;
141
142 #if __cpp_lib_concepts
143 // _GLIBCXX_RESOLVE_LIB_DEFECTS
144 // 3435. three_way_comparable_with<reverse_iterator<int*>, [...]>
145 template<typename _Iter>
146 static constexpr bool __convertible = !is_same_v<_Iter, _Iterator>
147 && convertible_to<const _Iter&, _Iterator>;
148 #endif
149
150 protected:
151 _Iterator current;
152
153 typedef iterator_traits<_Iterator> __traits_type;
154
155 public:
156 typedef _Iterator iterator_type;
157 typedef typename __traits_type::pointer pointer;
158 #if ! __cpp_lib_concepts
159 typedef typename __traits_type::difference_type difference_type;
160 typedef typename __traits_type::reference reference;
161 #else
162 using iterator_concept
163 = __conditional_t<random_access_iterator<_Iterator>,
164 random_access_iterator_tag,
165 bidirectional_iterator_tag>;
166 using iterator_category
167 = __detail::__clamp_iter_cat<typename __traits_type::iterator_category,
168 random_access_iterator_tag>;
169 using value_type = iter_value_t<_Iterator>;
170 using difference_type = iter_difference_t<_Iterator>;
171 using reference = iter_reference_t<_Iterator>;
172 #endif
173
174 /**
175 * The default constructor value-initializes member @p current.
176 * If it is a pointer, that means it is zero-initialized.
177 */
178 // _GLIBCXX_RESOLVE_LIB_DEFECTS
179 // 235 No specification of default ctor for reverse_iterator
180 // 1012. reverse_iterator default ctor should value initialize
181 _GLIBCXX17_CONSTEXPR
182 reverse_iterator()
183 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator()))
184 : current()
185 { }
186
187 /**
188 * This %iterator will move in the opposite direction that @p x does.
189 */
190 explicit _GLIBCXX17_CONSTEXPR
191 reverse_iterator(iterator_type __x)
192 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(__x)))
193 : current(__x)
194 { }
195
196 /**
197 * The copy constructor is normal.
198 */
199 _GLIBCXX17_CONSTEXPR
200 reverse_iterator(const reverse_iterator& __x)
201 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(__x.current)))
202 : current(__x.current)
203 { }
204
205 #if __cplusplus >= 201103L
206 reverse_iterator& operator=(const reverse_iterator&) = default;
207 #endif
208
209 /**
210 * A %reverse_iterator across other types can be copied if the
211 * underlying %iterator can be converted to the type of @c current.
212 */
213 template<typename _Iter>
214 #if __cpp_lib_concepts
215 requires __convertible<_Iter>
216 #endif
217 _GLIBCXX17_CONSTEXPR
218 reverse_iterator(const reverse_iterator<_Iter>& __x)
219 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(__x.current)))
220 : current(__x.current)
221 { }
222
223 #if __cplusplus >= 201103L
224 template<typename _Iter>
225 #if __cpp_lib_concepts
226 requires __convertible<_Iter>
227 && assignable_from<_Iterator&, const _Iter&>
228 #endif
229 _GLIBCXX17_CONSTEXPR
230 reverse_iterator&
231 operator=(const reverse_iterator<_Iter>& __x)
232 _GLIBCXX_NOEXCEPT_IF(noexcept(current = __x.current))
233 {
234 current = __x.current;
235 return *this;
236 }
237 #endif
238
239 /**
240 * @return @c current, the %iterator used for underlying work.
241 */
242 _GLIBCXX_NODISCARD
243 _GLIBCXX17_CONSTEXPR iterator_type
244 base() const
245 _GLIBCXX_NOEXCEPT_IF(noexcept(_Iterator(current)))
246 { return current; }
247
248 /**
249 * @return A reference to the value at @c --current
250 *
251 * This requires that @c --current is dereferenceable.
252 *
253 * @warning This implementation requires that for an iterator of the
254 * underlying iterator type, @c x, a reference obtained by
255 * @c *x remains valid after @c x has been modified or
256 * destroyed. This is a bug: http://gcc.gnu.org/PR51823
257 */
258 _GLIBCXX_NODISCARD
259 _GLIBCXX17_CONSTEXPR reference
260 operator*() const
261 {
262 _Iterator __tmp = current;
263 return *--__tmp;
264 }
265
266 /**
267 * @return A pointer to the value at @c --current
268 *
269 * This requires that @c --current is dereferenceable.
270 */
271 _GLIBCXX_NODISCARD
272 _GLIBCXX17_CONSTEXPR pointer
273 operator->() const
274 #if __cplusplus > 201703L && __cpp_concepts >= 201907L
275 requires is_pointer_v<_Iterator>
276 || requires(const _Iterator __i) { __i.operator->(); }
277 #endif
278 {
279 // _GLIBCXX_RESOLVE_LIB_DEFECTS
280 // 1052. operator-> should also support smart pointers
281 _Iterator __tmp = current;
282 --__tmp;
283 return _S_to_pointer(__tmp);
284 }
285
286 /**
287 * @return @c *this
288 *
289 * Decrements the underlying iterator.
290 */
291 _GLIBCXX17_CONSTEXPR reverse_iterator&
292 operator++()
293 {
294 --current;
295 return *this;
296 }
297
298 /**
299 * @return The original value of @c *this
300 *
301 * Decrements the underlying iterator.
302 */
303 _GLIBCXX17_CONSTEXPR reverse_iterator
304 operator++(int)
305 {
306 reverse_iterator __tmp = *this;
307 --current;
308 return __tmp;
309 }
310
311 /**
312 * @return @c *this
313 *
314 * Increments the underlying iterator.
315 */
316 _GLIBCXX17_CONSTEXPR reverse_iterator&
317 operator--()
318 {
319 ++current;
320 return *this;
321 }
322
323 /**
324 * @return A reverse_iterator with the previous value of @c *this
325 *
326 * Increments the underlying iterator.
327 */
328 _GLIBCXX17_CONSTEXPR reverse_iterator
329 operator--(int)
330 {
331 reverse_iterator __tmp = *this;
332 ++current;
333 return __tmp;
334 }
335
336 /**
337 * @return A reverse_iterator that refers to @c current - @a __n
338 *
339 * The underlying iterator must be a Random Access Iterator.
340 */
341 _GLIBCXX_NODISCARD
342 _GLIBCXX17_CONSTEXPR reverse_iterator
343 operator+(difference_type __n) const
344 { return reverse_iterator(current - __n); }
345
346 /**
347 * @return *this
348 *
349 * Moves the underlying iterator backwards @a __n steps.
350 * The underlying iterator must be a Random Access Iterator.
351 */
352 _GLIBCXX17_CONSTEXPR reverse_iterator&
353 operator+=(difference_type __n)
354 {
355 current -= __n;
356 return *this;
357 }
358
359 /**
360 * @return A reverse_iterator that refers to @c current - @a __n
361 *
362 * The underlying iterator must be a Random Access Iterator.
363 */
364 _GLIBCXX_NODISCARD
365 _GLIBCXX17_CONSTEXPR reverse_iterator
366 operator-(difference_type __n) const
367 { return reverse_iterator(current + __n); }
368
369 /**
370 * @return *this
371 *
372 * Moves the underlying iterator forwards @a __n steps.
373 * The underlying iterator must be a Random Access Iterator.
374 */
375 _GLIBCXX17_CONSTEXPR reverse_iterator&
376 operator-=(difference_type __n)
377 {
378 current += __n;
379 return *this;
380 }
381
382 /**
383 * @return The value at @c current - @a __n - 1
384 *
385 * The underlying iterator must be a Random Access Iterator.
386 */
387 _GLIBCXX_NODISCARD
388 _GLIBCXX17_CONSTEXPR reference
389 operator[](difference_type __n) const
390 { return *(*this + __n); }
391
392 #if __cplusplus > 201703L && __cpp_lib_concepts
393 [[nodiscard]]
394 friend constexpr iter_rvalue_reference_t<_Iterator>
395 iter_move(const reverse_iterator& __i)
396 noexcept(is_nothrow_copy_constructible_v<_Iterator>
397 && noexcept(ranges::iter_move(--std::declval<_Iterator&>())))
398 {
399 auto __tmp = __i.base();
400 return ranges::iter_move(--__tmp);
401 }
402
403 template<indirectly_swappable<_Iterator> _Iter2>
404 friend constexpr void
405 iter_swap(const reverse_iterator& __x,
406 const reverse_iterator<_Iter2>& __y)
407 noexcept(is_nothrow_copy_constructible_v<_Iterator>
408 && is_nothrow_copy_constructible_v<_Iter2>
409 && noexcept(ranges::iter_swap(--std::declval<_Iterator&>(),
410 --std::declval<_Iter2&>())))
411 {
412 auto __xtmp = __x.base();
413 auto __ytmp = __y.base();
414 ranges::iter_swap(--__xtmp, --__ytmp);
415 }
416 #endif
417
418 private:
419 template<typename _Tp>
420 static _GLIBCXX17_CONSTEXPR _Tp*
421 _S_to_pointer(_Tp* __p)
422 { return __p; }
423
424 template<typename _Tp>
425 static _GLIBCXX17_CONSTEXPR pointer
426 _S_to_pointer(_Tp __t)
427 { return __t.operator->(); }
428 };
429
430 ///@{
431 /**
432 * @param __x A %reverse_iterator.
433 * @param __y A %reverse_iterator.
434 * @return A simple bool.
435 *
436 * Reverse iterators forward comparisons to their underlying base()
437 * iterators.
438 *
439 */
440 #if __cplusplus <= 201703L || ! defined __cpp_lib_concepts
441 template<typename _Iterator>
442 _GLIBCXX_NODISCARD
443 inline _GLIBCXX17_CONSTEXPR bool
444 operator==(const reverse_iterator<_Iterator>& __x,
445 const reverse_iterator<_Iterator>& __y)
446 { return __x.base() == __y.base(); }
447
448 template<typename _Iterator>
449 _GLIBCXX_NODISCARD
450 inline _GLIBCXX17_CONSTEXPR bool
451 operator<(const reverse_iterator<_Iterator>& __x,
452 const reverse_iterator<_Iterator>& __y)
453 { return __y.base() < __x.base(); }
454
455 template<typename _Iterator>
456 _GLIBCXX_NODISCARD
457 inline _GLIBCXX17_CONSTEXPR bool
458 operator!=(const reverse_iterator<_Iterator>& __x,
459 const reverse_iterator<_Iterator>& __y)
460 { return !(__x == __y); }
461
462 template<typename _Iterator>
463 _GLIBCXX_NODISCARD
464 inline _GLIBCXX17_CONSTEXPR bool
465 operator>(const reverse_iterator<_Iterator>& __x,
466 const reverse_iterator<_Iterator>& __y)
467 { return __y < __x; }
468
469 template<typename _Iterator>
470 _GLIBCXX_NODISCARD
471 inline _GLIBCXX17_CONSTEXPR bool
472 operator<=(const reverse_iterator<_Iterator>& __x,
473 const reverse_iterator<_Iterator>& __y)
474 { return !(__y < __x); }
475
476 template<typename _Iterator>
477 _GLIBCXX_NODISCARD
478 inline _GLIBCXX17_CONSTEXPR bool
479 operator>=(const reverse_iterator<_Iterator>& __x,
480 const reverse_iterator<_Iterator>& __y)
481 { return !(__x < __y); }
482
483 // _GLIBCXX_RESOLVE_LIB_DEFECTS
484 // DR 280. Comparison of reverse_iterator to const reverse_iterator.
485
486 template<typename _IteratorL, typename _IteratorR>
487 _GLIBCXX_NODISCARD
488 inline _GLIBCXX17_CONSTEXPR bool
489 operator==(const reverse_iterator<_IteratorL>& __x,
490 const reverse_iterator<_IteratorR>& __y)
491 { return __x.base() == __y.base(); }
492
493 template<typename _IteratorL, typename _IteratorR>
494 _GLIBCXX_NODISCARD
495 inline _GLIBCXX17_CONSTEXPR bool
496 operator<(const reverse_iterator<_IteratorL>& __x,
497 const reverse_iterator<_IteratorR>& __y)
498 { return __x.base() > __y.base(); }
499
500 template<typename _IteratorL, typename _IteratorR>
501 _GLIBCXX_NODISCARD
502 inline _GLIBCXX17_CONSTEXPR bool
503 operator!=(const reverse_iterator<_IteratorL>& __x,
504 const reverse_iterator<_IteratorR>& __y)
505 { return __x.base() != __y.base(); }
506
507 template<typename _IteratorL, typename _IteratorR>
508 _GLIBCXX_NODISCARD
509 inline _GLIBCXX17_CONSTEXPR bool
510 operator>(const reverse_iterator<_IteratorL>& __x,
511 const reverse_iterator<_IteratorR>& __y)
512 { return __x.base() < __y.base(); }
513
514 template<typename _IteratorL, typename _IteratorR>
515 inline _GLIBCXX17_CONSTEXPR bool
516 operator<=(const reverse_iterator<_IteratorL>& __x,
517 const reverse_iterator<_IteratorR>& __y)
518 { return __x.base() >= __y.base(); }
519
520 template<typename _IteratorL, typename _IteratorR>
521 _GLIBCXX_NODISCARD
522 inline _GLIBCXX17_CONSTEXPR bool
523 operator>=(const reverse_iterator<_IteratorL>& __x,
524 const reverse_iterator<_IteratorR>& __y)
525 { return __x.base() <= __y.base(); }
526 #else // C++20
527 template<typename _IteratorL, typename _IteratorR>
528 [[nodiscard]]
529 constexpr bool
530 operator==(const reverse_iterator<_IteratorL>& __x,
531 const reverse_iterator<_IteratorR>& __y)
532 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
533 { return __x.base() == __y.base(); }
534
535 template<typename _IteratorL, typename _IteratorR>
536 [[nodiscard]]
537 constexpr bool
538 operator!=(const reverse_iterator<_IteratorL>& __x,
539 const reverse_iterator<_IteratorR>& __y)
540 requires requires { { __x.base() != __y.base() } -> convertible_to<bool>; }
541 { return __x.base() != __y.base(); }
542
543 template<typename _IteratorL, typename _IteratorR>
544 [[nodiscard]]
545 constexpr bool
546 operator<(const reverse_iterator<_IteratorL>& __x,
547 const reverse_iterator<_IteratorR>& __y)
548 requires requires { { __x.base() > __y.base() } -> convertible_to<bool>; }
549 { return __x.base() > __y.base(); }
550
551 template<typename _IteratorL, typename _IteratorR>
552 [[nodiscard]]
553 constexpr bool
554 operator>(const reverse_iterator<_IteratorL>& __x,
555 const reverse_iterator<_IteratorR>& __y)
556 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
557 { return __x.base() < __y.base(); }
558
559 template<typename _IteratorL, typename _IteratorR>
560 [[nodiscard]]
561 constexpr bool
562 operator<=(const reverse_iterator<_IteratorL>& __x,
563 const reverse_iterator<_IteratorR>& __y)
564 requires requires { { __x.base() >= __y.base() } -> convertible_to<bool>; }
565 { return __x.base() >= __y.base(); }
566
567 template<typename _IteratorL, typename _IteratorR>
568 [[nodiscard]]
569 constexpr bool
570 operator>=(const reverse_iterator<_IteratorL>& __x,
571 const reverse_iterator<_IteratorR>& __y)
572 requires requires { { __x.base() <= __y.base() } -> convertible_to<bool>; }
573 { return __x.base() <= __y.base(); }
574
575 template<typename _IteratorL,
576 three_way_comparable_with<_IteratorL> _IteratorR>
577 [[nodiscard]]
578 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
579 operator<=>(const reverse_iterator<_IteratorL>& __x,
580 const reverse_iterator<_IteratorR>& __y)
581 { return __y.base() <=> __x.base(); }
582
583 // Additional, non-standard overloads to avoid ambiguities with greedy,
584 // unconstrained overloads in associated namespaces.
585
586 template<typename _Iterator>
587 [[nodiscard]]
588 constexpr bool
589 operator==(const reverse_iterator<_Iterator>& __x,
590 const reverse_iterator<_Iterator>& __y)
591 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
592 { return __x.base() == __y.base(); }
593
594 template<three_way_comparable _Iterator>
595 [[nodiscard]]
596 constexpr compare_three_way_result_t<_Iterator, _Iterator>
597 operator<=>(const reverse_iterator<_Iterator>& __x,
598 const reverse_iterator<_Iterator>& __y)
599 { return __y.base() <=> __x.base(); }
600 #endif // C++20
601 ///@}
602
603 #if __cplusplus < 201103L
604 template<typename _Iterator>
605 inline typename reverse_iterator<_Iterator>::difference_type
606 operator-(const reverse_iterator<_Iterator>& __x,
607 const reverse_iterator<_Iterator>& __y)
608 { return __y.base() - __x.base(); }
609
610 template<typename _IteratorL, typename _IteratorR>
611 inline typename reverse_iterator<_IteratorL>::difference_type
612 operator-(const reverse_iterator<_IteratorL>& __x,
613 const reverse_iterator<_IteratorR>& __y)
614 { return __y.base() - __x.base(); }
615 #else
616 // _GLIBCXX_RESOLVE_LIB_DEFECTS
617 // DR 685. reverse_iterator/move_iterator difference has invalid signatures
618 template<typename _IteratorL, typename _IteratorR>
619 [[__nodiscard__]]
620 inline _GLIBCXX17_CONSTEXPR auto
621 operator-(const reverse_iterator<_IteratorL>& __x,
622 const reverse_iterator<_IteratorR>& __y)
623 -> decltype(__y.base() - __x.base())
624 { return __y.base() - __x.base(); }
625 #endif
626
627 template<typename _Iterator>
628 _GLIBCXX_NODISCARD
629 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
630 operator+(typename reverse_iterator<_Iterator>::difference_type __n,
631 const reverse_iterator<_Iterator>& __x)
632 { return reverse_iterator<_Iterator>(__x.base() - __n); }
633
634 #if __cplusplus >= 201103L
635 // Same as C++14 make_reverse_iterator but used in C++11 mode too.
636 template<typename _Iterator>
637 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
638 __make_reverse_iterator(_Iterator __i)
639 { return reverse_iterator<_Iterator>(__i); }
640
641 # if __cplusplus >= 201402L
642 # define __cpp_lib_make_reverse_iterator 201402L
643
644 // _GLIBCXX_RESOLVE_LIB_DEFECTS
645 // DR 2285. make_reverse_iterator
646 /// Generator function for reverse_iterator.
647 template<typename _Iterator>
648 [[__nodiscard__]]
649 inline _GLIBCXX17_CONSTEXPR reverse_iterator<_Iterator>
650 make_reverse_iterator(_Iterator __i)
651 { return reverse_iterator<_Iterator>(__i); }
652
653 # if __cplusplus > 201703L && defined __cpp_lib_concepts
654 template<typename _Iterator1, typename _Iterator2>
655 requires (!sized_sentinel_for<_Iterator1, _Iterator2>)
656 inline constexpr bool
657 disable_sized_sentinel_for<reverse_iterator<_Iterator1>,
658 reverse_iterator<_Iterator2>> = true;
659 # endif // C++20
660 # endif // C++14
661
662 template<typename _Iterator>
663 _GLIBCXX20_CONSTEXPR
664 auto
665 __niter_base(reverse_iterator<_Iterator> __it)
666 -> decltype(__make_reverse_iterator(__niter_base(__it.base())))
667 { return __make_reverse_iterator(__niter_base(__it.base())); }
668
669 template<typename _Iterator>
670 struct __is_move_iterator<reverse_iterator<_Iterator> >
671 : __is_move_iterator<_Iterator>
672 { };
673
674 template<typename _Iterator>
675 _GLIBCXX20_CONSTEXPR
676 auto
677 __miter_base(reverse_iterator<_Iterator> __it)
678 -> decltype(__make_reverse_iterator(__miter_base(__it.base())))
679 { return __make_reverse_iterator(__miter_base(__it.base())); }
680 #endif // C++11
681
682 // 24.4.2.2.1 back_insert_iterator
683 /**
684 * @brief Turns assignment into insertion.
685 *
686 * These are output iterators, constructed from a container-of-T.
687 * Assigning a T to the iterator appends it to the container using
688 * push_back.
689 *
690 * Tip: Using the back_inserter function to create these iterators can
691 * save typing.
692 */
693 template<typename _Container>
694 class back_insert_iterator
695 : public iterator<output_iterator_tag, void, void, void, void>
696 {
697 protected:
698 _Container* container;
699
700 public:
701 /// A nested typedef for the type of whatever container you used.
702 typedef _Container container_type;
703 #if __cplusplus > 201703L
704 using difference_type = ptrdiff_t;
705 #endif
706
707 /// The only way to create this %iterator is with a container.
708 explicit _GLIBCXX20_CONSTEXPR
709 back_insert_iterator(_Container& __x)
710 : container(std::__addressof(__x)) { }
711
712 /**
713 * @param __value An instance of whatever type
714 * container_type::const_reference is; presumably a
715 * reference-to-const T for container<T>.
716 * @return This %iterator, for chained operations.
717 *
718 * This kind of %iterator doesn't really have a @a position in the
719 * container (you can think of the position as being permanently at
720 * the end, if you like). Assigning a value to the %iterator will
721 * always append the value to the end of the container.
722 */
723 #if __cplusplus < 201103L
724 back_insert_iterator&
725 operator=(typename _Container::const_reference __value)
726 {
727 container->push_back(__value);
728 return *this;
729 }
730 #else
731 _GLIBCXX20_CONSTEXPR
732 back_insert_iterator&
733 operator=(const typename _Container::value_type& __value)
734 {
735 container->push_back(__value);
736 return *this;
737 }
738
739 _GLIBCXX20_CONSTEXPR
740 back_insert_iterator&
741 operator=(typename _Container::value_type&& __value)
742 {
743 container->push_back(std::move(__value));
744 return *this;
745 }
746 #endif
747
748 /// Simply returns *this.
749 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
750 back_insert_iterator&
751 operator*()
752 { return *this; }
753
754 /// Simply returns *this. (This %iterator does not @a move.)
755 _GLIBCXX20_CONSTEXPR
756 back_insert_iterator&
757 operator++()
758 { return *this; }
759
760 /// Simply returns *this. (This %iterator does not @a move.)
761 _GLIBCXX20_CONSTEXPR
762 back_insert_iterator
763 operator++(int)
764 { return *this; }
765 };
766
767 /**
768 * @param __x A container of arbitrary type.
769 * @return An instance of back_insert_iterator working on @p __x.
770 *
771 * This wrapper function helps in creating back_insert_iterator instances.
772 * Typing the name of the %iterator requires knowing the precise full
773 * type of the container, which can be tedious and impedes generic
774 * programming. Using this function lets you take advantage of automatic
775 * template parameter deduction, making the compiler match the correct
776 * types for you.
777 */
778 template<typename _Container>
779 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
780 inline back_insert_iterator<_Container>
781 back_inserter(_Container& __x)
782 { return back_insert_iterator<_Container>(__x); }
783
784 /**
785 * @brief Turns assignment into insertion.
786 *
787 * These are output iterators, constructed from a container-of-T.
788 * Assigning a T to the iterator prepends it to the container using
789 * push_front.
790 *
791 * Tip: Using the front_inserter function to create these iterators can
792 * save typing.
793 */
794 template<typename _Container>
795 class front_insert_iterator
796 : public iterator<output_iterator_tag, void, void, void, void>
797 {
798 protected:
799 _Container* container;
800
801 public:
802 /// A nested typedef for the type of whatever container you used.
803 typedef _Container container_type;
804 #if __cplusplus > 201703L
805 using difference_type = ptrdiff_t;
806 #endif
807
808 /// The only way to create this %iterator is with a container.
809 explicit _GLIBCXX20_CONSTEXPR
810 front_insert_iterator(_Container& __x)
811 : container(std::__addressof(__x)) { }
812
813 /**
814 * @param __value An instance of whatever type
815 * container_type::const_reference is; presumably a
816 * reference-to-const T for container<T>.
817 * @return This %iterator, for chained operations.
818 *
819 * This kind of %iterator doesn't really have a @a position in the
820 * container (you can think of the position as being permanently at
821 * the front, if you like). Assigning a value to the %iterator will
822 * always prepend the value to the front of the container.
823 */
824 #if __cplusplus < 201103L
825 front_insert_iterator&
826 operator=(typename _Container::const_reference __value)
827 {
828 container->push_front(__value);
829 return *this;
830 }
831 #else
832 _GLIBCXX20_CONSTEXPR
833 front_insert_iterator&
834 operator=(const typename _Container::value_type& __value)
835 {
836 container->push_front(__value);
837 return *this;
838 }
839
840 _GLIBCXX20_CONSTEXPR
841 front_insert_iterator&
842 operator=(typename _Container::value_type&& __value)
843 {
844 container->push_front(std::move(__value));
845 return *this;
846 }
847 #endif
848
849 /// Simply returns *this.
850 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
851 front_insert_iterator&
852 operator*()
853 { return *this; }
854
855 /// Simply returns *this. (This %iterator does not @a move.)
856 _GLIBCXX20_CONSTEXPR
857 front_insert_iterator&
858 operator++()
859 { return *this; }
860
861 /// Simply returns *this. (This %iterator does not @a move.)
862 _GLIBCXX20_CONSTEXPR
863 front_insert_iterator
864 operator++(int)
865 { return *this; }
866 };
867
868 /**
869 * @param __x A container of arbitrary type.
870 * @return An instance of front_insert_iterator working on @p x.
871 *
872 * This wrapper function helps in creating front_insert_iterator instances.
873 * Typing the name of the %iterator requires knowing the precise full
874 * type of the container, which can be tedious and impedes generic
875 * programming. Using this function lets you take advantage of automatic
876 * template parameter deduction, making the compiler match the correct
877 * types for you.
878 */
879 template<typename _Container>
880 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
881 inline front_insert_iterator<_Container>
882 front_inserter(_Container& __x)
883 { return front_insert_iterator<_Container>(__x); }
884
885 /**
886 * @brief Turns assignment into insertion.
887 *
888 * These are output iterators, constructed from a container-of-T.
889 * Assigning a T to the iterator inserts it in the container at the
890 * %iterator's position, rather than overwriting the value at that
891 * position.
892 *
893 * (Sequences will actually insert a @e copy of the value before the
894 * %iterator's position.)
895 *
896 * Tip: Using the inserter function to create these iterators can
897 * save typing.
898 */
899 template<typename _Container>
900 class insert_iterator
901 : public iterator<output_iterator_tag, void, void, void, void>
902 {
903 #if __cplusplus > 201703L && defined __cpp_lib_concepts
904 using _Iter = std::__detail::__range_iter_t<_Container>;
905 #else
906 typedef typename _Container::iterator _Iter;
907 #endif
908 protected:
909 _Container* container;
910 _Iter iter;
911
912 public:
913 /// A nested typedef for the type of whatever container you used.
914 typedef _Container container_type;
915
916 #if __cplusplus > 201703L && defined __cpp_lib_concepts
917 using difference_type = ptrdiff_t;
918 #endif
919
920 /**
921 * The only way to create this %iterator is with a container and an
922 * initial position (a normal %iterator into the container).
923 */
924 _GLIBCXX20_CONSTEXPR
925 insert_iterator(_Container& __x, _Iter __i)
926 : container(std::__addressof(__x)), iter(__i) {}
927
928 /**
929 * @param __value An instance of whatever type
930 * container_type::const_reference is; presumably a
931 * reference-to-const T for container<T>.
932 * @return This %iterator, for chained operations.
933 *
934 * This kind of %iterator maintains its own position in the
935 * container. Assigning a value to the %iterator will insert the
936 * value into the container at the place before the %iterator.
937 *
938 * The position is maintained such that subsequent assignments will
939 * insert values immediately after one another. For example,
940 * @code
941 * // vector v contains A and Z
942 *
943 * insert_iterator i (v, ++v.begin());
944 * i = 1;
945 * i = 2;
946 * i = 3;
947 *
948 * // vector v contains A, 1, 2, 3, and Z
949 * @endcode
950 */
951 #if __cplusplus < 201103L
952 insert_iterator&
953 operator=(typename _Container::const_reference __value)
954 {
955 iter = container->insert(iter, __value);
956 ++iter;
957 return *this;
958 }
959 #else
960 _GLIBCXX20_CONSTEXPR
961 insert_iterator&
962 operator=(const typename _Container::value_type& __value)
963 {
964 iter = container->insert(iter, __value);
965 ++iter;
966 return *this;
967 }
968
969 _GLIBCXX20_CONSTEXPR
970 insert_iterator&
971 operator=(typename _Container::value_type&& __value)
972 {
973 iter = container->insert(iter, std::move(__value));
974 ++iter;
975 return *this;
976 }
977 #endif
978
979 /// Simply returns *this.
980 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
981 insert_iterator&
982 operator*()
983 { return *this; }
984
985 /// Simply returns *this. (This %iterator does not @a move.)
986 _GLIBCXX20_CONSTEXPR
987 insert_iterator&
988 operator++()
989 { return *this; }
990
991 /// Simply returns *this. (This %iterator does not @a move.)
992 _GLIBCXX20_CONSTEXPR
993 insert_iterator&
994 operator++(int)
995 { return *this; }
996 };
997
998 #pragma GCC diagnostic pop
999
1000 /**
1001 * @param __x A container of arbitrary type.
1002 * @param __i An iterator into the container.
1003 * @return An instance of insert_iterator working on @p __x.
1004 *
1005 * This wrapper function helps in creating insert_iterator instances.
1006 * Typing the name of the %iterator requires knowing the precise full
1007 * type of the container, which can be tedious and impedes generic
1008 * programming. Using this function lets you take advantage of automatic
1009 * template parameter deduction, making the compiler match the correct
1010 * types for you.
1011 */
1012 #if __cplusplus > 201703L && defined __cpp_lib_concepts
1013 template<typename _Container>
1014 [[nodiscard]]
1015 constexpr insert_iterator<_Container>
1016 inserter(_Container& __x, std::__detail::__range_iter_t<_Container> __i)
1017 { return insert_iterator<_Container>(__x, __i); }
1018 #else
1019 template<typename _Container>
1020 _GLIBCXX_NODISCARD
1021 inline insert_iterator<_Container>
1022 inserter(_Container& __x, typename _Container::iterator __i)
1023 { return insert_iterator<_Container>(__x, __i); }
1024 #endif
1025
1026 /// @} group iterators
1027
1028 _GLIBCXX_END_NAMESPACE_VERSION
1029 } // namespace
1030
1031 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
1032 {
1033 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1034
1035 // This iterator adapter is @a normal in the sense that it does not
1036 // change the semantics of any of the operators of its iterator
1037 // parameter. Its primary purpose is to convert an iterator that is
1038 // not a class, e.g. a pointer, into an iterator that is a class.
1039 // The _Container parameter exists solely so that different containers
1040 // using this template can instantiate different types, even if the
1041 // _Iterator parameter is the same.
1042 template<typename _Iterator, typename _Container>
1043 class __normal_iterator
1044 {
1045 protected:
1046 _Iterator _M_current;
1047
1048 typedef std::iterator_traits<_Iterator> __traits_type;
1049
1050 #if __cplusplus >= 201103L
1051 template<typename _Iter>
1052 using __convertible_from
1053 = std::__enable_if_t<std::is_convertible<_Iter, _Iterator>::value>;
1054 #endif
1055
1056 public:
1057 typedef _Iterator iterator_type;
1058 typedef typename __traits_type::iterator_category iterator_category;
1059 typedef typename __traits_type::value_type value_type;
1060 typedef typename __traits_type::difference_type difference_type;
1061 typedef typename __traits_type::reference reference;
1062 typedef typename __traits_type::pointer pointer;
1063
1064 #if __cplusplus > 201703L && __cpp_lib_concepts
1065 using iterator_concept = std::__detail::__iter_concept<_Iterator>;
1066 #endif
1067
1068 _GLIBCXX_CONSTEXPR __normal_iterator() _GLIBCXX_NOEXCEPT
1069 : _M_current(_Iterator()) { }
1070
1071 explicit _GLIBCXX20_CONSTEXPR
1072 __normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
1073 : _M_current(__i) { }
1074
1075 // Allow iterator to const_iterator conversion
1076 #if __cplusplus >= 201103L
1077 template<typename _Iter, typename = __convertible_from<_Iter>>
1078 _GLIBCXX20_CONSTEXPR
1079 __normal_iterator(const __normal_iterator<_Iter, _Container>& __i)
1080 noexcept
1081 #else
1082 // N.B. _Container::pointer is not actually in container requirements,
1083 // but is present in std::vector and std::basic_string.
1084 template<typename _Iter>
1085 __normal_iterator(const __normal_iterator<_Iter,
1086 typename __enable_if<
1087 (std::__are_same<_Iter, typename _Container::pointer>::__value),
1088 _Container>::__type>& __i)
1089 #endif
1090 : _M_current(__i.base()) { }
1091
1092 // Forward iterator requirements
1093 _GLIBCXX20_CONSTEXPR
1094 reference
1095 operator*() const _GLIBCXX_NOEXCEPT
1096 { return *_M_current; }
1097
1098 _GLIBCXX20_CONSTEXPR
1099 pointer
1100 operator->() const _GLIBCXX_NOEXCEPT
1101 { return _M_current; }
1102
1103 _GLIBCXX20_CONSTEXPR
1104 __normal_iterator&
1105 operator++() _GLIBCXX_NOEXCEPT
1106 {
1107 ++_M_current;
1108 return *this;
1109 }
1110
1111 _GLIBCXX20_CONSTEXPR
1112 __normal_iterator
1113 operator++(int) _GLIBCXX_NOEXCEPT
1114 { return __normal_iterator(_M_current++); }
1115
1116 // Bidirectional iterator requirements
1117 _GLIBCXX20_CONSTEXPR
1118 __normal_iterator&
1119 operator--() _GLIBCXX_NOEXCEPT
1120 {
1121 --_M_current;
1122 return *this;
1123 }
1124
1125 _GLIBCXX20_CONSTEXPR
1126 __normal_iterator
1127 operator--(int) _GLIBCXX_NOEXCEPT
1128 { return __normal_iterator(_M_current--); }
1129
1130 // Random access iterator requirements
1131 _GLIBCXX20_CONSTEXPR
1132 reference
1133 operator[](difference_type __n) const _GLIBCXX_NOEXCEPT
1134 { return _M_current[__n]; }
1135
1136 _GLIBCXX20_CONSTEXPR
1137 __normal_iterator&
1138 operator+=(difference_type __n) _GLIBCXX_NOEXCEPT
1139 { _M_current += __n; return *this; }
1140
1141 _GLIBCXX20_CONSTEXPR
1142 __normal_iterator
1143 operator+(difference_type __n) const _GLIBCXX_NOEXCEPT
1144 { return __normal_iterator(_M_current + __n); }
1145
1146 _GLIBCXX20_CONSTEXPR
1147 __normal_iterator&
1148 operator-=(difference_type __n) _GLIBCXX_NOEXCEPT
1149 { _M_current -= __n; return *this; }
1150
1151 _GLIBCXX20_CONSTEXPR
1152 __normal_iterator
1153 operator-(difference_type __n) const _GLIBCXX_NOEXCEPT
1154 { return __normal_iterator(_M_current - __n); }
1155
1156 _GLIBCXX20_CONSTEXPR
1157 const _Iterator&
1158 base() const _GLIBCXX_NOEXCEPT
1159 { return _M_current; }
1160 };
1161
1162 // Note: In what follows, the left- and right-hand-side iterators are
1163 // allowed to vary in types (conceptually in cv-qualification) so that
1164 // comparison between cv-qualified and non-cv-qualified iterators be
1165 // valid. However, the greedy and unfriendly operators in std::rel_ops
1166 // will make overload resolution ambiguous (when in scope) if we don't
1167 // provide overloads whose operands are of the same type. Can someone
1168 // remind me what generic programming is about? -- Gaby
1169
1170 #if __cpp_lib_three_way_comparison
1171 template<typename _IteratorL, typename _IteratorR, typename _Container>
1172 [[nodiscard]]
1173 constexpr bool
1174 operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
1175 const __normal_iterator<_IteratorR, _Container>& __rhs)
1176 noexcept(noexcept(__lhs.base() == __rhs.base()))
1177 requires requires {
1178 { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
1179 }
1180 { return __lhs.base() == __rhs.base(); }
1181
1182 template<typename _IteratorL, typename _IteratorR, typename _Container>
1183 [[nodiscard]]
1184 constexpr std::__detail::__synth3way_t<_IteratorR, _IteratorL>
1185 operator<=>(const __normal_iterator<_IteratorL, _Container>& __lhs,
1186 const __normal_iterator<_IteratorR, _Container>& __rhs)
1187 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1188 { return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1189
1190 template<typename _Iterator, typename _Container>
1191 [[nodiscard]]
1192 constexpr bool
1193 operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
1194 const __normal_iterator<_Iterator, _Container>& __rhs)
1195 noexcept(noexcept(__lhs.base() == __rhs.base()))
1196 requires requires {
1197 { __lhs.base() == __rhs.base() } -> std::convertible_to<bool>;
1198 }
1199 { return __lhs.base() == __rhs.base(); }
1200
1201 template<typename _Iterator, typename _Container>
1202 [[nodiscard]]
1203 constexpr std::__detail::__synth3way_t<_Iterator>
1204 operator<=>(const __normal_iterator<_Iterator, _Container>& __lhs,
1205 const __normal_iterator<_Iterator, _Container>& __rhs)
1206 noexcept(noexcept(std::__detail::__synth3way(__lhs.base(), __rhs.base())))
1207 { return std::__detail::__synth3way(__lhs.base(), __rhs.base()); }
1208 #else
1209 // Forward iterator requirements
1210 template<typename _IteratorL, typename _IteratorR, typename _Container>
1211 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1212 inline bool
1213 operator==(const __normal_iterator<_IteratorL, _Container>& __lhs,
1214 const __normal_iterator<_IteratorR, _Container>& __rhs)
1215 _GLIBCXX_NOEXCEPT
1216 { return __lhs.base() == __rhs.base(); }
1217
1218 template<typename _Iterator, typename _Container>
1219 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1220 inline bool
1221 operator==(const __normal_iterator<_Iterator, _Container>& __lhs,
1222 const __normal_iterator<_Iterator, _Container>& __rhs)
1223 _GLIBCXX_NOEXCEPT
1224 { return __lhs.base() == __rhs.base(); }
1225
1226 template<typename _IteratorL, typename _IteratorR, typename _Container>
1227 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1228 inline bool
1229 operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs,
1230 const __normal_iterator<_IteratorR, _Container>& __rhs)
1231 _GLIBCXX_NOEXCEPT
1232 { return __lhs.base() != __rhs.base(); }
1233
1234 template<typename _Iterator, typename _Container>
1235 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1236 inline bool
1237 operator!=(const __normal_iterator<_Iterator, _Container>& __lhs,
1238 const __normal_iterator<_Iterator, _Container>& __rhs)
1239 _GLIBCXX_NOEXCEPT
1240 { return __lhs.base() != __rhs.base(); }
1241
1242 // Random access iterator requirements
1243 template<typename _IteratorL, typename _IteratorR, typename _Container>
1244 _GLIBCXX_NODISCARD
1245 inline bool
1246 operator<(const __normal_iterator<_IteratorL, _Container>& __lhs,
1247 const __normal_iterator<_IteratorR, _Container>& __rhs)
1248 _GLIBCXX_NOEXCEPT
1249 { return __lhs.base() < __rhs.base(); }
1250
1251 template<typename _Iterator, typename _Container>
1252 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1253 inline bool
1254 operator<(const __normal_iterator<_Iterator, _Container>& __lhs,
1255 const __normal_iterator<_Iterator, _Container>& __rhs)
1256 _GLIBCXX_NOEXCEPT
1257 { return __lhs.base() < __rhs.base(); }
1258
1259 template<typename _IteratorL, typename _IteratorR, typename _Container>
1260 _GLIBCXX_NODISCARD
1261 inline bool
1262 operator>(const __normal_iterator<_IteratorL, _Container>& __lhs,
1263 const __normal_iterator<_IteratorR, _Container>& __rhs)
1264 _GLIBCXX_NOEXCEPT
1265 { return __lhs.base() > __rhs.base(); }
1266
1267 template<typename _Iterator, typename _Container>
1268 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1269 inline bool
1270 operator>(const __normal_iterator<_Iterator, _Container>& __lhs,
1271 const __normal_iterator<_Iterator, _Container>& __rhs)
1272 _GLIBCXX_NOEXCEPT
1273 { return __lhs.base() > __rhs.base(); }
1274
1275 template<typename _IteratorL, typename _IteratorR, typename _Container>
1276 _GLIBCXX_NODISCARD
1277 inline bool
1278 operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs,
1279 const __normal_iterator<_IteratorR, _Container>& __rhs)
1280 _GLIBCXX_NOEXCEPT
1281 { return __lhs.base() <= __rhs.base(); }
1282
1283 template<typename _Iterator, typename _Container>
1284 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1285 inline bool
1286 operator<=(const __normal_iterator<_Iterator, _Container>& __lhs,
1287 const __normal_iterator<_Iterator, _Container>& __rhs)
1288 _GLIBCXX_NOEXCEPT
1289 { return __lhs.base() <= __rhs.base(); }
1290
1291 template<typename _IteratorL, typename _IteratorR, typename _Container>
1292 _GLIBCXX_NODISCARD
1293 inline bool
1294 operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs,
1295 const __normal_iterator<_IteratorR, _Container>& __rhs)
1296 _GLIBCXX_NOEXCEPT
1297 { return __lhs.base() >= __rhs.base(); }
1298
1299 template<typename _Iterator, typename _Container>
1300 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1301 inline bool
1302 operator>=(const __normal_iterator<_Iterator, _Container>& __lhs,
1303 const __normal_iterator<_Iterator, _Container>& __rhs)
1304 _GLIBCXX_NOEXCEPT
1305 { return __lhs.base() >= __rhs.base(); }
1306 #endif // three-way comparison
1307
1308 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1309 // According to the resolution of DR179 not only the various comparison
1310 // operators but also operator- must accept mixed iterator/const_iterator
1311 // parameters.
1312 template<typename _IteratorL, typename _IteratorR, typename _Container>
1313 #if __cplusplus >= 201103L
1314 // DR 685.
1315 [[__nodiscard__]] _GLIBCXX20_CONSTEXPR
1316 inline auto
1317 operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
1318 const __normal_iterator<_IteratorR, _Container>& __rhs) noexcept
1319 -> decltype(__lhs.base() - __rhs.base())
1320 #else
1321 inline typename __normal_iterator<_IteratorL, _Container>::difference_type
1322 operator-(const __normal_iterator<_IteratorL, _Container>& __lhs,
1323 const __normal_iterator<_IteratorR, _Container>& __rhs)
1324 #endif
1325 { return __lhs.base() - __rhs.base(); }
1326
1327 template<typename _Iterator, typename _Container>
1328 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1329 inline typename __normal_iterator<_Iterator, _Container>::difference_type
1330 operator-(const __normal_iterator<_Iterator, _Container>& __lhs,
1331 const __normal_iterator<_Iterator, _Container>& __rhs)
1332 _GLIBCXX_NOEXCEPT
1333 { return __lhs.base() - __rhs.base(); }
1334
1335 template<typename _Iterator, typename _Container>
1336 _GLIBCXX_NODISCARD _GLIBCXX20_CONSTEXPR
1337 inline __normal_iterator<_Iterator, _Container>
1338 operator+(typename __normal_iterator<_Iterator, _Container>::difference_type
1339 __n, const __normal_iterator<_Iterator, _Container>& __i)
1340 _GLIBCXX_NOEXCEPT
1341 { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); }
1342
1343 _GLIBCXX_END_NAMESPACE_VERSION
1344 } // namespace
1345
1346 namespace std _GLIBCXX_VISIBILITY(default)
1347 {
1348 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1349
1350 template<typename _Iterator, typename _Container>
1351 _GLIBCXX20_CONSTEXPR
1352 _Iterator
1353 __niter_base(__gnu_cxx::__normal_iterator<_Iterator, _Container> __it)
1354 _GLIBCXX_NOEXCEPT_IF(std::is_nothrow_copy_constructible<_Iterator>::value)
1355 { return __it.base(); }
1356
1357 #if __cplusplus >= 201103L
1358
1359 #if __cplusplus <= 201703L
1360 // Need to overload __to_address because the pointer_traits primary template
1361 // will deduce element_type of __normal_iterator<T*, C> as T* rather than T.
1362 template<typename _Iterator, typename _Container>
1363 constexpr auto
1364 __to_address(const __gnu_cxx::__normal_iterator<_Iterator,
1365 _Container>& __it) noexcept
1366 -> decltype(std::__to_address(__it.base()))
1367 { return std::__to_address(__it.base()); }
1368 #endif
1369
1370 /**
1371 * @addtogroup iterators
1372 * @{
1373 */
1374
1375 #if __cplusplus > 201703L && __cpp_lib_concepts
1376 template<semiregular _Sent>
1377 class move_sentinel
1378 {
1379 public:
1380 constexpr
1381 move_sentinel()
1382 noexcept(is_nothrow_default_constructible_v<_Sent>)
1383 : _M_last() { }
1384
1385 constexpr explicit
1386 move_sentinel(_Sent __s)
1387 noexcept(is_nothrow_move_constructible_v<_Sent>)
1388 : _M_last(std::move(__s)) { }
1389
1390 template<typename _S2> requires convertible_to<const _S2&, _Sent>
1391 constexpr
1392 move_sentinel(const move_sentinel<_S2>& __s)
1393 noexcept(is_nothrow_constructible_v<_Sent, const _S2&>)
1394 : _M_last(__s.base())
1395 { }
1396
1397 template<typename _S2> requires assignable_from<_Sent&, const _S2&>
1398 constexpr move_sentinel&
1399 operator=(const move_sentinel<_S2>& __s)
1400 noexcept(is_nothrow_assignable_v<_Sent, const _S2&>)
1401 {
1402 _M_last = __s.base();
1403 return *this;
1404 }
1405
1406 [[nodiscard]]
1407 constexpr _Sent
1408 base() const
1409 noexcept(is_nothrow_copy_constructible_v<_Sent>)
1410 { return _M_last; }
1411
1412 private:
1413 _Sent _M_last;
1414 };
1415 #endif // C++20
1416
1417 namespace __detail
1418 {
1419 #if __cplusplus > 201703L && __cpp_lib_concepts
1420 template<typename _Iterator>
1421 struct __move_iter_cat
1422 { };
1423
1424 template<typename _Iterator>
1425 requires requires { typename iterator_traits<_Iterator>::iterator_category; }
1426 struct __move_iter_cat<_Iterator>
1427 {
1428 using iterator_category
1429 = __clamp_iter_cat<typename iterator_traits<_Iterator>::iterator_category,
1430 random_access_iterator_tag>;
1431 };
1432 #endif
1433 }
1434
1435 // 24.4.3 Move iterators
1436 /**
1437 * Class template move_iterator is an iterator adapter with the same
1438 * behavior as the underlying iterator except that its dereference
1439 * operator implicitly converts the value returned by the underlying
1440 * iterator's dereference operator to an rvalue reference. Some
1441 * generic algorithms can be called with move iterators to replace
1442 * copying with moving.
1443 */
1444 template<typename _Iterator>
1445 class move_iterator
1446 #if __cplusplus > 201703L && __cpp_lib_concepts
1447 : public __detail::__move_iter_cat<_Iterator>
1448 #endif
1449 {
1450 _Iterator _M_current;
1451
1452 using __traits_type = iterator_traits<_Iterator>;
1453 #if ! (__cplusplus > 201703L && __cpp_lib_concepts)
1454 using __base_ref = typename __traits_type::reference;
1455 #endif
1456
1457 template<typename _Iter2>
1458 friend class move_iterator;
1459
1460 #if __cpp_lib_concepts
1461 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1462 // 3435. three_way_comparable_with<reverse_iterator<int*>, [...]>
1463 template<typename _Iter2>
1464 static constexpr bool __convertible = !is_same_v<_Iter2, _Iterator>
1465 && convertible_to<const _Iter2&, _Iterator>;
1466 #endif
1467
1468 #if __cplusplus > 201703L && __cpp_lib_concepts
1469 static auto
1470 _S_iter_concept()
1471 {
1472 if constexpr (random_access_iterator<_Iterator>)
1473 return random_access_iterator_tag{};
1474 else if constexpr (bidirectional_iterator<_Iterator>)
1475 return bidirectional_iterator_tag{};
1476 else if constexpr (forward_iterator<_Iterator>)
1477 return forward_iterator_tag{};
1478 else
1479 return input_iterator_tag{};
1480 }
1481 #endif
1482
1483 public:
1484 using iterator_type = _Iterator;
1485
1486 #if __cplusplus > 201703L && __cpp_lib_concepts
1487 // This is P2520R0, a C++23 change, but we treat it as a DR against C++20.
1488 # define __cpp_lib_move_iterator_concept 202207L
1489 using iterator_concept = decltype(_S_iter_concept());
1490
1491 // iterator_category defined in __move_iter_cat
1492 using value_type = iter_value_t<_Iterator>;
1493 using difference_type = iter_difference_t<_Iterator>;
1494 using pointer = _Iterator;
1495 using reference = iter_rvalue_reference_t<_Iterator>;
1496 #else
1497 typedef typename __traits_type::iterator_category iterator_category;
1498 typedef typename __traits_type::value_type value_type;
1499 typedef typename __traits_type::difference_type difference_type;
1500 // NB: DR 680.
1501 typedef _Iterator pointer;
1502 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1503 // 2106. move_iterator wrapping iterators returning prvalues
1504 using reference
1505 = __conditional_t<is_reference<__base_ref>::value,
1506 typename remove_reference<__base_ref>::type&&,
1507 __base_ref>;
1508 #endif
1509
1510 _GLIBCXX17_CONSTEXPR
1511 move_iterator()
1512 : _M_current() { }
1513
1514 explicit _GLIBCXX17_CONSTEXPR
1515 move_iterator(iterator_type __i)
1516 : _M_current(std::move(__i)) { }
1517
1518 template<typename _Iter>
1519 #if __cpp_lib_concepts
1520 requires __convertible<_Iter>
1521 #endif
1522 _GLIBCXX17_CONSTEXPR
1523 move_iterator(const move_iterator<_Iter>& __i)
1524 : _M_current(__i._M_current) { }
1525
1526 template<typename _Iter>
1527 #if __cpp_lib_concepts
1528 requires __convertible<_Iter>
1529 && assignable_from<_Iterator&, const _Iter&>
1530 #endif
1531 _GLIBCXX17_CONSTEXPR
1532 move_iterator& operator=(const move_iterator<_Iter>& __i)
1533 {
1534 _M_current = __i._M_current;
1535 return *this;
1536 }
1537
1538 #if __cplusplus <= 201703L
1539 [[__nodiscard__]]
1540 _GLIBCXX17_CONSTEXPR iterator_type
1541 base() const
1542 { return _M_current; }
1543 #else
1544 [[nodiscard]]
1545 constexpr const iterator_type&
1546 base() const & noexcept
1547 { return _M_current; }
1548
1549 [[nodiscard]]
1550 constexpr iterator_type
1551 base() &&
1552 { return std::move(_M_current); }
1553 #endif
1554
1555 [[__nodiscard__]]
1556 _GLIBCXX17_CONSTEXPR reference
1557 operator*() const
1558 #if __cplusplus > 201703L && __cpp_lib_concepts
1559 { return ranges::iter_move(_M_current); }
1560 #else
1561 { return static_cast<reference>(*_M_current); }
1562 #endif
1563
1564 [[__nodiscard__]]
1565 _GLIBCXX17_CONSTEXPR pointer
1566 operator->() const
1567 { return _M_current; }
1568
1569 _GLIBCXX17_CONSTEXPR move_iterator&
1570 operator++()
1571 {
1572 ++_M_current;
1573 return *this;
1574 }
1575
1576 _GLIBCXX17_CONSTEXPR move_iterator
1577 operator++(int)
1578 {
1579 move_iterator __tmp = *this;
1580 ++_M_current;
1581 return __tmp;
1582 }
1583
1584 #if __cpp_lib_concepts
1585 constexpr void
1586 operator++(int) requires (!forward_iterator<_Iterator>)
1587 { ++_M_current; }
1588 #endif
1589
1590 _GLIBCXX17_CONSTEXPR move_iterator&
1591 operator--()
1592 {
1593 --_M_current;
1594 return *this;
1595 }
1596
1597 _GLIBCXX17_CONSTEXPR move_iterator
1598 operator--(int)
1599 {
1600 move_iterator __tmp = *this;
1601 --_M_current;
1602 return __tmp;
1603 }
1604
1605 [[__nodiscard__]]
1606 _GLIBCXX17_CONSTEXPR move_iterator
1607 operator+(difference_type __n) const
1608 { return move_iterator(_M_current + __n); }
1609
1610 _GLIBCXX17_CONSTEXPR move_iterator&
1611 operator+=(difference_type __n)
1612 {
1613 _M_current += __n;
1614 return *this;
1615 }
1616
1617 [[__nodiscard__]]
1618 _GLIBCXX17_CONSTEXPR move_iterator
1619 operator-(difference_type __n) const
1620 { return move_iterator(_M_current - __n); }
1621
1622 _GLIBCXX17_CONSTEXPR move_iterator&
1623 operator-=(difference_type __n)
1624 {
1625 _M_current -= __n;
1626 return *this;
1627 }
1628
1629 [[__nodiscard__]]
1630 _GLIBCXX17_CONSTEXPR reference
1631 operator[](difference_type __n) const
1632 #if __cplusplus > 201703L && __cpp_lib_concepts
1633 { return ranges::iter_move(_M_current + __n); }
1634 #else
1635 { return std::move(_M_current[__n]); }
1636 #endif
1637
1638 #if __cplusplus > 201703L && __cpp_lib_concepts
1639 template<sentinel_for<_Iterator> _Sent>
1640 [[nodiscard]]
1641 friend constexpr bool
1642 operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
1643 { return __x.base() == __y.base(); }
1644
1645 template<sized_sentinel_for<_Iterator> _Sent>
1646 [[nodiscard]]
1647 friend constexpr iter_difference_t<_Iterator>
1648 operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y)
1649 { return __x.base() - __y.base(); }
1650
1651 template<sized_sentinel_for<_Iterator> _Sent>
1652 [[nodiscard]]
1653 friend constexpr iter_difference_t<_Iterator>
1654 operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y)
1655 { return __x.base() - __y.base(); }
1656
1657 [[nodiscard]]
1658 friend constexpr iter_rvalue_reference_t<_Iterator>
1659 iter_move(const move_iterator& __i)
1660 noexcept(noexcept(ranges::iter_move(__i._M_current)))
1661 { return ranges::iter_move(__i._M_current); }
1662
1663 template<indirectly_swappable<_Iterator> _Iter2>
1664 friend constexpr void
1665 iter_swap(const move_iterator& __x, const move_iterator<_Iter2>& __y)
1666 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
1667 { return ranges::iter_swap(__x._M_current, __y._M_current); }
1668 #endif // C++20
1669 };
1670
1671 template<typename _IteratorL, typename _IteratorR>
1672 [[__nodiscard__]]
1673 inline _GLIBCXX17_CONSTEXPR bool
1674 operator==(const move_iterator<_IteratorL>& __x,
1675 const move_iterator<_IteratorR>& __y)
1676 #if __cplusplus > 201703L && __cpp_lib_concepts
1677 requires requires { { __x.base() == __y.base() } -> convertible_to<bool>; }
1678 #endif
1679 { return __x.base() == __y.base(); }
1680
1681 #if __cpp_lib_three_way_comparison
1682 template<typename _IteratorL,
1683 three_way_comparable_with<_IteratorL> _IteratorR>
1684 [[__nodiscard__]]
1685 constexpr compare_three_way_result_t<_IteratorL, _IteratorR>
1686 operator<=>(const move_iterator<_IteratorL>& __x,
1687 const move_iterator<_IteratorR>& __y)
1688 { return __x.base() <=> __y.base(); }
1689 #else
1690 template<typename _IteratorL, typename _IteratorR>
1691 [[__nodiscard__]]
1692 inline _GLIBCXX17_CONSTEXPR bool
1693 operator!=(const move_iterator<_IteratorL>& __x,
1694 const move_iterator<_IteratorR>& __y)
1695 { return !(__x == __y); }
1696 #endif
1697
1698 template<typename _IteratorL, typename _IteratorR>
1699 [[__nodiscard__]]
1700 inline _GLIBCXX17_CONSTEXPR bool
1701 operator<(const move_iterator<_IteratorL>& __x,
1702 const move_iterator<_IteratorR>& __y)
1703 #if __cplusplus > 201703L && __cpp_lib_concepts
1704 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1705 #endif
1706 { return __x.base() < __y.base(); }
1707
1708 template<typename _IteratorL, typename _IteratorR>
1709 [[__nodiscard__]]
1710 inline _GLIBCXX17_CONSTEXPR bool
1711 operator<=(const move_iterator<_IteratorL>& __x,
1712 const move_iterator<_IteratorR>& __y)
1713 #if __cplusplus > 201703L && __cpp_lib_concepts
1714 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1715 #endif
1716 { return !(__y < __x); }
1717
1718 template<typename _IteratorL, typename _IteratorR>
1719 [[__nodiscard__]]
1720 inline _GLIBCXX17_CONSTEXPR bool
1721 operator>(const move_iterator<_IteratorL>& __x,
1722 const move_iterator<_IteratorR>& __y)
1723 #if __cplusplus > 201703L && __cpp_lib_concepts
1724 requires requires { { __y.base() < __x.base() } -> convertible_to<bool>; }
1725 #endif
1726 { return __y < __x; }
1727
1728 template<typename _IteratorL, typename _IteratorR>
1729 [[__nodiscard__]]
1730 inline _GLIBCXX17_CONSTEXPR bool
1731 operator>=(const move_iterator<_IteratorL>& __x,
1732 const move_iterator<_IteratorR>& __y)
1733 #if __cplusplus > 201703L && __cpp_lib_concepts
1734 requires requires { { __x.base() < __y.base() } -> convertible_to<bool>; }
1735 #endif
1736 { return !(__x < __y); }
1737
1738 // Note: See __normal_iterator operators note from Gaby to understand
1739 // why we have these extra overloads for some move_iterator operators.
1740
1741 template<typename _Iterator>
1742 [[__nodiscard__]]
1743 inline _GLIBCXX17_CONSTEXPR bool
1744 operator==(const move_iterator<_Iterator>& __x,
1745 const move_iterator<_Iterator>& __y)
1746 { return __x.base() == __y.base(); }
1747
1748 #if __cpp_lib_three_way_comparison
1749 template<three_way_comparable _Iterator>
1750 [[__nodiscard__]]
1751 constexpr compare_three_way_result_t<_Iterator>
1752 operator<=>(const move_iterator<_Iterator>& __x,
1753 const move_iterator<_Iterator>& __y)
1754 { return __x.base() <=> __y.base(); }
1755 #else
1756 template<typename _Iterator>
1757 [[__nodiscard__]]
1758 inline _GLIBCXX17_CONSTEXPR bool
1759 operator!=(const move_iterator<_Iterator>& __x,
1760 const move_iterator<_Iterator>& __y)
1761 { return !(__x == __y); }
1762
1763 template<typename _Iterator>
1764 [[__nodiscard__]]
1765 inline _GLIBCXX17_CONSTEXPR bool
1766 operator<(const move_iterator<_Iterator>& __x,
1767 const move_iterator<_Iterator>& __y)
1768 { return __x.base() < __y.base(); }
1769
1770 template<typename _Iterator>
1771 [[__nodiscard__]]
1772 inline _GLIBCXX17_CONSTEXPR bool
1773 operator<=(const move_iterator<_Iterator>& __x,
1774 const move_iterator<_Iterator>& __y)
1775 { return !(__y < __x); }
1776
1777 template<typename _Iterator>
1778 [[__nodiscard__]]
1779 inline _GLIBCXX17_CONSTEXPR bool
1780 operator>(const move_iterator<_Iterator>& __x,
1781 const move_iterator<_Iterator>& __y)
1782 { return __y < __x; }
1783
1784 template<typename _Iterator>
1785 [[__nodiscard__]]
1786 inline _GLIBCXX17_CONSTEXPR bool
1787 operator>=(const move_iterator<_Iterator>& __x,
1788 const move_iterator<_Iterator>& __y)
1789 { return !(__x < __y); }
1790 #endif // ! C++20
1791
1792 // DR 685.
1793 template<typename _IteratorL, typename _IteratorR>
1794 [[__nodiscard__]]
1795 inline _GLIBCXX17_CONSTEXPR auto
1796 operator-(const move_iterator<_IteratorL>& __x,
1797 const move_iterator<_IteratorR>& __y)
1798 -> decltype(__x.base() - __y.base())
1799 { return __x.base() - __y.base(); }
1800
1801 template<typename _Iterator>
1802 [[__nodiscard__]]
1803 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1804 operator+(typename move_iterator<_Iterator>::difference_type __n,
1805 const move_iterator<_Iterator>& __x)
1806 { return __x + __n; }
1807
1808 template<typename _Iterator>
1809 [[__nodiscard__]]
1810 inline _GLIBCXX17_CONSTEXPR move_iterator<_Iterator>
1811 make_move_iterator(_Iterator __i)
1812 { return move_iterator<_Iterator>(std::move(__i)); }
1813
1814 template<typename _Iterator, typename _ReturnType
1815 = __conditional_t<__move_if_noexcept_cond
1816 <typename iterator_traits<_Iterator>::value_type>::value,
1817 _Iterator, move_iterator<_Iterator>>>
1818 inline _GLIBCXX17_CONSTEXPR _ReturnType
1819 __make_move_if_noexcept_iterator(_Iterator __i)
1820 { return _ReturnType(__i); }
1821
1822 // Overload for pointers that matches std::move_if_noexcept more closely,
1823 // returning a constant iterator when we don't want to move.
1824 template<typename _Tp, typename _ReturnType
1825 = __conditional_t<__move_if_noexcept_cond<_Tp>::value,
1826 const _Tp*, move_iterator<_Tp*>>>
1827 inline _GLIBCXX17_CONSTEXPR _ReturnType
1828 __make_move_if_noexcept_iterator(_Tp* __i)
1829 { return _ReturnType(__i); }
1830
1831 #if __cplusplus > 201703L && __cpp_lib_concepts
1832 // [iterators.common] Common iterators
1833
1834 namespace __detail
1835 {
1836 template<typename _It>
1837 concept __common_iter_has_arrow = indirectly_readable<const _It>
1838 && (requires(const _It& __it) { __it.operator->(); }
1839 || is_reference_v<iter_reference_t<_It>>
1840 || constructible_from<iter_value_t<_It>, iter_reference_t<_It>>);
1841
1842 template<typename _It>
1843 concept __common_iter_use_postfix_proxy
1844 = (!requires (_It& __i) { { *__i++ } -> __can_reference; })
1845 && constructible_from<iter_value_t<_It>, iter_reference_t<_It>>
1846 && move_constructible<iter_value_t<_It>>;
1847 } // namespace __detail
1848
1849 /// An iterator/sentinel adaptor for representing a non-common range.
1850 template<input_or_output_iterator _It, sentinel_for<_It> _Sent>
1851 requires (!same_as<_It, _Sent>) && copyable<_It>
1852 class common_iterator
1853 {
1854 template<typename _Tp, typename _Up>
1855 static constexpr bool
1856 _S_noexcept1()
1857 {
1858 if constexpr (is_trivially_default_constructible_v<_Tp>)
1859 return is_nothrow_assignable_v<_Tp&, _Up>;
1860 else
1861 return is_nothrow_constructible_v<_Tp, _Up>;
1862 }
1863
1864 template<typename _It2, typename _Sent2>
1865 static constexpr bool
1866 _S_noexcept()
1867 { return _S_noexcept1<_It, _It2>() && _S_noexcept1<_Sent, _Sent2>(); }
1868
1869 class __arrow_proxy
1870 {
1871 iter_value_t<_It> _M_keep;
1872
1873 constexpr
1874 __arrow_proxy(iter_reference_t<_It>&& __x)
1875 : _M_keep(std::move(__x)) { }
1876
1877 friend class common_iterator;
1878
1879 public:
1880 constexpr const iter_value_t<_It>*
1881 operator->() const noexcept
1882 { return std::__addressof(_M_keep); }
1883 };
1884
1885 class __postfix_proxy
1886 {
1887 iter_value_t<_It> _M_keep;
1888
1889 constexpr
1890 __postfix_proxy(iter_reference_t<_It>&& __x)
1891 : _M_keep(std::forward<iter_reference_t<_It>>(__x)) { }
1892
1893 friend class common_iterator;
1894
1895 public:
1896 constexpr const iter_value_t<_It>&
1897 operator*() const noexcept
1898 { return _M_keep; }
1899 };
1900
1901 public:
1902 constexpr
1903 common_iterator()
1904 noexcept(is_nothrow_default_constructible_v<_It>)
1905 requires default_initializable<_It>
1906 : _M_it(), _M_index(0)
1907 { }
1908
1909 constexpr
1910 common_iterator(_It __i)
1911 noexcept(is_nothrow_move_constructible_v<_It>)
1912 : _M_it(std::move(__i)), _M_index(0)
1913 { }
1914
1915 constexpr
1916 common_iterator(_Sent __s)
1917 noexcept(is_nothrow_move_constructible_v<_Sent>)
1918 : _M_sent(std::move(__s)), _M_index(1)
1919 { }
1920
1921 template<typename _It2, typename _Sent2>
1922 requires convertible_to<const _It2&, _It>
1923 && convertible_to<const _Sent2&, _Sent>
1924 constexpr
1925 common_iterator(const common_iterator<_It2, _Sent2>& __x)
1926 noexcept(_S_noexcept<const _It2&, const _Sent2&>())
1927 : _M_valueless(), _M_index(__x._M_index)
1928 {
1929 __glibcxx_assert(__x._M_has_value());
1930 if (_M_index == 0)
1931 {
1932 if constexpr (is_trivially_default_constructible_v<_It>)
1933 _M_it = std::move(__x._M_it);
1934 else
1935 std::construct_at(std::__addressof(_M_it), __x._M_it);
1936 }
1937 else if (_M_index == 1)
1938 {
1939 if constexpr (is_trivially_default_constructible_v<_Sent>)
1940 _M_sent = std::move(__x._M_sent);
1941 else
1942 std::construct_at(std::__addressof(_M_sent), __x._M_sent);
1943 }
1944 }
1945
1946 constexpr
1947 common_iterator(const common_iterator& __x)
1948 noexcept(_S_noexcept<const _It&, const _Sent&>())
1949 : _M_valueless(), _M_index(__x._M_index)
1950 {
1951 if (_M_index == 0)
1952 {
1953 if constexpr (is_trivially_default_constructible_v<_It>)
1954 _M_it = __x._M_it;
1955 else
1956 std::construct_at(std::__addressof(_M_it), __x._M_it);
1957 }
1958 else if (_M_index == 1)
1959 {
1960 if constexpr (is_trivially_default_constructible_v<_Sent>)
1961 _M_sent = __x._M_sent;
1962 else
1963 std::construct_at(std::__addressof(_M_sent), __x._M_sent);
1964 }
1965 }
1966
1967 constexpr
1968 common_iterator(common_iterator&& __x)
1969 noexcept(_S_noexcept<_It, _Sent>())
1970 : _M_valueless(), _M_index(__x._M_index)
1971 {
1972 if (_M_index == 0)
1973 {
1974 if constexpr (is_trivially_default_constructible_v<_It>)
1975 _M_it = std::move(__x._M_it);
1976 else
1977 std::construct_at(std::__addressof(_M_it), std::move(__x._M_it));
1978 }
1979 else if (_M_index == 1)
1980 {
1981 if constexpr (is_trivially_default_constructible_v<_Sent>)
1982 _M_sent = std::move(__x._M_sent);
1983 else
1984 std::construct_at(std::__addressof(_M_sent),
1985 std::move(__x._M_sent));
1986 }
1987 }
1988
1989 constexpr common_iterator&
1990 operator=(const common_iterator&) = default;
1991
1992 constexpr common_iterator&
1993 operator=(const common_iterator& __x)
1994 noexcept(is_nothrow_copy_assignable_v<_It>
1995 && is_nothrow_copy_assignable_v<_Sent>
1996 && is_nothrow_copy_constructible_v<_It>
1997 && is_nothrow_copy_constructible_v<_Sent>)
1998 requires (!is_trivially_copy_assignable_v<_It>
1999 || !is_trivially_copy_assignable_v<_Sent>)
2000 {
2001 _M_assign(__x);
2002 return *this;
2003 }
2004
2005 constexpr common_iterator&
2006 operator=(common_iterator&&) = default;
2007
2008 constexpr common_iterator&
2009 operator=(common_iterator&& __x)
2010 noexcept(is_nothrow_move_assignable_v<_It>
2011 && is_nothrow_move_assignable_v<_Sent>
2012 && is_nothrow_move_constructible_v<_It>
2013 && is_nothrow_move_constructible_v<_Sent>)
2014 requires (!is_trivially_move_assignable_v<_It>
2015 || !is_trivially_move_assignable_v<_Sent>)
2016 {
2017 _M_assign(std::move(__x));
2018 return *this;
2019 }
2020
2021 template<typename _It2, typename _Sent2>
2022 requires convertible_to<const _It2&, _It>
2023 && convertible_to<const _Sent2&, _Sent>
2024 && assignable_from<_It&, const _It2&>
2025 && assignable_from<_Sent&, const _Sent2&>
2026 constexpr common_iterator&
2027 operator=(const common_iterator<_It2, _Sent2>& __x)
2028 noexcept(is_nothrow_constructible_v<_It, const _It2&>
2029 && is_nothrow_constructible_v<_Sent, const _Sent2&>
2030 && is_nothrow_assignable_v<_It&, const _It2&>
2031 && is_nothrow_assignable_v<_Sent&, const _Sent2&>)
2032 {
2033 __glibcxx_assert(__x._M_has_value());
2034 _M_assign(__x);
2035 return *this;
2036 }
2037
2038 constexpr
2039 ~common_iterator()
2040 {
2041 if (_M_index == 0)
2042 _M_it.~_It();
2043 else if (_M_index == 1)
2044 _M_sent.~_Sent();
2045 }
2046
2047 [[nodiscard]]
2048 constexpr decltype(auto)
2049 operator*()
2050 {
2051 __glibcxx_assert(_M_index == 0);
2052 return *_M_it;
2053 }
2054
2055 [[nodiscard]]
2056 constexpr decltype(auto)
2057 operator*() const requires __detail::__dereferenceable<const _It>
2058 {
2059 __glibcxx_assert(_M_index == 0);
2060 return *_M_it;
2061 }
2062
2063 [[nodiscard]]
2064 constexpr auto
2065 operator->() const requires __detail::__common_iter_has_arrow<_It>
2066 {
2067 __glibcxx_assert(_M_index == 0);
2068 if constexpr (is_pointer_v<_It> || requires { _M_it.operator->(); })
2069 return _M_it;
2070 else if constexpr (is_reference_v<iter_reference_t<_It>>)
2071 {
2072 auto&& __tmp = *_M_it;
2073 return std::__addressof(__tmp);
2074 }
2075 else
2076 return __arrow_proxy{*_M_it};
2077 }
2078
2079 constexpr common_iterator&
2080 operator++()
2081 {
2082 __glibcxx_assert(_M_index == 0);
2083 ++_M_it;
2084 return *this;
2085 }
2086
2087 constexpr decltype(auto)
2088 operator++(int)
2089 {
2090 __glibcxx_assert(_M_index == 0);
2091 if constexpr (forward_iterator<_It>)
2092 {
2093 common_iterator __tmp = *this;
2094 ++*this;
2095 return __tmp;
2096 }
2097 else if constexpr (!__detail::__common_iter_use_postfix_proxy<_It>)
2098 return _M_it++;
2099 else
2100 {
2101 __postfix_proxy __p(**this);
2102 ++*this;
2103 return __p;
2104 }
2105 }
2106
2107 template<typename _It2, sentinel_for<_It> _Sent2>
2108 requires sentinel_for<_Sent, _It2>
2109 friend constexpr bool
2110 operator== [[nodiscard]] (const common_iterator& __x,
2111 const common_iterator<_It2, _Sent2>& __y)
2112 {
2113 switch(__x._M_index << 2 | __y._M_index)
2114 {
2115 case 0b0000:
2116 case 0b0101:
2117 return true;
2118 case 0b0001:
2119 return __x._M_it == __y._M_sent;
2120 case 0b0100:
2121 return __x._M_sent == __y._M_it;
2122 default:
2123 __glibcxx_assert(__x._M_has_value());
2124 __glibcxx_assert(__y._M_has_value());
2125 __builtin_unreachable();
2126 }
2127 }
2128
2129 template<typename _It2, sentinel_for<_It> _Sent2>
2130 requires sentinel_for<_Sent, _It2> && equality_comparable_with<_It, _It2>
2131 friend constexpr bool
2132 operator== [[nodiscard]] (const common_iterator& __x,
2133 const common_iterator<_It2, _Sent2>& __y)
2134 {
2135 switch(__x._M_index << 2 | __y._M_index)
2136 {
2137 case 0b0101:
2138 return true;
2139 case 0b0000:
2140 return __x._M_it == __y._M_it;
2141 case 0b0001:
2142 return __x._M_it == __y._M_sent;
2143 case 0b0100:
2144 return __x._M_sent == __y._M_it;
2145 default:
2146 __glibcxx_assert(__x._M_has_value());
2147 __glibcxx_assert(__y._M_has_value());
2148 __builtin_unreachable();
2149 }
2150 }
2151
2152 template<sized_sentinel_for<_It> _It2, sized_sentinel_for<_It> _Sent2>
2153 requires sized_sentinel_for<_Sent, _It2>
2154 friend constexpr iter_difference_t<_It2>
2155 operator- [[nodiscard]] (const common_iterator& __x,
2156 const common_iterator<_It2, _Sent2>& __y)
2157 {
2158 switch(__x._M_index << 2 | __y._M_index)
2159 {
2160 case 0b0101:
2161 return 0;
2162 case 0b0000:
2163 return __x._M_it - __y._M_it;
2164 case 0b0001:
2165 return __x._M_it - __y._M_sent;
2166 case 0b0100:
2167 return __x._M_sent - __y._M_it;
2168 default:
2169 __glibcxx_assert(__x._M_has_value());
2170 __glibcxx_assert(__y._M_has_value());
2171 __builtin_unreachable();
2172 }
2173 }
2174
2175 [[nodiscard]]
2176 friend constexpr iter_rvalue_reference_t<_It>
2177 iter_move(const common_iterator& __i)
2178 noexcept(noexcept(ranges::iter_move(std::declval<const _It&>())))
2179 requires input_iterator<_It>
2180 {
2181 __glibcxx_assert(__i._M_index == 0);
2182 return ranges::iter_move(__i._M_it);
2183 }
2184
2185 template<indirectly_swappable<_It> _It2, typename _Sent2>
2186 friend constexpr void
2187 iter_swap(const common_iterator& __x,
2188 const common_iterator<_It2, _Sent2>& __y)
2189 noexcept(noexcept(ranges::iter_swap(std::declval<const _It&>(),
2190 std::declval<const _It2&>())))
2191 {
2192 __glibcxx_assert(__x._M_index == 0);
2193 __glibcxx_assert(__y._M_index == 0);
2194 return ranges::iter_swap(__x._M_it, __y._M_it);
2195 }
2196
2197 private:
2198 template<input_or_output_iterator _It2, sentinel_for<_It2> _Sent2>
2199 requires (!same_as<_It2, _Sent2>) && copyable<_It2>
2200 friend class common_iterator;
2201
2202 constexpr bool
2203 _M_has_value() const noexcept { return _M_index != _S_valueless; }
2204
2205 template<typename _CIt>
2206 constexpr void
2207 _M_assign(_CIt&& __x)
2208 {
2209 if (_M_index == __x._M_index)
2210 {
2211 if (_M_index == 0)
2212 _M_it = std::forward<_CIt>(__x)._M_it;
2213 else if (_M_index == 1)
2214 _M_sent = std::forward<_CIt>(__x)._M_sent;
2215 }
2216 else
2217 {
2218 if (_M_index == 0)
2219 _M_it.~_It();
2220 else if (_M_index == 1)
2221 _M_sent.~_Sent();
2222 _M_index = _S_valueless;
2223
2224 if (__x._M_index == 0)
2225 std::construct_at(std::__addressof(_M_it),
2226 std::forward<_CIt>(__x)._M_it);
2227 else if (__x._M_index == 1)
2228 std::construct_at(std::__addressof(_M_sent),
2229 std::forward<_CIt>(__x)._M_sent);
2230 _M_index = __x._M_index;
2231 }
2232 }
2233
2234 union
2235 {
2236 _It _M_it;
2237 _Sent _M_sent;
2238 unsigned char _M_valueless;
2239 };
2240 unsigned char _M_index; // 0 == _M_it, 1 == _M_sent, 2 == valueless
2241
2242 static constexpr unsigned char _S_valueless{2};
2243 };
2244
2245 template<typename _It, typename _Sent>
2246 struct incrementable_traits<common_iterator<_It, _Sent>>
2247 {
2248 using difference_type = iter_difference_t<_It>;
2249 };
2250
2251 template<input_iterator _It, typename _Sent>
2252 struct iterator_traits<common_iterator<_It, _Sent>>
2253 {
2254 private:
2255 template<typename _Iter>
2256 struct __ptr
2257 {
2258 using type = void;
2259 };
2260
2261 template<typename _Iter>
2262 requires __detail::__common_iter_has_arrow<_Iter>
2263 struct __ptr<_Iter>
2264 {
2265 using _CIter = common_iterator<_Iter, _Sent>;
2266 using type = decltype(std::declval<const _CIter&>().operator->());
2267 };
2268
2269 static auto
2270 _S_iter_cat()
2271 {
2272 using _Traits = iterator_traits<_It>;
2273 if constexpr (requires { requires derived_from<typename _Traits::iterator_category,
2274 forward_iterator_tag>; })
2275 return forward_iterator_tag{};
2276 else
2277 return input_iterator_tag{};
2278 }
2279
2280 public:
2281 using iterator_concept = __conditional_t<forward_iterator<_It>,
2282 forward_iterator_tag,
2283 input_iterator_tag>;
2284 using iterator_category = decltype(_S_iter_cat());
2285 using value_type = iter_value_t<_It>;
2286 using difference_type = iter_difference_t<_It>;
2287 using pointer = typename __ptr<_It>::type;
2288 using reference = iter_reference_t<_It>;
2289 };
2290
2291 // [iterators.counted] Counted iterators
2292
2293 namespace __detail
2294 {
2295 template<typename _It>
2296 struct __counted_iter_value_type
2297 { };
2298
2299 template<indirectly_readable _It>
2300 struct __counted_iter_value_type<_It>
2301 { using value_type = iter_value_t<_It>; };
2302
2303 template<typename _It>
2304 struct __counted_iter_concept
2305 { };
2306
2307 template<typename _It>
2308 requires requires { typename _It::iterator_concept; }
2309 struct __counted_iter_concept<_It>
2310 { using iterator_concept = typename _It::iterator_concept; };
2311
2312 template<typename _It>
2313 struct __counted_iter_cat
2314 { };
2315
2316 template<typename _It>
2317 requires requires { typename _It::iterator_category; }
2318 struct __counted_iter_cat<_It>
2319 { using iterator_category = typename _It::iterator_category; };
2320 }
2321
2322 /// An iterator adaptor that keeps track of the distance to the end.
2323 template<input_or_output_iterator _It>
2324 class counted_iterator
2325 : public __detail::__counted_iter_value_type<_It>,
2326 public __detail::__counted_iter_concept<_It>,
2327 public __detail::__counted_iter_cat<_It>
2328 {
2329 public:
2330 using iterator_type = _It;
2331 // value_type defined in __counted_iter_value_type
2332 using difference_type = iter_difference_t<_It>;
2333 // iterator_concept defined in __counted_iter_concept
2334 // iterator_category defined in __counted_iter_cat
2335
2336 constexpr counted_iterator() requires default_initializable<_It> = default;
2337
2338 constexpr
2339 counted_iterator(_It __i, iter_difference_t<_It> __n)
2340 : _M_current(std::move(__i)), _M_length(__n)
2341 { __glibcxx_assert(__n >= 0); }
2342
2343 template<typename _It2>
2344 requires convertible_to<const _It2&, _It>
2345 constexpr
2346 counted_iterator(const counted_iterator<_It2>& __x)
2347 : _M_current(__x._M_current), _M_length(__x._M_length)
2348 { }
2349
2350 template<typename _It2>
2351 requires assignable_from<_It&, const _It2&>
2352 constexpr counted_iterator&
2353 operator=(const counted_iterator<_It2>& __x)
2354 {
2355 _M_current = __x._M_current;
2356 _M_length = __x._M_length;
2357 return *this;
2358 }
2359
2360 [[nodiscard]]
2361 constexpr const _It&
2362 base() const & noexcept
2363 { return _M_current; }
2364
2365 [[nodiscard]]
2366 constexpr _It
2367 base() &&
2368 noexcept(is_nothrow_move_constructible_v<_It>)
2369 { return std::move(_M_current); }
2370
2371 [[nodiscard]]
2372 constexpr iter_difference_t<_It>
2373 count() const noexcept { return _M_length; }
2374
2375 [[nodiscard]]
2376 constexpr decltype(auto)
2377 operator*()
2378 noexcept(noexcept(*_M_current))
2379 {
2380 __glibcxx_assert( _M_length > 0 );
2381 return *_M_current;
2382 }
2383
2384 [[nodiscard]]
2385 constexpr decltype(auto)
2386 operator*() const
2387 noexcept(noexcept(*_M_current))
2388 requires __detail::__dereferenceable<const _It>
2389 {
2390 __glibcxx_assert( _M_length > 0 );
2391 return *_M_current;
2392 }
2393
2394 [[nodiscard]]
2395 constexpr auto
2396 operator->() const noexcept
2397 requires contiguous_iterator<_It>
2398 { return std::to_address(_M_current); }
2399
2400 constexpr counted_iterator&
2401 operator++()
2402 {
2403 __glibcxx_assert(_M_length > 0);
2404 ++_M_current;
2405 --_M_length;
2406 return *this;
2407 }
2408
2409 constexpr decltype(auto)
2410 operator++(int)
2411 {
2412 __glibcxx_assert(_M_length > 0);
2413 --_M_length;
2414 __try
2415 {
2416 return _M_current++;
2417 } __catch(...) {
2418 ++_M_length;
2419 __throw_exception_again;
2420 }
2421 }
2422
2423 constexpr counted_iterator
2424 operator++(int) requires forward_iterator<_It>
2425 {
2426 auto __tmp = *this;
2427 ++*this;
2428 return __tmp;
2429 }
2430
2431 constexpr counted_iterator&
2432 operator--() requires bidirectional_iterator<_It>
2433 {
2434 --_M_current;
2435 ++_M_length;
2436 return *this;
2437 }
2438
2439 constexpr counted_iterator
2440 operator--(int) requires bidirectional_iterator<_It>
2441 {
2442 auto __tmp = *this;
2443 --*this;
2444 return __tmp;
2445 }
2446
2447 [[nodiscard]]
2448 constexpr counted_iterator
2449 operator+(iter_difference_t<_It> __n) const
2450 requires random_access_iterator<_It>
2451 { return counted_iterator(_M_current + __n, _M_length - __n); }
2452
2453 [[nodiscard]]
2454 friend constexpr counted_iterator
2455 operator+(iter_difference_t<_It> __n, const counted_iterator& __x)
2456 requires random_access_iterator<_It>
2457 { return __x + __n; }
2458
2459 constexpr counted_iterator&
2460 operator+=(iter_difference_t<_It> __n)
2461 requires random_access_iterator<_It>
2462 {
2463 __glibcxx_assert(__n <= _M_length);
2464 _M_current += __n;
2465 _M_length -= __n;
2466 return *this;
2467 }
2468
2469 [[nodiscard]]
2470 constexpr counted_iterator
2471 operator-(iter_difference_t<_It> __n) const
2472 requires random_access_iterator<_It>
2473 { return counted_iterator(_M_current - __n, _M_length + __n); }
2474
2475 template<common_with<_It> _It2>
2476 [[nodiscard]]
2477 friend constexpr iter_difference_t<_It2>
2478 operator-(const counted_iterator& __x,
2479 const counted_iterator<_It2>& __y)
2480 { return __y._M_length - __x._M_length; }
2481
2482 [[nodiscard]]
2483 friend constexpr iter_difference_t<_It>
2484 operator-(const counted_iterator& __x, default_sentinel_t)
2485 { return -__x._M_length; }
2486
2487 [[nodiscard]]
2488 friend constexpr iter_difference_t<_It>
2489 operator-(default_sentinel_t, const counted_iterator& __y)
2490 { return __y._M_length; }
2491
2492 constexpr counted_iterator&
2493 operator-=(iter_difference_t<_It> __n)
2494 requires random_access_iterator<_It>
2495 {
2496 __glibcxx_assert(-__n <= _M_length);
2497 _M_current -= __n;
2498 _M_length += __n;
2499 return *this;
2500 }
2501
2502 [[nodiscard]]
2503 constexpr decltype(auto)
2504 operator[](iter_difference_t<_It> __n) const
2505 noexcept(noexcept(_M_current[__n]))
2506 requires random_access_iterator<_It>
2507 {
2508 __glibcxx_assert(__n < _M_length);
2509 return _M_current[__n];
2510 }
2511
2512 template<common_with<_It> _It2>
2513 [[nodiscard]]
2514 friend constexpr bool
2515 operator==(const counted_iterator& __x,
2516 const counted_iterator<_It2>& __y)
2517 { return __x._M_length == __y._M_length; }
2518
2519 [[nodiscard]]
2520 friend constexpr bool
2521 operator==(const counted_iterator& __x, default_sentinel_t)
2522 { return __x._M_length == 0; }
2523
2524 template<common_with<_It> _It2>
2525 [[nodiscard]]
2526 friend constexpr strong_ordering
2527 operator<=>(const counted_iterator& __x,
2528 const counted_iterator<_It2>& __y)
2529 { return __y._M_length <=> __x._M_length; }
2530
2531 [[nodiscard]]
2532 friend constexpr iter_rvalue_reference_t<_It>
2533 iter_move(const counted_iterator& __i)
2534 noexcept(noexcept(ranges::iter_move(__i._M_current)))
2535 requires input_iterator<_It>
2536 {
2537 __glibcxx_assert( __i._M_length > 0 );
2538 return ranges::iter_move(__i._M_current);
2539 }
2540
2541 template<indirectly_swappable<_It> _It2>
2542 friend constexpr void
2543 iter_swap(const counted_iterator& __x,
2544 const counted_iterator<_It2>& __y)
2545 noexcept(noexcept(ranges::iter_swap(__x._M_current, __y._M_current)))
2546 {
2547 __glibcxx_assert( __x._M_length > 0 && __y._M_length > 0 );
2548 ranges::iter_swap(__x._M_current, __y._M_current);
2549 }
2550
2551 private:
2552 template<input_or_output_iterator _It2> friend class counted_iterator;
2553
2554 _It _M_current = _It();
2555 iter_difference_t<_It> _M_length = 0;
2556 };
2557
2558 template<input_iterator _It>
2559 requires same_as<__detail::__iter_traits<_It>, iterator_traits<_It>>
2560 struct iterator_traits<counted_iterator<_It>> : iterator_traits<_It>
2561 {
2562 using pointer = __conditional_t<contiguous_iterator<_It>,
2563 add_pointer_t<iter_reference_t<_It>>,
2564 void>;
2565 };
2566 #endif // C++20
2567
2568 /// @} group iterators
2569
2570 template<typename _Iterator>
2571 _GLIBCXX20_CONSTEXPR
2572 auto
2573 __niter_base(move_iterator<_Iterator> __it)
2574 -> decltype(make_move_iterator(__niter_base(__it.base())))
2575 { return make_move_iterator(__niter_base(__it.base())); }
2576
2577 template<typename _Iterator>
2578 struct __is_move_iterator<move_iterator<_Iterator> >
2579 {
2580 enum { __value = 1 };
2581 typedef __true_type __type;
2582 };
2583
2584 template<typename _Iterator>
2585 _GLIBCXX20_CONSTEXPR
2586 auto
2587 __miter_base(move_iterator<_Iterator> __it)
2588 -> decltype(__miter_base(__it.base()))
2589 { return __miter_base(__it.base()); }
2590
2591 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) std::make_move_iterator(_Iter)
2592 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) \
2593 std::__make_move_if_noexcept_iterator(_Iter)
2594 #else
2595 #define _GLIBCXX_MAKE_MOVE_ITERATOR(_Iter) (_Iter)
2596 #define _GLIBCXX_MAKE_MOVE_IF_NOEXCEPT_ITERATOR(_Iter) (_Iter)
2597 #endif // C++11
2598
2599 #if __cpp_deduction_guides >= 201606
2600 // These helper traits are used for deduction guides
2601 // of associative containers.
2602 template<typename _InputIterator>
2603 using __iter_key_t = remove_const_t<
2604 typename iterator_traits<_InputIterator>::value_type::first_type>;
2605
2606 template<typename _InputIterator>
2607 using __iter_val_t =
2608 typename iterator_traits<_InputIterator>::value_type::second_type;
2609
2610 template<typename _T1, typename _T2>
2611 struct pair;
2612
2613 template<typename _InputIterator>
2614 using __iter_to_alloc_t =
2615 pair<add_const_t<__iter_key_t<_InputIterator>>,
2616 __iter_val_t<_InputIterator>>;
2617 #endif // __cpp_deduction_guides
2618
2619 _GLIBCXX_END_NAMESPACE_VERSION
2620 } // namespace
2621
2622 #ifdef _GLIBCXX_DEBUG
2623 # include <debug/stl_iterator.h>
2624 #endif
2625
2626 #endif
2627