From Jason Turner

[range.adjacent.transform.iterator]

C++20 → C++23 8.0 KB 242 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/tmpj7ihc3gm/{from.md → to.md} +239 -0
tmp/tmpj7ihc3gm/{from.md → to.md} RENAMED
@@ -0,0 +1,239 @@
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
+ #### Class template `adjacent_transform_view::iterator` <a id="range.adjacent.transform.iterator">[[range.adjacent.transform.iterator]]</a>
2
+
3
+ ``` cpp
4
+ namespace std::ranges {
5
+ template<forward_range V, move_constructible F, size_t N>
6
+ requires view<V> && (N > 0) && is_object_v<F> &&
7
+ regular_invocable<F&, REPEAT(range_reference_t<V>, N)...> &&
8
+ can-reference<invoke_result_t<F&, REPEAT(range_reference_t<V>, N)...>>
9
+ template<bool Const>
10
+ class adjacent_transform_view<V, F, N>::iterator {
11
+ using Parent = maybe-const<Const, adjacent_transform_view>; // exposition only
12
+ using Base = maybe-const<Const, V>; // exposition only
13
+ Parent* parent_ = nullptr; // exposition only
14
+ inner-iterator<Const> inner_; // exposition only
15
+
16
+ constexpr iterator(Parent& parent, inner-iterator<Const> inner); // exposition only
17
+
18
+ public:
19
+ using iterator_category = see below;
20
+ using iterator_concept = typename inner-iterator<Const>::iterator_concept;
21
+ using value_type =
22
+ remove_cvref_t<invoke_result_t<maybe-const<Const, F>&,
23
+ REPEAT(range_reference_t<Base>, N)...>>;
24
+ using difference_type = range_difference_t<Base>;
25
+
26
+ iterator() = default;
27
+ constexpr iterator(iterator<!Const> i)
28
+ requires Const && convertible_to<inner-iterator<false>, inner-iterator<Const>>;
29
+
30
+ constexpr decltype(auto) operator*() const noexcept(see below);
31
+ constexpr iterator& operator++();
32
+ constexpr iterator operator++(int);
33
+ constexpr iterator& operator--() requires bidirectional_range<Base>;
34
+ constexpr iterator operator--(int) requires bidirectional_range<Base>;
35
+ constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;
36
+ constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>;
37
+
38
+ constexpr decltype(auto) operator[](difference_type n) const
39
+ requires random_access_range<Base>;
40
+
41
+ friend constexpr bool operator==(const iterator& x, const iterator& y);
42
+ friend constexpr bool operator<(const iterator& x, const iterator& y)
43
+ requires random_access_range<Base>;
44
+ friend constexpr bool operator>(const iterator& x, const iterator& y)
45
+ requires random_access_range<Base>;
46
+ friend constexpr bool operator<=(const iterator& x, const iterator& y)
47
+ requires random_access_range<Base>;
48
+ friend constexpr bool operator>=(const iterator& x, const iterator& y)
49
+ requires random_access_range<Base>;
50
+ friend constexpr auto operator<=>(const iterator& x, const iterator& y)
51
+ requires random_access_range<Base> && three_way_comparable<inner-iterator<Const>>;
52
+
53
+ friend constexpr iterator operator+(const iterator& i, difference_type n)
54
+ requires random_access_range<Base>;
55
+ friend constexpr iterator operator+(difference_type n, const iterator& i)
56
+ requires random_access_range<Base>;
57
+ friend constexpr iterator operator-(const iterator& i, difference_type n)
58
+ requires random_access_range<Base>;
59
+ friend constexpr difference_type operator-(const iterator& x, const iterator& y)
60
+ requires sized_sentinel_for<inner-iterator<Const>, inner-iterator<Const>>;
61
+ };
62
+ }
63
+ ```
64
+
65
+ The member *typedef-name* `iterator::iterator_category` is defined as
66
+ follows:
67
+
68
+ - If `invoke_result_t<maybe-const<Const, F>&,
69
+ REPEAT(range_reference_t<Base>, N)...>` isnot a reference,
70
+ `iterator_category` denotes `input_iterator_tag`.
71
+ - Otherwise, let `C` denote the type
72
+ `iterator_traits<iterator_t<Base>>::iterator_category`.
73
+ - If `derived_from<C, random_access_iterator_tag>` is `true`,
74
+ `iterator_category` denotes `random_access_iterator_tag`.
75
+ - Otherwise, if `derived_from<C, bidirectional_iterator_tag>` is
76
+ `true`, `iterator_category` denotes `bidirectional_iterator_tag`.
77
+ - Otherwise, if `derived_from<C, forward_iterator_tag>` is `true`,
78
+ `iterator_category` denotes `forward_iterator_tag`.
79
+ - Otherwise, `iterator_category` denotes `input_iterator_tag`.
80
+
81
+ ``` cpp
82
+ constexpr iterator(Parent& parent, inner-iterator<Const> inner);
83
+ ```
84
+
85
+ *Effects:* Initializes *parent\_* with `addressof(parent)` and *inner\_*
86
+ with `std::move(inner)`.
87
+
88
+ ``` cpp
89
+ constexpr iterator(iterator<!Const> i)
90
+ requires Const && convertible_to<inner-iterator<false>, inner-iterator<Const>>;
91
+ ```
92
+
93
+ *Effects:* Initializes *parent\_* with `i.`*`parent_`* and *inner\_*
94
+ with `std::move(i.`*`inner_`*`)`.
95
+
96
+ ``` cpp
97
+ constexpr decltype(auto) operator*() const noexcept(see below);
98
+ ```
99
+
100
+ *Effects:* Equivalent to:
101
+
102
+ ``` cpp
103
+ return apply([&](const auto&... iters) -> decltype(auto) {
104
+ return invoke(*parent_->fun_, *iters...);
105
+ }, inner_.current_);
106
+ ```
107
+
108
+ *Remarks:* Let `Is` be the pack `0, 1, …, (N-1)`. The exception
109
+ specification is equivalent to:
110
+
111
+ ``` cpp
112
+ noexcept(invoke(*parent_->fun_, *std::get<Is>(inner_.current_)...))
113
+ ```
114
+
115
+ ``` cpp
116
+ constexpr iterator& operator++();
117
+ ```
118
+
119
+ *Effects:* Equivalent to:
120
+
121
+ ``` cpp
122
+ ++inner_;
123
+ return *this;
124
+ ```
125
+
126
+ ``` cpp
127
+ constexpr iterator operator++(int);
128
+ ```
129
+
130
+ *Effects:* Equivalent to:
131
+
132
+ ``` cpp
133
+ auto tmp = *this;
134
+ ++*this;
135
+ return tmp;
136
+ ```
137
+
138
+ ``` cpp
139
+ constexpr iterator& operator--() requires bidirectional_range<Base>;
140
+ ```
141
+
142
+ *Effects:* Equivalent to:
143
+
144
+ ``` cpp
145
+ --inner_;
146
+ return *this;
147
+ ```
148
+
149
+ ``` cpp
150
+ constexpr iterator operator--(int) requires bidirectional_range<Base>;
151
+ ```
152
+
153
+ *Effects:* Equivalent to:
154
+
155
+ ``` cpp
156
+ auto tmp = *this;
157
+ --*this;
158
+ return tmp;
159
+ ```
160
+
161
+ ``` cpp
162
+ constexpr iterator& operator+=(difference_type x) requires random_access_range<Base>;
163
+ ```
164
+
165
+ *Effects:* Equivalent to:
166
+
167
+ ``` cpp
168
+ inner_ += x;
169
+ return *this;
170
+ ```
171
+
172
+ ``` cpp
173
+ constexpr iterator& operator-=(difference_type x) requires random_access_range<Base>;
174
+ ```
175
+
176
+ *Effects:* Equivalent to:
177
+
178
+ ``` cpp
179
+ inner_ -= x;
180
+ return *this;
181
+ ```
182
+
183
+ ``` cpp
184
+ constexpr decltype(auto) operator[](difference_type n) const
185
+ requires random_access_range<Base>;
186
+ ```
187
+
188
+ *Effects:* Equivalent to:
189
+
190
+ ``` cpp
191
+ return apply([&](const auto&... iters) -> decltype(auto) {
192
+ return invoke(*parent_->fun_, iters[n]...);
193
+ }, inner_.current_);
194
+ ```
195
+
196
+ ``` cpp
197
+ friend constexpr bool operator==(const iterator& x, const iterator& y);
198
+ friend constexpr bool operator<(const iterator& x, const iterator& y)
199
+ requires random_access_range<Base>;
200
+ friend constexpr bool operator>(const iterator& x, const iterator& y)
201
+ requires random_access_range<Base>;
202
+ friend constexpr bool operator<=(const iterator& x, const iterator& y)
203
+ requires random_access_range<Base>;
204
+ friend constexpr bool operator>=(const iterator& x, const iterator& y)
205
+ requires random_access_range<Base>;
206
+ friend constexpr auto operator<=>(const iterator& x, const iterator& y)
207
+ requires random_access_range<Base> && three_way_comparable<inner-iterator<Const>>;
208
+ ```
209
+
210
+ Let *op* be the operator.
211
+
212
+ *Effects:* Equivalent to:
213
+ `return x.`*`inner_`*` `*`op`*` y.`*`inner_`*`;`
214
+
215
+ ``` cpp
216
+ friend constexpr iterator operator+(const iterator& i, difference_type n)
217
+ requires random_access_range<Base>;
218
+ friend constexpr iterator operator+(difference_type n, const iterator& i)
219
+ requires random_access_range<Base>;
220
+ ```
221
+
222
+ *Effects:* Equivalent to:
223
+ `return `*`iterator`*`(*i.`*`parent_`*`, i.`*`inner_`*` + n);`
224
+
225
+ ``` cpp
226
+ friend constexpr iterator operator-(const iterator& i, difference_type n)
227
+ requires random_access_range<Base>;
228
+ ```
229
+
230
+ *Effects:* Equivalent to:
231
+ `return `*`iterator`*`(*i.`*`parent_`*`, i.`*`inner_`*` - n);`
232
+
233
+ ``` cpp
234
+ friend constexpr difference_type operator-(const iterator& x, const iterator& y)
235
+ requires sized_sentinel_for<inner-iterator<Const>, inner-iterator<Const>>;
236
+ ```
237
+
238
+ *Effects:* Equivalent to: `return x.`*`inner_`*` - y.`*`inner_`*`;`
239
+