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_MOVE_ITERATOR_H
11#define _LIBCPP___ITERATOR_MOVE_ITERATOR_H
12
13#include <__compare/compare_three_way_result.h>
14#include <__compare/three_way_comparable.h>
15#include <__concepts/assignable.h>
16#include <__concepts/constructible.h>
17#include <__concepts/convertible_to.h>
18#include <__concepts/derived_from.h>
19#include <__concepts/same_as.h>
20#include <__config>
21#include <__iterator/concepts.h>
22#include <__iterator/incrementable_traits.h>
23#include <__iterator/iter_move.h>
24#include <__iterator/iter_swap.h>
25#include <__iterator/iterator_traits.h>
26#include <__iterator/move_sentinel.h>
27#include <__iterator/readable_traits.h>
28#include <__type_traits/conditional.h>
29#include <__type_traits/enable_if.h>
30#include <__type_traits/is_assignable.h>
31#include <__type_traits/is_convertible.h>
32#include <__type_traits/is_reference.h>
33#include <__type_traits/is_same.h>
34#include <__type_traits/remove_reference.h>
35#include <__utility/declval.h>
36#include <__utility/move.h>
37
38#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
39# pragma GCC system_header
40#endif
41
42_LIBCPP_PUSH_MACROS
43#include <__undef_macros>
44
45_LIBCPP_BEGIN_NAMESPACE_STD
46
47#if _LIBCPP_STD_VER >= 20
48template <class _Iter, class = void>
49struct __move_iter_category_base {};
50
51template <class _Iter>
52 requires requires { typename iterator_traits<_Iter>::iterator_category; }
53struct __move_iter_category_base<_Iter> {
54 using iterator_category =
55 _If< derived_from<typename iterator_traits<_Iter>::iterator_category, random_access_iterator_tag>,
56 random_access_iterator_tag,
57 typename iterator_traits<_Iter>::iterator_category >;
58};
59
60template <class _Iter, class _Sent>
61concept __move_iter_comparable = requires {
62 { std::declval<const _Iter&>() == std::declval<_Sent>() } -> convertible_to<bool>;
63};
64#endif // _LIBCPP_STD_VER >= 20
65
66template <class _Iter>
67class move_iterator
68#if _LIBCPP_STD_VER >= 20
69 : public __move_iter_category_base<_Iter>
70#endif
71{
72#if _LIBCPP_STD_VER >= 20
73
74private:
75 static constexpr auto __get_iter_concept() {
76 if constexpr (random_access_iterator<_Iter>) {
77 return random_access_iterator_tag{};
78 } else if constexpr (bidirectional_iterator<_Iter>) {
79 return bidirectional_iterator_tag{};
80 } else if constexpr (forward_iterator<_Iter>) {
81 return forward_iterator_tag{};
82 } else {
83 return input_iterator_tag{};
84 }
85 }
86#endif // _LIBCPP_STD_VER >= 20
87
88public:
89#if _LIBCPP_STD_VER >= 20
90 using iterator_type = _Iter;
91 using iterator_concept = decltype(__get_iter_concept());
92 // iterator_category is inherited and not always present
93 using value_type = iter_value_t<_Iter>;
94 using difference_type = iter_difference_t<_Iter>;
95 using pointer = _Iter;
96 using reference = iter_rvalue_reference_t<_Iter>;
97#else
98 typedef _Iter iterator_type;
99 typedef _If< __has_random_access_iterator_category<_Iter>::value,
100 random_access_iterator_tag,
101 typename iterator_traits<_Iter>::iterator_category >
102 iterator_category;
103 typedef typename iterator_traits<iterator_type>::value_type value_type;
104 typedef typename iterator_traits<iterator_type>::difference_type difference_type;
105 typedef iterator_type pointer;
106
107 typedef typename iterator_traits<iterator_type>::reference __reference;
108 typedef __conditional_t<is_reference<__reference>::value, __libcpp_remove_reference_t<__reference>&&, __reference>
109 reference;
110#endif // _LIBCPP_STD_VER >= 20
111
112 _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit move_iterator(_Iter __i) : __current_(std::move(__i)) {}
113
114 _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator++() {
115 ++__current_;
116 return *this;
117 }
118
119 _LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_CONSTEXPR_SINCE_CXX17 pointer operator->() const { return __current_; }
120
121#if _LIBCPP_STD_VER >= 20
122 constexpr move_iterator()
123 requires default_initializable<_Iter>
124 : __current_() {}
125
126 template <class _Up>
127 requires(!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter>
128 constexpr move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
129
130 template <class _Up>
131 requires(!_IsSame<_Up, _Iter>::value) && convertible_to<const _Up&, _Iter> && assignable_from<_Iter&, const _Up&>
132 constexpr move_iterator& operator=(const move_iterator<_Up>& __u) {
133 __current_ = __u.base();
134 return *this;
135 }
136
137 [[nodiscard]] constexpr const _Iter& base() const& noexcept { return __current_; }
138 [[nodiscard]] constexpr _Iter base() && { return std::move(__current_); }
139
140 [[nodiscard]] constexpr reference operator*() const { return ranges::iter_move(__current_); }
141 [[nodiscard]] constexpr reference operator[](difference_type __n) const {
142 return ranges::iter_move(__current_ + __n);
143 }
144
145 constexpr auto operator++(int)
146 requires forward_iterator<_Iter>
147 {
148 move_iterator __tmp(*this);
149 ++__current_;
150 return __tmp;
151 }
152
153 constexpr void operator++(int) { ++__current_; }
154#else
155 _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator() : __current_() {}
156
157 template <class _Up, __enable_if_t< !is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value, int> = 0>
158 _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator(const move_iterator<_Up>& __u) : __current_(__u.base()) {}
159
160 template <class _Up,
161 __enable_if_t< !is_same<_Up, _Iter>::value && is_convertible<const _Up&, _Iter>::value &&
162 is_assignable<_Iter&, const _Up&>::value,
163 int> = 0>
164 _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator=(const move_iterator<_Up>& __u) {
165 __current_ = __u.base();
166 return *this;
167 }
168
169 [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX17 _Iter base() const { return __current_; }
170
171 [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator*() const {
172 return static_cast<reference>(*__current_);
173 }
174 [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](difference_type __n) const {
175 return static_cast<reference>(__current_[__n]);
176 }
177
178 _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator++(int) {
179 move_iterator __tmp(*this);
180 ++__current_;
181 return __tmp;
182 }
183#endif // _LIBCPP_STD_VER >= 20
184
185 _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator--() {
186 --__current_;
187 return *this;
188 }
189 _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator--(int) {
190 move_iterator __tmp(*this);
191 --__current_;
192 return __tmp;
193 }
194 [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator+(difference_type __n) const {
195 return move_iterator(__current_ + __n);
196 }
197 _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator+=(difference_type __n) {
198 __current_ += __n;
199 return *this;
200 }
201 [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator operator-(difference_type __n) const {
202 return move_iterator(__current_ - __n);
203 }
204 _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator& operator-=(difference_type __n) {
205 __current_ -= __n;
206 return *this;
207 }
208
209#if _LIBCPP_STD_VER >= 20
210 template <sentinel_for<_Iter> _Sent>
211 friend constexpr bool operator==(const move_iterator& __x, const move_sentinel<_Sent>& __y)
212 requires __move_iter_comparable<_Iter, _Sent>
213 {
214 return __x.base() == __y.base();
215 }
216
217 template <sized_sentinel_for<_Iter> _Sent>
218 [[nodiscard]] friend constexpr iter_difference_t<_Iter>
219 operator-(const move_sentinel<_Sent>& __x, const move_iterator& __y) {
220 return __x.base() - __y.base();
221 }
222
223 template <sized_sentinel_for<_Iter> _Sent>
224 [[nodiscard]] friend constexpr iter_difference_t<_Iter>
225 operator-(const move_iterator& __x, const move_sentinel<_Sent>& __y) {
226 return __x.base() - __y.base();
227 }
228
229 [[nodiscard]] friend constexpr iter_rvalue_reference_t<_Iter>
230 iter_move(const move_iterator& __i) noexcept(noexcept(ranges::iter_move(__i.__current_))) {
231 return ranges::iter_move(__i.__current_);
232 }
233
234 template <indirectly_swappable<_Iter> _It2>
235 friend constexpr void
236 iter_swap(const move_iterator& __x,
237 const move_iterator<_It2>& __y) noexcept(noexcept(ranges::iter_swap(__x.__current_, __y.__current_))) {
238 return ranges::iter_swap(__x.__current_, __y.__current_);
239 }
240#endif // _LIBCPP_STD_VER >= 20
241
242private:
243 template <class _It2>
244 friend class move_iterator;
245
246 _Iter __current_;
247};
248_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(move_iterator);
249
250template <class _Iter1, class _Iter2>
251inline _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
252operator==(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
253 return __x.base() == __y.base();
254}
255
256#if _LIBCPP_STD_VER <= 17
257template <class _Iter1, class _Iter2>
258inline
259 _LIBCPP_CONSTEXPR_SINCE_CXX17 bool operator!=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
260 return __x.base() != __y.base();
261}
262#endif // _LIBCPP_STD_VER <= 17
263
264template <class _Iter1, class _Iter2>
265inline
266 _LIBCPP_CONSTEXPR_SINCE_CXX17 bool operator<(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
267 return __x.base() < __y.base();
268}
269
270template <class _Iter1, class _Iter2>
271inline _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
272operator>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
273 return __x.base() > __y.base();
274}
275
276template <class _Iter1, class _Iter2>
277inline _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
278operator<=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
279 return __x.base() <= __y.base();
280}
281
282template <class _Iter1, class _Iter2>
283inline _LIBCPP_CONSTEXPR_SINCE_CXX17 bool
284operator>=(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
285 return __x.base() >= __y.base();
286}
287
288#if _LIBCPP_STD_VER >= 20
289template <class _Iter1, three_way_comparable_with<_Iter1> _Iter2>
290inline constexpr auto operator<=>(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
291 -> compare_three_way_result_t<_Iter1, _Iter2> {
292 return __x.base() <=> __y.base();
293}
294#endif // _LIBCPP_STD_VER >= 20
295
296#ifndef _LIBCPP_CXX03_LANG
297template <class _Iter1, class _Iter2>
298[[__nodiscard__]] inline
299 _LIBCPP_CONSTEXPR_SINCE_CXX17 auto operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y)
300 -> decltype(__x.base() - __y.base()) {
301 return __x.base() - __y.base();
302}
303#else
304template <class _Iter1, class _Iter2>
305[[__nodiscard__]] inline typename move_iterator<_Iter1>::difference_type
306operator-(const move_iterator<_Iter1>& __x, const move_iterator<_Iter2>& __y) {
307 return __x.base() - __y.base();
308}
309#endif // !_LIBCPP_CXX03_LANG
310
311#if _LIBCPP_STD_VER >= 20
312template <class _Iter>
313[[nodiscard]] inline constexpr move_iterator<_Iter>
314operator+(iter_difference_t<_Iter> __n, const move_iterator<_Iter>& __x)
315 requires requires {
316 { __x.base() + __n } -> same_as<_Iter>;
317 }
318{
319 return __x + __n;
320}
321#else
322template <class _Iter>
323[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter>
324operator+(typename move_iterator<_Iter>::difference_type __n, const move_iterator<_Iter>& __x) {
325 return move_iterator<_Iter>(__x.base() + __n);
326}
327#endif // _LIBCPP_STD_VER >= 20
328
329#if _LIBCPP_STD_VER >= 20
330template <class _Iter1, class _Iter2>
331 requires(!sized_sentinel_for<_Iter1, _Iter2>)
332inline constexpr bool disable_sized_sentinel_for<move_iterator<_Iter1>, move_iterator<_Iter2>> = true;
333#endif // _LIBCPP_STD_VER >= 20
334
335template <class _Iter>
336[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX17 move_iterator<_Iter> make_move_iterator(_Iter __i) {
337 return move_iterator<_Iter>(std::move(__i));
338}
339
340_LIBCPP_END_NAMESPACE_STD
341
342_LIBCPP_POP_MACROS
343
344#endif // _LIBCPP___ITERATOR_MOVE_ITERATOR_H
345