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

source code of flutter_engine/third_party/libcxx/include/__iterator/move_iterator.h