From Jason Turner

[range.stride.iterator]

C++20 → C++23 11.0 KB 352 lines
Current Draft | LaTeX Source
Archived: C++20 | C++23
Markdown: C++20 | C++23
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpu6z51udu/{from.md → to.md} +349 -0
tmp/tmpu6z51udu/{from.md → to.md} RENAMED
@@ -0,0 +1,349 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #### Class template `stride_view::iterator` <a id="range.stride.iterator">[[range.stride.iterator]]</a>
2
+
3
+ ``` cpp
4
+ namespace std::ranges {
5
+ template<input_range V>
6
+ requires view<V>
7
+ template<bool Const>
8
+ class stride_view<V>::iterator {
9
+ using Parent = maybe-const<Const, stride_view>; // exposition only
10
+ using Base = maybe-const<Const, V>; // exposition only
11
+
12
+ iterator_t<Base> current_ = iterator_t<Base>(); // exposition only
13
+ sentinel_t<Base> end_ = sentinel_t<Base>(); // exposition only
14
+ range_difference_t<Base> stride_ = 0; // exposition only
15
+ range_difference_t<Base> missing_ = 0; // exposition only
16
+
17
+ constexpr iterator(Parent* parent, iterator_t<Base> current, // exposition only
18
+ range_difference_t<Base> missing = 0);
19
+ public:
20
+ using difference_type = range_difference_t<Base>;
21
+ using value_type = range_value_t<Base>;
22
+ using iterator_concept = see below;
23
+ using iterator_category = see below; // not always present
24
+
25
+ iterator() requires default_initializable<iterator_t<Base>> = default;
26
+
27
+ constexpr iterator(iterator<!Const> other)
28
+ requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>
29
+ && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
30
+
31
+ constexpr iterator_t<Base> base() &&;
32
+ constexpr const iterator_t<Base>& base() const & noexcept;
33
+
34
+ constexpr decltype(auto) operator*() const { return *current_; }
35
+
36
+ constexpr iterator& operator++();
37
+ constexpr void operator++(int);
38
+ constexpr iterator operator++(int) requires forward_range<Base>;
39
+
40
+ constexpr iterator& operator--() requires bidirectional_range<Base>;
41
+ constexpr iterator operator--(int) requires bidirectional_range<Base>;
42
+
43
+ constexpr iterator& operator+=(difference_type n) requires random_access_range<Base>;
44
+ constexpr iterator& operator-=(difference_type n) requires random_access_range<Base>;
45
+
46
+ constexpr decltype(auto) operator[](difference_type n) const
47
+ requires random_access_range<Base>
48
+ { return *(*this + n); }
49
+
50
+ friend constexpr bool operator==(const iterator& x, default_sentinel_t);
51
+
52
+ friend constexpr bool operator==(const iterator& x, const iterator& y)
53
+ requires equality_comparable<iterator_t<Base>>;
54
+
55
+ friend constexpr bool operator<(const iterator& x, const iterator& y)
56
+ requires random_access_range<Base>;
57
+
58
+ friend constexpr bool operator>(const iterator& x, const iterator& y)
59
+ requires random_access_range<Base>;
60
+
61
+ friend constexpr bool operator<=(const iterator& x, const iterator& y)
62
+ requires random_access_range<Base>;
63
+
64
+ friend constexpr bool operator>=(const iterator& x, const iterator& y)
65
+ requires random_access_range<Base>;
66
+
67
+ friend constexpr auto operator<=>(const iterator& x, const iterator& y)
68
+ requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;
69
+
70
+ friend constexpr iterator operator+(const iterator& x, difference_type n)
71
+ requires random_access_range<Base>;
72
+ friend constexpr iterator operator+(difference_type n, const iterator& x)
73
+ requires random_access_range<Base>;
74
+ friend constexpr iterator operator-(const iterator& x, difference_type n)
75
+ requires random_access_range<Base>;
76
+ friend constexpr difference_type operator-(const iterator& x, const iterator& y)
77
+ requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;
78
+
79
+ friend constexpr difference_type operator-(default_sentinel_t y, const iterator& x)
80
+ requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
81
+ friend constexpr difference_type operator-(const iterator& x, default_sentinel_t y)
82
+ requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
83
+
84
+ friend constexpr range_rvalue_reference_t<Base> iter_move(const iterator& i)
85
+ noexcept(noexcept(ranges::iter_move(i.current_)));
86
+
87
+ friend constexpr void iter_swap(const iterator& x, const iterator& y)
88
+ noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
89
+ requires indirectly_swappable<iterator_t<Base>>;
90
+ };
91
+ }
92
+ ```
93
+
94
+ `iterator::iterator_concept` is defined as follows:
95
+
96
+ - If *`Base`* models `random_access_range`, then `iterator_concept`
97
+ denotes `random_access_iterator_tag`.
98
+ - Otherwise, if *`Base`* models `bidirectional_range`, then
99
+ `iterator_concept` denotes `bidirectional_iterator_tag`.
100
+ - Otherwise, if *`Base`* models `forward_range`, then `iterator_concept`
101
+ denotes `forward_iterator_tag`.
102
+ - Otherwise, `iterator_concept` denotes `input_iterator_tag`.
103
+
104
+ The member *typedef-name* `iterator_category` is defined if and only if
105
+ *`Base`* models `forward_range`. In that case,
106
+ `iterator::iterator_category` is defined as follows:
107
+
108
+ - Let `C` denote the type
109
+ `iterator_traits<iterator_t<Base>>::iterator_category`.
110
+ - If `C` models `derived_from<random_access_iterator_tag>`, then
111
+ `iterator_category` denotes `random_access_iterator_tag`.
112
+ - Otherwise, `iterator_category` denotes `C`.
113
+
114
+ ``` cpp
115
+ constexpr iterator(Parent* parent, iterator_t<Base> current,
116
+ range_difference_t<Base> missing = 0);
117
+ ```
118
+
119
+ *Effects:* Initializes *current\_* with `std::move(current)`, *end\_*
120
+ with `ranges::end(parent->`*`base_`*`)`, *stride\_* with
121
+ `parent->`*`stride_`*, and *missing\_* with `missing`.
122
+
123
+ ``` cpp
124
+ constexpr iterator(iterator<!Const> i)
125
+ requires Const && convertible_to<iterator_t<V>, iterator_t<Base>>
126
+ && convertible_to<sentinel_t<V>, sentinel_t<Base>>;
127
+ ```
128
+
129
+ *Effects:* Initializes *current\_* with `std::move(i.`*`current_`*`)`,
130
+ *end\_* with `std::move(i.`*`end_`*`)`, *stride\_* with `i.`*`stride_`*,
131
+ and *missing\_* with `i.`*`missing_`*.
132
+
133
+ ``` cpp
134
+ constexpr iterator_t<Base> base() &&;
135
+ ```
136
+
137
+ *Returns:* `std::move(`*`current_`*`)`.
138
+
139
+ ``` cpp
140
+ constexpr const iterator_t<Base>& base() const & noexcept;
141
+ ```
142
+
143
+ *Returns:* *current\_*.
144
+
145
+ ``` cpp
146
+ constexpr iterator& operator++();
147
+ ```
148
+
149
+ *Preconditions:* *`current_`*` != `*`end_`* is `true`.
150
+
151
+ *Effects:* Equivalent to:
152
+
153
+ ``` cpp
154
+ missing_ = ranges::advance(current_, stride_, end_);
155
+ return *this;
156
+ ```
157
+
158
+ ``` cpp
159
+ constexpr void operator++(int);
160
+ ```
161
+
162
+ *Effects:* Equivalent to: `++*this;`
163
+
164
+ ``` cpp
165
+ constexpr iterator operator++(int) requires forward_range<Base>;
166
+ ```
167
+
168
+ *Effects:* Equivalent to:
169
+
170
+ ``` cpp
171
+ auto tmp = *this;
172
+ ++*this;
173
+ return tmp;
174
+ ```
175
+
176
+ ``` cpp
177
+ constexpr iterator& operator--() requires bidirectional_range<Base>;
178
+ ```
179
+
180
+ *Effects:* Equivalent to:
181
+
182
+ ``` cpp
183
+ ranges::advance(current_, missing_ - stride_);
184
+ missing_ = 0;
185
+ return *this;
186
+ ```
187
+
188
+ ``` cpp
189
+ constexpr iterator operator--(int) requires bidirectional_range<Base>;
190
+ ```
191
+
192
+ *Effects:* Equivalent to:
193
+
194
+ ``` cpp
195
+ auto tmp = *this;
196
+ --*this;
197
+ return tmp;
198
+ ```
199
+
200
+ ``` cpp
201
+ constexpr iterator& operator+=(difference_type n) requires random_access_range<Base>;
202
+ ```
203
+
204
+ *Preconditions:* If `n` is positive,
205
+ `ranges::distance(`*`current_`*`, `*`end_`*`) > `*`stride_`*` * (n - 1)`
206
+ is `true`.
207
+
208
+ [*Note 1*: If `n` is negative, the *Effects* paragraph implies a
209
+ precondition. — *end note*]
210
+
211
+ *Effects:* Equivalent to:
212
+
213
+ ``` cpp
214
+ if (n > 0) {
215
+ ranges::advance(current_, stride_ * (n - 1));
216
+ missing_ = ranges::advance(current_, stride_, end_);
217
+ } else if (n < 0) {
218
+ ranges::advance(current_, stride_ * n + missing_);
219
+ missing_ = 0;
220
+ }
221
+ return *this;
222
+ ```
223
+
224
+ ``` cpp
225
+ constexpr iterator& operator-=(difference_type x)
226
+ requires random_access_range<Base>;
227
+ ```
228
+
229
+ *Effects:* Equivalent to: `return *this += -x;`
230
+
231
+ ``` cpp
232
+ friend constexpr bool operator==(const iterator& x, default_sentinel_t);
233
+ ```
234
+
235
+ *Returns:* `x.`*`current_`*` == x.`*`end_`*.
236
+
237
+ ``` cpp
238
+ friend constexpr bool operator==(const iterator& x, const iterator& y)
239
+ requires equality_comparable<iterator_t<Base>>;
240
+ ```
241
+
242
+ *Returns:* `x.`*`current_`*` == y.`*`current_`*.
243
+
244
+ ``` cpp
245
+ friend constexpr bool operator<(const iterator& x, const iterator& y)
246
+ requires random_access_range<Base>;
247
+ ```
248
+
249
+ *Returns:* `x.`*`current_`*` < y.`*`current_`*.
250
+
251
+ ``` cpp
252
+ friend constexpr bool operator>(const iterator& x, const iterator& y)
253
+ requires random_access_range<Base>;
254
+ ```
255
+
256
+ *Effects:* Equivalent to: `return y < x;`
257
+
258
+ ``` cpp
259
+ friend constexpr bool operator<=(const iterator& x, const iterator& y)
260
+ requires random_access_range<Base>;
261
+ ```
262
+
263
+ *Effects:* Equivalent to: `return !(y < x);`
264
+
265
+ ``` cpp
266
+ friend constexpr bool operator>=(const iterator& x, const iterator& y)
267
+ requires random_access_range<Base>;
268
+ ```
269
+
270
+ *Effects:* Equivalent to: `return !(x < y);`
271
+
272
+ ``` cpp
273
+ friend constexpr auto operator<=>(const iterator& x, const iterator& y)
274
+ requires random_access_range<Base> && three_way_comparable<iterator_t<Base>>;
275
+ ```
276
+
277
+ *Returns:* `x.`*`current_`*` <=> y.`*`current_`*.
278
+
279
+ ``` cpp
280
+ friend constexpr iterator operator+(const iterator& i, difference_type n)
281
+ requires random_access_range<Base>;
282
+ friend constexpr iterator operator+(difference_type n, const iterator& i)
283
+ requires random_access_range<Base>;
284
+ ```
285
+
286
+ *Effects:* Equivalent to:
287
+
288
+ ``` cpp
289
+ auto r = i;
290
+ r += n;
291
+ return r;
292
+ ```
293
+
294
+ ``` cpp
295
+ friend constexpr iterator operator-(const iterator& i, difference_type n)
296
+ requires random_access_range<Base>;
297
+ ```
298
+
299
+ *Effects:* Equivalent to:
300
+
301
+ ``` cpp
302
+ auto r = i;
303
+ r -= n;
304
+ return r;
305
+ ```
306
+
307
+ ``` cpp
308
+ friend constexpr difference_type operator-(const iterator& x, const iterator& y)
309
+ requires sized_sentinel_for<iterator_t<Base>, iterator_t<Base>>;
310
+ ```
311
+
312
+ *Returns:* Let `N` be `(x.`*`current_`*` - y.`*`current_`*`)`.
313
+
314
+ - If *Base* models `forward_range`,
315
+ `(N + x.`*`missing_`*` - y.`*`missing_`*`) / x.`*`stride_`*.
316
+ - Otherwise, if `N` is negative, `-`*`div-ceil`*`(-N, x.`*`stride_`*`)`.
317
+ - Otherwise, *`div-ceil`*`(N, x.`*`stride_`*`)`.
318
+
319
+ ``` cpp
320
+ friend constexpr difference_type operator-(default_sentinel_t y, const iterator& x)
321
+ requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
322
+ ```
323
+
324
+ *Returns:*
325
+ *`div-ceil`*`(x.`*`end_`*` - x.`*`current_`*`, x.`*`stride_`*`)`.
326
+
327
+ ``` cpp
328
+ friend constexpr difference_type operator-(const iterator& x, default_sentinel_t y)
329
+ requires sized_sentinel_for<sentinel_t<Base>, iterator_t<Base>>;
330
+ ```
331
+
332
+ *Effects:* Equivalent to: `return -(y - x);`
333
+
334
+ ``` cpp
335
+ friend constexpr range_rvalue_reference_t<Base> iter_move(const iterator& i)
336
+ noexcept(noexcept(ranges::iter_move(i.current_)));
337
+ ```
338
+
339
+ *Effects:* Equivalent to: `return ranges::iter_move(i.`*`current_`*`);`
340
+
341
+ ``` cpp
342
+ friend constexpr void iter_swap(const iterator& x, const iterator& y)
343
+ noexcept(noexcept(ranges::iter_swap(x.current_, y.current_)))
344
+ requires indirectly_swappable<iterator_t<Base>>;
345
+ ```
346
+
347
+ *Effects:* Equivalent to:
348
+ `ranges::iter_swap(x.`*`current_`*`, y.`*`current_`*`);`
349
+