libcxx/include/__iterator/reverse_iterator.h

   1 // -*- C++ -*-
   2 //===----------------------------------------------------------------------===//
   3 //
   4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   5 // See https://llvm.org/LICENSE.txt for license information.
   6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #ifndef _LIBCPP___ITERATOR_REVERSE_ITERATOR_H
  11 #define _LIBCPP___ITERATOR_REVERSE_ITERATOR_H
  12
  13 #include <__algorithm/unwrap_iter.h>
  14 #include <__compare/compare_three_way_result.h>
  15 #include <__compare/three_way_comparable.h>
  16 #include <__concepts/convertible_to.h>
  17 #include <__config>
  18 #include <__iterator/advance.h>
  19 #include <__iterator/concepts.h>
  20 #include <__iterator/incrementable_traits.h>
  21 #include <__iterator/iter_move.h>
  22 #include <__iterator/iter_swap.h>
  23 #include <__iterator/iterator.h>
  24 #include <__iterator/iterator_traits.h>
  25 #include <__iterator/next.h>
  26 #include <__iterator/prev.h>
  27 #include <__iterator/readable_traits.h>
  28 #include <__iterator/segmented_iterator.h>
  29 #include <__memory/addressof.h>
  30 #include <__ranges/access.h>
  31 #include <__ranges/concepts.h>
  32 #include <__ranges/subrange.h>
  33 #include <__type_traits/conditional.h>
  34 #include <__type_traits/enable_if.h>
  35 #include <__type_traits/is_assignable.h>
  36 #include <__type_traits/is_convertible.h>
  37 #include <__type_traits/is_nothrow_copy_constructible.h>
  38 #include <__type_traits/is_pointer.h>
  39 #include <__type_traits/is_same.h>
  40 #include <__utility/declval.h>
  41 #include <__utility/move.h>
  42
  43 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  44 #  pragma GCC system_header
  45 #endif
  46
  47 _LIBCPP_BEGIN_NAMESPACE_STD
  48
  49 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
  50 template <class _Iter>
  51 class _LIBCPP_TEMPLATE_VIS reverse_iterator
  52 #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
  53     : public iterator<typename iterator_traits<_Iter>::iterator_category,
  54                       typename iterator_traits<_Iter>::value_type,
  55                       typename iterator_traits<_Iter>::difference_type,
  56                       typename iterator_traits<_Iter>::pointer,
  57                       typename iterator_traits<_Iter>::reference>
  58 #endif
  59 {
  60 _LIBCPP_SUPPRESS_DEPRECATED_POP
  61 private:
  62 #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
  63     _Iter __t_; // no longer used as of LWG #2360, not removed due to ABI break
  64 #endif
  65
  66 #if _LIBCPP_STD_VER >= 20
  67     static_assert(__has_bidirectional_iterator_category<_Iter>::value || bidirectional_iterator<_Iter>,
  68         "reverse_iterator<It> requires It to be a bidirectional iterator.");
  69 #endif // _LIBCPP_STD_VER >= 20
  70
  71 protected:
  72     _Iter current;
  73 public:
  74     using iterator_type = _Iter;
  75
  76     using iterator_category = _If<__has_random_access_iterator_category<_Iter>::value,
  77                                   random_access_iterator_tag,
  78                                   typename iterator_traits<_Iter>::iterator_category>;
  79     using pointer = typename iterator_traits<_Iter>::pointer;
  80 #if _LIBCPP_STD_VER >= 20
  81     using iterator_concept = _If<random_access_iterator<_Iter>, random_access_iterator_tag, bidirectional_iterator_tag>;
  82     using value_type = iter_value_t<_Iter>;
  83     using difference_type = iter_difference_t<_Iter>;
  84     using reference = iter_reference_t<_Iter>;
  85 #else
  86     using value_type = typename iterator_traits<_Iter>::value_type;
  87     using difference_type = typename iterator_traits<_Iter>::difference_type;
  88     using reference = typename iterator_traits<_Iter>::reference;
  89 #endif
  90
  91 #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
  92     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
  93     reverse_iterator() : __t_(), current() {}
  94
  95     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
  96     explicit reverse_iterator(_Iter __x) : __t_(__x), current(__x) {}
  97
  98     template <class _Up, class = __enable_if_t<
  99         !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
 100     > >
 101     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 102     reverse_iterator(const reverse_iterator<_Up>& __u)
 103         : __t_(__u.base()), current(__u.base())
 104     { }
 105
 106     template <class _Up, class = __enable_if_t<
 107         !is_same<_Up, _Iter>::value &&
 108         is_convertible<_Up const&, _Iter>::value &&
 109         is_assignable<_Iter&, _Up const&>::value
 110     > >
 111     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 112     reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
 113         __t_ = current = __u.base();
 114         return *this;
 115     }
 116 #else
 117     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 118     reverse_iterator() : current() {}
 119
 120     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 121     explicit reverse_iterator(_Iter __x) : current(__x) {}
 122
 123     template <class _Up, class = __enable_if_t<
 124         !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
 125     > >
 126     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 127     reverse_iterator(const reverse_iterator<_Up>& __u)
 128         : current(__u.base())
 129     { }
 130
 131     template <class _Up, class = __enable_if_t<
 132         !is_same<_Up, _Iter>::value &&
 133         is_convertible<_Up const&, _Iter>::value &&
 134         is_assignable<_Iter&, _Up const&>::value
 135     > >
 136     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 137     reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
 138         current = __u.base();
 139         return *this;
 140     }
 141 #endif
 142     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 143     _Iter base() const {return current;}
 144     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 145     reference operator*() const {_Iter __tmp = current; return *--__tmp;}
 146
 147 #if _LIBCPP_STD_VER >= 20
 148     _LIBCPP_INLINE_VISIBILITY
 149     constexpr pointer operator->() const
 150       requires is_pointer_v<_Iter> || requires(const _Iter __i) { __i.operator->(); }
 151     {
 152       if constexpr (is_pointer_v<_Iter>) {
 153         return std::prev(current);
 154       } else {
 155         return std::prev(current).operator->();
 156       }
 157     }
 158 #else
 159     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 160     pointer operator->() const {
 161       return std::addressof(operator*());
 162     }
 163 #endif // _LIBCPP_STD_VER >= 20
 164
 165     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 166     reverse_iterator& operator++() {--current; return *this;}
 167     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 168     reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
 169     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 170     reverse_iterator& operator--() {++current; return *this;}
 171     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 172     reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
 173     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 174     reverse_iterator operator+(difference_type __n) const {return reverse_iterator(current - __n);}
 175     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 176     reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
 177     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 178     reverse_iterator operator-(difference_type __n) const {return reverse_iterator(current + __n);}
 179     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 180     reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
 181     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 182     reference operator[](difference_type __n) const {return *(*this + __n);}
 183
 184 #if _LIBCPP_STD_VER >= 20
 185     _LIBCPP_HIDE_FROM_ABI friend constexpr
 186     iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i)
 187       noexcept(is_nothrow_copy_constructible_v<_Iter> &&
 188           noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
 189       auto __tmp = __i.base();
 190       return ranges::iter_move(--__tmp);
 191     }
 192
 193     template <indirectly_swappable<_Iter> _Iter2>
 194     _LIBCPP_HIDE_FROM_ABI friend constexpr
 195     void iter_swap(const reverse_iterator& __x, const reverse_iterator<_Iter2>& __y)
 196       noexcept(is_nothrow_copy_constructible_v<_Iter> &&
 197           is_nothrow_copy_constructible_v<_Iter2> &&
 198           noexcept(ranges::iter_swap(--std::declval<_Iter&>(), --std::declval<_Iter2&>()))) {
 199       auto __xtmp = __x.base();
 200       auto __ytmp = __y.base();
 201       ranges::iter_swap(--__xtmp, --__ytmp);
 202     }
 203 #endif // _LIBCPP_STD_VER >= 20
 204 };
 205
 206 template <class _Iter1, class _Iter2>
 207 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 208 bool
 209 operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 210 #if _LIBCPP_STD_VER >= 20
 211     requires requires {
 212       { __x.base() == __y.base() } -> convertible_to<bool>;
 213     }
 214 #endif // _LIBCPP_STD_VER >= 20
 215 {
 216     return __x.base() == __y.base();
 217 }
 218
 219 template <class _Iter1, class _Iter2>
 220 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 221 bool
 222 operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 223 #if _LIBCPP_STD_VER >= 20
 224     requires requires {
 225         { __x.base() > __y.base() } -> convertible_to<bool>;
 226       }
 227 #endif // _LIBCPP_STD_VER >= 20
 228 {
 229     return __x.base() > __y.base();
 230 }
 231
 232 template <class _Iter1, class _Iter2>
 233 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 234 bool
 235 operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 236 #if _LIBCPP_STD_VER >= 20
 237     requires requires {
 238       { __x.base() != __y.base() } -> convertible_to<bool>;
 239     }
 240 #endif // _LIBCPP_STD_VER >= 20
 241 {
 242     return __x.base() != __y.base();
 243 }
 244
 245 template <class _Iter1, class _Iter2>
 246 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 247 bool
 248 operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 249 #if _LIBCPP_STD_VER >= 20
 250     requires requires {
 251         { __x.base() < __y.base() } -> convertible_to<bool>;
 252       }
 253 #endif // _LIBCPP_STD_VER >= 20
 254 {
 255     return __x.base() < __y.base();
 256 }
 257
 258 template <class _Iter1, class _Iter2>
 259 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 260 bool
 261 operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 262 #if _LIBCPP_STD_VER >= 20
 263     requires requires {
 264         { __x.base() <= __y.base() } -> convertible_to<bool>;
 265       }
 266 #endif // _LIBCPP_STD_VER >= 20
 267 {
 268     return __x.base() <= __y.base();
 269 }
 270
 271 template <class _Iter1, class _Iter2>
 272 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 273 bool
 274 operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 275 #if _LIBCPP_STD_VER >= 20
 276     requires requires {
 277         { __x.base() >= __y.base() } -> convertible_to<bool>;
 278       }
 279 #endif // _LIBCPP_STD_VER >= 20
 280 {
 281     return __x.base() >= __y.base();
 282 }
 283
 284 #if _LIBCPP_STD_VER >= 20
 285 template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
 286 _LIBCPP_HIDE_FROM_ABI constexpr
 287 compare_three_way_result_t<_Iter1, _Iter2>
 288 operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 289 {
 290     return __y.base() <=> __x.base();
 291 }
 292 #endif // _LIBCPP_STD_VER >= 20
 293
 294 #ifndef _LIBCPP_CXX03_LANG
 295 template <class _Iter1, class _Iter2>
 296 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 297 auto
 298 operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 299 -> decltype(__y.base() - __x.base())
 300 {
 301     return __y.base() - __x.base();
 302 }
 303 #else
 304 template <class _Iter1, class _Iter2>
 305 inline _LIBCPP_INLINE_VISIBILITY
 306 typename reverse_iterator<_Iter1>::difference_type
 307 operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
 308 {
 309     return __y.base() - __x.base();
 310 }
 311 #endif
 312
 313 template <class _Iter>
 314 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 315 reverse_iterator<_Iter>
 316 operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
 317 {
 318     return reverse_iterator<_Iter>(__x.base() - __n);
 319 }
 320
 321 #if _LIBCPP_STD_VER >= 20
 322 template <class _Iter1, class _Iter2>
 323   requires (!sized_sentinel_for<_Iter1, _Iter2>)
 324 inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_Iter1>, reverse_iterator<_Iter2>> = true;
 325 #endif // _LIBCPP_STD_VER >= 20
 326
 327 #if _LIBCPP_STD_VER >= 14
 328 template <class _Iter>
 329 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_SINCE_CXX17
 330 reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
 331 {
 332     return reverse_iterator<_Iter>(__i);
 333 }
 334 #endif
 335
 336 #if _LIBCPP_STD_VER <= 17
 337 template <class _Iter>
 338 using __unconstrained_reverse_iterator = reverse_iterator<_Iter>;
 339 #else
 340
 341 // __unconstrained_reverse_iterator allows us to use reverse iterators in the implementation of algorithms by working
 342 // around a language issue in C++20.
 343 // In C++20, when a reverse iterator wraps certain C++20-hostile iterators, calling comparison operators on it will
 344 // result in a compilation error. However, calling comparison operators on the pristine hostile iterator is not
 345 // an error. Thus, we cannot use reverse_iterators in the implementation of an algorithm that accepts a
 346 // C++20-hostile iterator. This class is an internal workaround -- it is a copy of reverse_iterator with
 347 // tweaks to make it support hostile iterators.
 348 //
 349 // A C++20-hostile iterator is one that defines a comparison operator where one of the arguments is an exact match
 350 // and the other requires an implicit conversion, for example:
 351 //   friend bool operator==(const BaseIter&, const DerivedIter&);
 352 //
 353 // C++20 rules for rewriting equality operators create another overload of this function with parameters reversed:
 354 //   friend bool operator==(const DerivedIter&, const BaseIter&);
 355 //
 356 // This creates an ambiguity in overload resolution.
 357 //
 358 // Clang treats this ambiguity differently in different contexts. When operator== is actually called in the function
 359 // body, the code is accepted with a warning. When a concept requires operator== to be a valid expression, however,
 360 // it evaluates to false. Thus, the implementation of reverse_iterator::operator== can actually call operator== on its
 361 // base iterators, but the constraints on reverse_iterator::operator== prevent it from being considered during overload
 362 // resolution. This class simply removes the problematic constraints from comparison functions.
 363 template <class _Iter>
 364 class __unconstrained_reverse_iterator {
 365   _Iter __iter_;
 366
 367 public:
 368   static_assert(__has_bidirectional_iterator_category<_Iter>::value || bidirectional_iterator<_Iter>);
 369
 370   using iterator_type = _Iter;
 371   using iterator_category =
 372       _If<__has_random_access_iterator_category<_Iter>::value, random_access_iterator_tag, __iterator_category_type<_Iter>>;
 373   using pointer = __iterator_pointer_type<_Iter>;
 374   using value_type = iter_value_t<_Iter>;
 375   using difference_type = iter_difference_t<_Iter>;
 376   using reference = iter_reference_t<_Iter>;
 377
 378   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator() = default;
 379   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator(const __unconstrained_reverse_iterator&) = default;
 380   _LIBCPP_HIDE_FROM_ABI constexpr explicit __unconstrained_reverse_iterator(_Iter __iter) : __iter_(__iter) {}
 381
 382   _LIBCPP_HIDE_FROM_ABI constexpr _Iter base() const { return __iter_; }
 383   _LIBCPP_HIDE_FROM_ABI constexpr reference operator*() const {
 384     auto __tmp = __iter_;
 385     return *--__tmp;
 386   }
 387
 388   _LIBCPP_HIDE_FROM_ABI constexpr pointer operator->() const {
 389     if constexpr (is_pointer_v<_Iter>) {
 390       return std::prev(__iter_);
 391     } else {
 392       return std::prev(__iter_).operator->();
 393     }
 394   }
 395
 396   _LIBCPP_HIDE_FROM_ABI friend constexpr
 397   iter_rvalue_reference_t<_Iter> iter_move(const __unconstrained_reverse_iterator& __i)
 398     noexcept(is_nothrow_copy_constructible_v<_Iter> &&
 399         noexcept(ranges::iter_move(--std::declval<_Iter&>()))) {
 400     auto __tmp = __i.base();
 401     return ranges::iter_move(--__tmp);
 402   }
 403
 404   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator& operator++() {
 405     --__iter_;
 406     return *this;
 407   }
 408
 409   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator operator++(int) {
 410     auto __tmp = *this;
 411     --__iter_;
 412     return __tmp;
 413   }
 414
 415   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator& operator--() {
 416     ++__iter_;
 417     return *this;
 418   }
 419
 420   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator operator--(int) {
 421     auto __tmp = *this;
 422     ++__iter_;
 423     return __tmp;
 424   }
 425
 426   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator& operator+=(difference_type __n) {
 427     __iter_ -= __n;
 428     return *this;
 429   }
 430
 431   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator& operator-=(difference_type __n) {
 432     __iter_ += __n;
 433     return *this;
 434   }
 435
 436   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator operator+(difference_type __n) const {
 437     return __unconstrained_reverse_iterator(__iter_ - __n);
 438   }
 439
 440   _LIBCPP_HIDE_FROM_ABI constexpr __unconstrained_reverse_iterator operator-(difference_type __n) const {
 441     return __unconstrained_reverse_iterator(__iter_ + __n);
 442   }
 443
 444   _LIBCPP_HIDE_FROM_ABI constexpr difference_type operator-(const __unconstrained_reverse_iterator& __other) const {
 445     return __other.__iter_ - __iter_;
 446   }
 447
 448   _LIBCPP_HIDE_FROM_ABI constexpr auto operator[](difference_type __n) const { return *(*this + __n); }
 449
 450   // Deliberately unconstrained unlike the comparison functions in `reverse_iterator` -- see the class comment for the
 451   // rationale.
 452   _LIBCPP_HIDE_FROM_ABI friend constexpr bool
 453   operator==(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
 454     return __lhs.base() == __rhs.base();
 455   }
 456
 457   _LIBCPP_HIDE_FROM_ABI friend constexpr bool
 458   operator!=(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
 459     return __lhs.base() != __rhs.base();
 460   }
 461
 462   _LIBCPP_HIDE_FROM_ABI friend constexpr bool
 463   operator<(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
 464     return __lhs.base() > __rhs.base();
 465   }
 466
 467   _LIBCPP_HIDE_FROM_ABI friend constexpr bool
 468   operator>(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
 469     return __lhs.base() < __rhs.base();
 470   }
 471
 472   _LIBCPP_HIDE_FROM_ABI friend constexpr bool
 473   operator<=(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
 474     return __lhs.base() >= __rhs.base();
 475   }
 476
 477   _LIBCPP_HIDE_FROM_ABI friend constexpr bool
 478   operator>=(const __unconstrained_reverse_iterator& __lhs, const __unconstrained_reverse_iterator& __rhs) {
 479     return __lhs.base() <= __rhs.base();
 480   }
 481 };
 482
 483 #endif // _LIBCPP_STD_VER <= 17
 484
 485 template <template <class> class _RevIter1, template <class> class _RevIter2, class _Iter>
 486 struct __unwrap_reverse_iter_impl {
 487   using _UnwrappedIter = decltype(__unwrap_iter_impl<_Iter>::__unwrap(std::declval<_Iter>()));
 488   using _ReverseWrapper = _RevIter1<_RevIter2<_Iter> >;
 489
 490   static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ReverseWrapper
 491   __rewrap(_ReverseWrapper __orig_iter, _UnwrappedIter __unwrapped_iter) {
 492     return _ReverseWrapper(
 493         _RevIter2<_Iter>(__unwrap_iter_impl<_Iter>::__rewrap(__orig_iter.base().base(), __unwrapped_iter)));
 494   }
 495
 496   static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _UnwrappedIter __unwrap(_ReverseWrapper __i) _NOEXCEPT {
 497     return __unwrap_iter_impl<_Iter>::__unwrap(__i.base().base());
 498   }
 499 };
 500
 501 #if _LIBCPP_STD_VER >= 20
 502 template <ranges::bidirectional_range _Range>
 503 _LIBCPP_HIDE_FROM_ABI constexpr ranges::
 504     subrange<reverse_iterator<ranges::iterator_t<_Range>>, reverse_iterator<ranges::iterator_t<_Range>>>
 505     __reverse_range(_Range&& __range) {
 506   auto __first = ranges::begin(__range);
 507   return {std::make_reverse_iterator(ranges::next(__first, ranges::end(__range))), std::make_reverse_iterator(__first)};
 508 }
 509 #endif
 510
 511 template <class _Iter, bool __b>
 512 struct __unwrap_iter_impl<reverse_iterator<reverse_iterator<_Iter> >, __b>
 513     : __unwrap_reverse_iter_impl<reverse_iterator, reverse_iterator, _Iter> {};
 514
 515 #if _LIBCPP_STD_VER >= 20
 516
 517 template <class _Iter, bool __b>
 518 struct __unwrap_iter_impl<reverse_iterator<__unconstrained_reverse_iterator<_Iter>>, __b>
 519     : __unwrap_reverse_iter_impl<reverse_iterator, __unconstrained_reverse_iterator, _Iter> {};
 520
 521 template <class _Iter, bool __b>
 522 struct __unwrap_iter_impl<__unconstrained_reverse_iterator<reverse_iterator<_Iter>>, __b>
 523     : __unwrap_reverse_iter_impl<__unconstrained_reverse_iterator, reverse_iterator, _Iter> {};
 524
 525 template <class _Iter, bool __b>
 526 struct __unwrap_iter_impl<__unconstrained_reverse_iterator<__unconstrained_reverse_iterator<_Iter>>, __b>
 527     : __unwrap_reverse_iter_impl<__unconstrained_reverse_iterator, __unconstrained_reverse_iterator, _Iter> {};
 528
 529 #endif // _LIBCPP_STD_VER >= 20
 530
 531 _LIBCPP_END_NAMESPACE_STD
 532
 533 #endif // _LIBCPP___ITERATOR_REVERSE_ITERATOR_H