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 <__compare/compare_three_way_result.h>
14 #include <__compare/three_way_comparable.h>
15 #include <__concepts/convertible_to.h>
16 #include <__config>
17 #include <__iterator/concepts.h>
18 #include <__iterator/incrementable_traits.h>
19 #include <__iterator/iter_move.h>
20 #include <__iterator/iter_swap.h>
21 #include <__iterator/iterator.h>
22 #include <__iterator/iterator_traits.h>
23 #include <__iterator/prev.h>
24 #include <__iterator/readable_traits.h>
25 #include <__memory/addressof.h>
26 #include <__utility/move.h>
27 #include <type_traits>
28 
29 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
30 #  pragma GCC system_header
31 #endif
32 
33 _LIBCPP_BEGIN_NAMESPACE_STD
34 
35 _LIBCPP_SUPPRESS_DEPRECATED_PUSH
36 template <class _Iter>
37 class _LIBCPP_TEMPLATE_VIS reverse_iterator
38 #if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
39     : public iterator<typename iterator_traits<_Iter>::iterator_category,
40                       typename iterator_traits<_Iter>::value_type,
41                       typename iterator_traits<_Iter>::difference_type,
42                       typename iterator_traits<_Iter>::pointer,
43                       typename iterator_traits<_Iter>::reference>
44 #endif
45 {
46 _LIBCPP_SUPPRESS_DEPRECATED_POP
47 private:
48 #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
49     _Iter __t; // no longer used as of LWG #2360, not removed due to ABI break
50 #endif
51 
52 #if _LIBCPP_STD_VER > 17
53     static_assert(__is_cpp17_bidirectional_iterator<_Iter>::value || bidirectional_iterator<_Iter>,
54         "reverse_iterator<It> requires It to be a bidirectional iterator.");
55 #endif // _LIBCPP_STD_VER > 17
56 
57 protected:
58     _Iter current;
59 public:
60     using iterator_type = _Iter;
61 
62     using iterator_category = _If<__is_cpp17_random_access_iterator<_Iter>::value,
63                                   random_access_iterator_tag,
64                                   typename iterator_traits<_Iter>::iterator_category>;
65     using pointer = typename iterator_traits<_Iter>::pointer;
66 #if _LIBCPP_STD_VER > 17
67     using iterator_concept = _If<__is_cpp17_random_access_iterator<_Iter>::value,
68                                   random_access_iterator_tag,
69                                   bidirectional_iterator_tag>;
70     using value_type = iter_value_t<_Iter>;
71     using difference_type = iter_difference_t<_Iter>;
72     using reference = iter_reference_t<_Iter>;
73 #else
74     using value_type = typename iterator_traits<_Iter>::value_type;
75     using difference_type = typename iterator_traits<_Iter>::difference_type;
76     using reference = typename iterator_traits<_Iter>::reference;
77 #endif
78 
79 #ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
80     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
81     reverse_iterator() : __t(), current() {}
82 
83     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
84     explicit reverse_iterator(_Iter __x) : __t(__x), current(__x) {}
85 
86     template <class _Up, class = __enable_if_t<
87         !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
88     > >
89     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
90     reverse_iterator(const reverse_iterator<_Up>& __u)
91         : __t(__u.base()), current(__u.base())
92     { }
93 
94     template <class _Up, class = __enable_if_t<
95         !is_same<_Up, _Iter>::value &&
96         is_convertible<_Up const&, _Iter>::value &&
97         is_assignable<_Iter&, _Up const&>::value
98     > >
99     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
100     reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
101         __t = current = __u.base();
102         return *this;
103     }
104 #else
105     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
106     reverse_iterator() : current() {}
107 
108     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
109     explicit reverse_iterator(_Iter __x) : current(__x) {}
110 
111     template <class _Up, class = __enable_if_t<
112         !is_same<_Up, _Iter>::value && is_convertible<_Up const&, _Iter>::value
113     > >
114     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
115     reverse_iterator(const reverse_iterator<_Up>& __u)
116         : current(__u.base())
117     { }
118 
119     template <class _Up, class = __enable_if_t<
120         !is_same<_Up, _Iter>::value &&
121         is_convertible<_Up const&, _Iter>::value &&
122         is_assignable<_Iter&, _Up const&>::value
123     > >
124     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
125     reverse_iterator& operator=(const reverse_iterator<_Up>& __u) {
126         current = __u.base();
127         return *this;
128     }
129 #endif
130     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
131     _Iter base() const {return current;}
132     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
133     reference operator*() const {_Iter __tmp = current; return *--__tmp;}
134 
135 #if _LIBCPP_STD_VER > 17
136     _LIBCPP_INLINE_VISIBILITY
137     constexpr pointer operator->() const
138       requires is_pointer_v<_Iter> || requires(const _Iter i) { i.operator->(); }
139     {
140       if constexpr (is_pointer_v<_Iter>) {
141         return std::prev(current);
142       } else {
143         return std::prev(current).operator->();
144       }
145     }
146 #else
147     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
148     pointer operator->() const {
149       return std::addressof(operator*());
150     }
151 #endif // _LIBCPP_STD_VER > 17
152 
153     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
154     reverse_iterator& operator++() {--current; return *this;}
155     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
156     reverse_iterator operator++(int) {reverse_iterator __tmp(*this); --current; return __tmp;}
157     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
158     reverse_iterator& operator--() {++current; return *this;}
159     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
160     reverse_iterator operator--(int) {reverse_iterator __tmp(*this); ++current; return __tmp;}
161     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
162     reverse_iterator operator+(difference_type __n) const {return reverse_iterator(current - __n);}
163     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
164     reverse_iterator& operator+=(difference_type __n) {current -= __n; return *this;}
165     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
166     reverse_iterator operator-(difference_type __n) const {return reverse_iterator(current + __n);}
167     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
168     reverse_iterator& operator-=(difference_type __n) {current += __n; return *this;}
169     _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
170     reference operator[](difference_type __n) const {return *(*this + __n);}
171 
172 #if _LIBCPP_STD_VER > 17
173     _LIBCPP_HIDE_FROM_ABI friend constexpr
174     iter_rvalue_reference_t<_Iter> iter_move(const reverse_iterator& __i)
175       noexcept(is_nothrow_copy_constructible_v<_Iter> &&
176           noexcept(ranges::iter_move(--declval<_Iter&>()))) {
177       auto __tmp = __i.base();
178       return ranges::iter_move(--__tmp);
179     }
180 
181     template <indirectly_swappable<_Iter> _Iter2>
182     _LIBCPP_HIDE_FROM_ABI friend constexpr
183     void iter_swap(const reverse_iterator& __x, const reverse_iterator<_Iter2>& __y)
184       noexcept(is_nothrow_copy_constructible_v<_Iter> &&
185           is_nothrow_copy_constructible_v<_Iter2> &&
186           noexcept(ranges::iter_swap(--declval<_Iter&>(), --declval<_Iter2&>()))) {
187       auto __xtmp = __x.base();
188       auto __ytmp = __y.base();
189       ranges::iter_swap(--__xtmp, --__ytmp);
190     }
191 #endif // _LIBCPP_STD_VER > 17
192 };
193 
194 template <class _Iter1, class _Iter2>
195 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
196 bool
197 operator==(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
198 #if _LIBCPP_STD_VER > 17
199     requires requires {
200       { __x.base() == __y.base() } -> convertible_to<bool>;
201     }
202 #endif // _LIBCPP_STD_VER > 17
203 {
204     return __x.base() == __y.base();
205 }
206 
207 template <class _Iter1, class _Iter2>
208 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
209 bool
210 operator<(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
211 #if _LIBCPP_STD_VER > 17
212     requires requires {
213         { __x.base() > __y.base() } -> convertible_to<bool>;
214       }
215 #endif // _LIBCPP_STD_VER > 17
216 {
217     return __x.base() > __y.base();
218 }
219 
220 template <class _Iter1, class _Iter2>
221 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
222 bool
223 operator!=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
224 #if _LIBCPP_STD_VER > 17
225     requires requires {
226       { __x.base() != __y.base() } -> convertible_to<bool>;
227     }
228 #endif // _LIBCPP_STD_VER > 17
229 {
230     return __x.base() != __y.base();
231 }
232 
233 template <class _Iter1, class _Iter2>
234 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
235 bool
236 operator>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
237 #if _LIBCPP_STD_VER > 17
238     requires requires {
239         { __x.base() < __y.base() } -> convertible_to<bool>;
240       }
241 #endif // _LIBCPP_STD_VER > 17
242 {
243     return __x.base() < __y.base();
244 }
245 
246 template <class _Iter1, class _Iter2>
247 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
248 bool
249 operator>=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
250 #if _LIBCPP_STD_VER > 17
251     requires requires {
252         { __x.base() <= __y.base() } -> convertible_to<bool>;
253       }
254 #endif // _LIBCPP_STD_VER > 17
255 {
256     return __x.base() <= __y.base();
257 }
258 
259 template <class _Iter1, class _Iter2>
260 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
261 bool
262 operator<=(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
263 #if _LIBCPP_STD_VER > 17
264     requires requires {
265         { __x.base() >= __y.base() } -> convertible_to<bool>;
266       }
267 #endif // _LIBCPP_STD_VER > 17
268 {
269     return __x.base() >= __y.base();
270 }
271 
272 #if _LIBCPP_STD_VER > 17
273 template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
274 _LIBCPP_HIDE_FROM_ABI constexpr
275 compare_three_way_result_t<_Iter1, _Iter2>
276 operator<=>(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
277 {
278     return __y.base() <=> __x.base();
279 }
280 #endif // _LIBCPP_STD_VER > 17
281 
282 #ifndef _LIBCPP_CXX03_LANG
283 template <class _Iter1, class _Iter2>
284 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
285 auto
286 operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
287 -> decltype(__y.base() - __x.base())
288 {
289     return __y.base() - __x.base();
290 }
291 #else
292 template <class _Iter1, class _Iter2>
293 inline _LIBCPP_INLINE_VISIBILITY
294 typename reverse_iterator<_Iter1>::difference_type
295 operator-(const reverse_iterator<_Iter1>& __x, const reverse_iterator<_Iter2>& __y)
296 {
297     return __y.base() - __x.base();
298 }
299 #endif
300 
301 template <class _Iter>
302 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
303 reverse_iterator<_Iter>
304 operator+(typename reverse_iterator<_Iter>::difference_type __n, const reverse_iterator<_Iter>& __x)
305 {
306     return reverse_iterator<_Iter>(__x.base() - __n);
307 }
308 
309 #if _LIBCPP_STD_VER > 17
310 template <class _Iter1, class _Iter2>
311   requires (!sized_sentinel_for<_Iter1, _Iter2>)
312 inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_Iter1>, reverse_iterator<_Iter2>> = true;
313 #endif // _LIBCPP_STD_VER > 17
314 
315 #if _LIBCPP_STD_VER > 11
316 template <class _Iter>
317 inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX14
318 reverse_iterator<_Iter> make_reverse_iterator(_Iter __i)
319 {
320     return reverse_iterator<_Iter>(__i);
321 }
322 #endif
323 
324 _LIBCPP_END_NAMESPACE_STD
325 
326 #endif // _LIBCPP___ITERATOR_REVERSE_ITERATOR_H
327