From Jason Turner

[re.submatch.op]

C++17 → C++20 10.1 KB 320 lines
Current Draft | LaTeX Source
Archived: C++17 | C++20
Markdown: C++17 | C++20
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmpxu1g96gu/{from.md → to.md} +21 -294
tmp/tmpxu1g96gu/{from.md → to.md} RENAMED
@@ -1,110 +1,26 @@
1
- ### `sub_match` non-member operators <a id="re.submatch.op">[[re.submatch.op]]</a>
 
 
 
 
 
 
2
 
3
  ``` cpp
4
  template<class BiIter>
5
  bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
6
  ```
7
 
8
  *Returns:* `lhs.compare(rhs) == 0`.
9
 
10
  ``` cpp
11
  template<class BiIter>
12
- bool operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
13
  ```
14
 
15
- *Returns:* `lhs.compare(rhs) != 0`.
16
-
17
- ``` cpp
18
- template <class BiIter>
19
- bool operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
20
- ```
21
-
22
- *Returns:* `lhs.compare(rhs) < 0`.
23
-
24
- ``` cpp
25
- template <class BiIter>
26
- bool operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
27
- ```
28
-
29
- *Returns:* `lhs.compare(rhs) <= 0`.
30
-
31
- ``` cpp
32
- template <class BiIter>
33
- bool operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
34
- ```
35
-
36
- *Returns:* `lhs.compare(rhs) >= 0`.
37
-
38
- ``` cpp
39
- template <class BiIter>
40
- bool operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
41
- ```
42
-
43
- *Returns:* `lhs.compare(rhs) > 0`.
44
-
45
- ``` cpp
46
- template <class BiIter, class ST, class SA>
47
- bool operator==(
48
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
49
- const sub_match<BiIter>& rhs);
50
- ```
51
-
52
- *Returns:*
53
-
54
- ``` cpp
55
- rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(), lhs.size())) == 0
56
- ```
57
-
58
- ``` cpp
59
- template <class BiIter, class ST, class SA>
60
- bool operator!=(
61
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
62
- const sub_match<BiIter>& rhs);
63
- ```
64
-
65
- *Returns:* `!(lhs == rhs)`.
66
-
67
- ``` cpp
68
- template <class BiIter, class ST, class SA>
69
- bool operator<(
70
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
71
- const sub_match<BiIter>& rhs);
72
- ```
73
-
74
- *Returns:*
75
-
76
- ``` cpp
77
- rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(), lhs.size())) > 0
78
- ```
79
-
80
- ``` cpp
81
- template <class BiIter, class ST, class SA>
82
- bool operator>(
83
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
84
- const sub_match<BiIter>& rhs);
85
- ```
86
-
87
- *Returns:* `rhs < lhs`.
88
-
89
- ``` cpp
90
- template <class BiIter, class ST, class SA>
91
- bool operator>=(
92
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
93
- const sub_match<BiIter>& rhs);
94
- ```
95
-
96
- *Returns:* `!(lhs < rhs)`.
97
-
98
- ``` cpp
99
- template <class BiIter, class ST, class SA>
100
- bool operator<=(
101
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
102
- const sub_match<BiIter>& rhs);
103
- ```
104
-
105
- *Returns:* `!(rhs < lhs)`.
106
 
107
  ``` cpp
108
  template<class BiIter, class ST, class SA>
109
  bool operator==(
110
  const sub_match<BiIter>& lhs,
@@ -117,202 +33,39 @@ template <class BiIter, class ST, class SA>
117
  lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) == 0
118
  ```
119
 
120
  ``` cpp
121
  template<class BiIter, class ST, class SA>
122
- bool operator!=(
123
- const sub_match<BiIter>& lhs,
124
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
125
- ```
126
-
127
- *Returns:* `!(lhs == rhs)`.
128
-
129
- ``` cpp
130
- template <class BiIter, class ST, class SA>
131
- bool operator<(
132
  const sub_match<BiIter>& lhs,
133
  const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
134
  ```
135
 
136
  *Returns:*
137
 
138
  ``` cpp
139
- lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) < 0
 
 
 
140
  ```
141
 
142
- ``` cpp
143
- template <class BiIter, class ST, class SA>
144
- bool operator>(
145
- const sub_match<BiIter>& lhs,
146
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
147
- ```
148
-
149
- *Returns:* `rhs < lhs`.
150
-
151
- ``` cpp
152
- template <class BiIter, class ST, class SA>
153
- bool operator>=(
154
- const sub_match<BiIter>& lhs,
155
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
156
- ```
157
-
158
- *Returns:* `!(lhs < rhs)`.
159
-
160
- ``` cpp
161
- template <class BiIter, class ST, class SA>
162
- bool operator<=(
163
- const sub_match<BiIter>& lhs,
164
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
165
- ```
166
-
167
- *Returns:* `!(rhs < lhs)`.
168
-
169
- ``` cpp
170
- template <class BiIter>
171
- bool operator==(const typename iterator_traits<BiIter>::value_type* lhs,
172
- const sub_match<BiIter>& rhs);
173
- ```
174
-
175
- *Returns:* `rhs.compare(lhs) == 0`.
176
-
177
- ``` cpp
178
- template <class BiIter>
179
- bool operator!=(const typename iterator_traits<BiIter>::value_type* lhs,
180
- const sub_match<BiIter>& rhs);
181
- ```
182
-
183
- *Returns:* `!(lhs == rhs)`.
184
-
185
- ``` cpp
186
- template <class BiIter>
187
- bool operator<(const typename iterator_traits<BiIter>::value_type* lhs,
188
- const sub_match<BiIter>& rhs);
189
- ```
190
-
191
- *Returns:* `rhs.compare(lhs) > 0`.
192
-
193
- ``` cpp
194
- template <class BiIter>
195
- bool operator>(const typename iterator_traits<BiIter>::value_type* lhs,
196
- const sub_match<BiIter>& rhs);
197
- ```
198
-
199
- *Returns:* `rhs < lhs`.
200
-
201
- ``` cpp
202
- template <class BiIter>
203
- bool operator>=(const typename iterator_traits<BiIter>::value_type* lhs,
204
- const sub_match<BiIter>& rhs);
205
- ```
206
-
207
- *Returns:* `!(lhs < rhs)`.
208
-
209
- ``` cpp
210
- template <class BiIter>
211
- bool operator<=(const typename iterator_traits<BiIter>::value_type* lhs,
212
- const sub_match<BiIter>& rhs);
213
- ```
214
-
215
- *Returns:* `!(rhs < lhs)`.
216
-
217
  ``` cpp
218
  template<class BiIter>
219
  bool operator==(const sub_match<BiIter>& lhs,
220
  const typename iterator_traits<BiIter>::value_type* rhs);
221
  ```
222
 
223
  *Returns:* `lhs.compare(rhs) == 0`.
224
 
225
  ``` cpp
226
  template<class BiIter>
227
- bool operator!=(const sub_match<BiIter>& lhs,
228
  const typename iterator_traits<BiIter>::value_type* rhs);
229
  ```
230
 
231
- *Returns:* `!(lhs == rhs)`.
232
-
233
- ``` cpp
234
- template <class BiIter>
235
- bool operator<(const sub_match<BiIter>& lhs,
236
- const typename iterator_traits<BiIter>::value_type* rhs);
237
- ```
238
-
239
- *Returns:* `lhs.compare(rhs) < 0`.
240
-
241
- ``` cpp
242
- template <class BiIter>
243
- bool operator>(const sub_match<BiIter>& lhs,
244
- const typename iterator_traits<BiIter>::value_type* rhs);
245
- ```
246
-
247
- *Returns:* `rhs < lhs`.
248
-
249
- ``` cpp
250
- template <class BiIter>
251
- bool operator>=(const sub_match<BiIter>& lhs,
252
- const typename iterator_traits<BiIter>::value_type* rhs);
253
- ```
254
-
255
- *Returns:* `!(lhs < rhs)`.
256
-
257
- ``` cpp
258
- template <class BiIter>
259
- bool operator<=(const sub_match<BiIter>& lhs,
260
- const typename iterator_traits<BiIter>::value_type* rhs);
261
- ```
262
-
263
- *Returns:* `!(rhs < lhs)`.
264
-
265
- ``` cpp
266
- template <class BiIter>
267
- bool operator==(const typename iterator_traits<BiIter>::value_type& lhs,
268
- const sub_match<BiIter>& rhs);
269
- ```
270
-
271
- *Returns:*
272
- `rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) == 0`.
273
-
274
- ``` cpp
275
- template <class BiIter>
276
- bool operator!=(const typename iterator_traits<BiIter>::value_type& lhs,
277
- const sub_match<BiIter>& rhs);
278
- ```
279
-
280
- *Returns:* `!(lhs == rhs)`.
281
-
282
- ``` cpp
283
- template <class BiIter>
284
- bool operator<(const typename iterator_traits<BiIter>::value_type& lhs,
285
- const sub_match<BiIter>& rhs);
286
- ```
287
-
288
- *Returns:*
289
- `rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) > 0`.
290
-
291
- ``` cpp
292
- template <class BiIter>
293
- bool operator>(const typename iterator_traits<BiIter>::value_type& lhs,
294
- const sub_match<BiIter>& rhs);
295
- ```
296
-
297
- *Returns:* `rhs < lhs`.
298
-
299
- ``` cpp
300
- template <class BiIter>
301
- bool operator>=(const typename iterator_traits<BiIter>::value_type& lhs,
302
- const sub_match<BiIter>& rhs);
303
- ```
304
-
305
- *Returns:* `!(lhs < rhs)`.
306
-
307
- ``` cpp
308
- template <class BiIter>
309
- bool operator<=(const typename iterator_traits<BiIter>::value_type& lhs,
310
- const sub_match<BiIter>& rhs);
311
- ```
312
-
313
- *Returns:* `!(rhs < lhs)`.
314
 
315
  ``` cpp
316
  template<class BiIter>
317
  bool operator==(const sub_match<BiIter>& lhs,
318
  const typename iterator_traits<BiIter>::value_type& rhs);
@@ -321,49 +74,23 @@ template <class BiIter>
321
  *Returns:*
322
  `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0`.
323
 
324
  ``` cpp
325
  template<class BiIter>
326
- bool operator!=(const sub_match<BiIter>& lhs,
327
- const typename iterator_traits<BiIter>::value_type& rhs);
328
- ```
329
-
330
- *Returns:* `!(lhs == rhs)`.
331
-
332
- ``` cpp
333
- template <class BiIter>
334
- bool operator<(const sub_match<BiIter>& lhs,
335
  const typename iterator_traits<BiIter>::value_type& rhs);
336
  ```
337
 
338
  *Returns:*
339
- `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) < 0`.
340
 
341
  ``` cpp
342
- template <class BiIter>
343
- bool operator>(const sub_match<BiIter>& lhs,
344
- const typename iterator_traits<BiIter>::value_type& rhs);
 
345
  ```
346
 
347
- *Returns:* `rhs < lhs`.
348
-
349
- ``` cpp
350
- template <class BiIter>
351
- bool operator>=(const sub_match<BiIter>& lhs,
352
- const typename iterator_traits<BiIter>::value_type& rhs);
353
- ```
354
-
355
- *Returns:* `!(lhs < rhs)`.
356
-
357
- ``` cpp
358
- template <class BiIter>
359
- bool operator<=(const sub_match<BiIter>& lhs,
360
- const typename iterator_traits<BiIter>::value_type& rhs);
361
- ```
362
-
363
- *Returns:* `!(rhs < lhs)`.
364
-
365
  ``` cpp
366
  template<class charT, class ST, class BiIter>
367
  basic_ostream<charT, ST>&
368
  operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
369
  ```
 
1
+ ### Non-member operators <a id="re.submatch.op">[[re.submatch.op]]</a>
2
+
3
+ Let `SM-CAT(I)` be
4
+
5
+ ``` cpp
6
+ compare_three_way_result_t<basic_string<typename iterator_traits<I>::value_type>>
7
+ ```
8
 
9
  ``` cpp
10
  template<class BiIter>
11
  bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
12
  ```
13
 
14
  *Returns:* `lhs.compare(rhs) == 0`.
15
 
16
  ``` cpp
17
  template<class BiIter>
18
+ auto operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
19
  ```
20
 
21
+ *Returns:* `static_cast<`*`SM-CAT`*`(BiIter)>(lhs.compare(rhs) <=> 0)`.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
22
 
23
  ``` cpp
24
  template<class BiIter, class ST, class SA>
25
  bool operator==(
26
  const sub_match<BiIter>& lhs,
 
33
  lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) == 0
34
  ```
35
 
36
  ``` cpp
37
  template<class BiIter, class ST, class SA>
38
+ auto operator<=>(
 
 
 
 
 
 
 
 
 
39
  const sub_match<BiIter>& lhs,
40
  const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
41
  ```
42
 
43
  *Returns:*
44
 
45
  ``` cpp
46
+ static_cast<SM-CAT(BiIter)>(lhs.compare(
47
+ typename sub_match<BiIter>::string_type(rhs.data(), rhs.size()))
48
+ <=> 0
49
+ )
50
  ```
51
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
52
  ``` cpp
53
  template<class BiIter>
54
  bool operator==(const sub_match<BiIter>& lhs,
55
  const typename iterator_traits<BiIter>::value_type* rhs);
56
  ```
57
 
58
  *Returns:* `lhs.compare(rhs) == 0`.
59
 
60
  ``` cpp
61
  template<class BiIter>
62
+ auto operator<=>(const sub_match<BiIter>& lhs,
63
  const typename iterator_traits<BiIter>::value_type* rhs);
64
  ```
65
 
66
+ *Returns:* `static_cast<`*`SM-CAT`*`(BiIter)>(lhs.compare(rhs) <=> 0)`.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
67
 
68
  ``` cpp
69
  template<class BiIter>
70
  bool operator==(const sub_match<BiIter>& lhs,
71
  const typename iterator_traits<BiIter>::value_type& rhs);
 
74
  *Returns:*
75
  `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0`.
76
 
77
  ``` cpp
78
  template<class BiIter>
79
+ auto operator<=>(const sub_match<BiIter>& lhs,
 
 
 
 
 
 
 
 
80
  const typename iterator_traits<BiIter>::value_type& rhs);
81
  ```
82
 
83
  *Returns:*
 
84
 
85
  ``` cpp
86
+ static_cast<SM-CAT(BiIter)>(lhs.compare(
87
+ typename sub_match<BiIter>::string_type(1, rhs))
88
+ <=> 0
89
+ )
90
  ```
91
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
92
  ``` cpp
93
  template<class charT, class ST, class BiIter>
94
  basic_ostream<charT, ST>&
95
  operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
96
  ```