From Jason Turner

[re.submatch]

C++17 → C++20 10.5 KB 323 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/tmpvqit0_g0/{from.md → to.md} +22 -295
tmp/tmpvqit0_g0/{from.md → to.md} RENAMED
@@ -28,11 +28,11 @@ namespace std {
28
  int compare(const value_type* s) const;
29
  };
30
  }
31
  ```
32
 
33
- ### `sub_match` members <a id="re.submatch.members">[[re.submatch.members]]</a>
34
 
35
  ``` cpp
36
  constexpr sub_match();
37
  ```
38
 
@@ -73,115 +73,31 @@ int compare(const string_type& s) const;
73
  int compare(const value_type* s) const;
74
  ```
75
 
76
  *Returns:* `str().compare(s)`.
77
 
78
- ### `sub_match` non-member operators <a id="re.submatch.op">[[re.submatch.op]]</a>
 
 
 
 
 
 
79
 
80
  ``` cpp
81
  template<class BiIter>
82
  bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
83
  ```
84
 
85
  *Returns:* `lhs.compare(rhs) == 0`.
86
 
87
  ``` cpp
88
  template<class BiIter>
89
- bool operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
90
  ```
91
 
92
- *Returns:* `lhs.compare(rhs) != 0`.
93
-
94
- ``` cpp
95
- template <class BiIter>
96
- bool operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
97
- ```
98
-
99
- *Returns:* `lhs.compare(rhs) < 0`.
100
-
101
- ``` cpp
102
- template <class BiIter>
103
- bool operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
104
- ```
105
-
106
- *Returns:* `lhs.compare(rhs) <= 0`.
107
-
108
- ``` cpp
109
- template <class BiIter>
110
- bool operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
111
- ```
112
-
113
- *Returns:* `lhs.compare(rhs) >= 0`.
114
-
115
- ``` cpp
116
- template <class BiIter>
117
- bool operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
118
- ```
119
-
120
- *Returns:* `lhs.compare(rhs) > 0`.
121
-
122
- ``` cpp
123
- template <class BiIter, class ST, class SA>
124
- bool operator==(
125
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
126
- const sub_match<BiIter>& rhs);
127
- ```
128
-
129
- *Returns:*
130
-
131
- ``` cpp
132
- rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(), lhs.size())) == 0
133
- ```
134
-
135
- ``` cpp
136
- template <class BiIter, class ST, class SA>
137
- bool operator!=(
138
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
139
- const sub_match<BiIter>& rhs);
140
- ```
141
-
142
- *Returns:* `!(lhs == rhs)`.
143
-
144
- ``` cpp
145
- template <class BiIter, class ST, class SA>
146
- bool operator<(
147
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
148
- const sub_match<BiIter>& rhs);
149
- ```
150
-
151
- *Returns:*
152
-
153
- ``` cpp
154
- rhs.compare(typename sub_match<BiIter>::string_type(lhs.data(), lhs.size())) > 0
155
- ```
156
-
157
- ``` cpp
158
- template <class BiIter, class ST, class SA>
159
- bool operator>(
160
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
161
- const sub_match<BiIter>& rhs);
162
- ```
163
-
164
- *Returns:* `rhs < lhs`.
165
-
166
- ``` cpp
167
- template <class BiIter, class ST, class SA>
168
- bool operator>=(
169
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
170
- const sub_match<BiIter>& rhs);
171
- ```
172
-
173
- *Returns:* `!(lhs < rhs)`.
174
-
175
- ``` cpp
176
- template <class BiIter, class ST, class SA>
177
- bool operator<=(
178
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
179
- const sub_match<BiIter>& rhs);
180
- ```
181
-
182
- *Returns:* `!(rhs < lhs)`.
183
 
184
  ``` cpp
185
  template<class BiIter, class ST, class SA>
186
  bool operator==(
187
  const sub_match<BiIter>& lhs,
@@ -194,202 +110,39 @@ template <class BiIter, class ST, class SA>
194
  lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) == 0
195
  ```
196
 
197
  ``` cpp
198
  template<class BiIter, class ST, class SA>
199
- bool operator!=(
200
- const sub_match<BiIter>& lhs,
201
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
202
- ```
203
-
204
- *Returns:* `!(lhs == rhs)`.
205
-
206
- ``` cpp
207
- template <class BiIter, class ST, class SA>
208
- bool operator<(
209
  const sub_match<BiIter>& lhs,
210
  const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
211
  ```
212
 
213
  *Returns:*
214
 
215
  ``` cpp
216
- lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) < 0
 
 
 
217
  ```
218
 
219
- ``` cpp
220
- template <class BiIter, class ST, class SA>
221
- bool operator>(
222
- const sub_match<BiIter>& lhs,
223
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
224
- ```
225
-
226
- *Returns:* `rhs < lhs`.
227
-
228
- ``` cpp
229
- template <class BiIter, class ST, class SA>
230
- bool operator>=(
231
- const sub_match<BiIter>& lhs,
232
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
233
- ```
234
-
235
- *Returns:* `!(lhs < rhs)`.
236
-
237
- ``` cpp
238
- template <class BiIter, class ST, class SA>
239
- bool operator<=(
240
- const sub_match<BiIter>& lhs,
241
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
242
- ```
243
-
244
- *Returns:* `!(rhs < lhs)`.
245
-
246
- ``` cpp
247
- template <class BiIter>
248
- bool operator==(const typename iterator_traits<BiIter>::value_type* lhs,
249
- const sub_match<BiIter>& rhs);
250
- ```
251
-
252
- *Returns:* `rhs.compare(lhs) == 0`.
253
-
254
- ``` cpp
255
- template <class BiIter>
256
- bool operator!=(const typename iterator_traits<BiIter>::value_type* lhs,
257
- const sub_match<BiIter>& rhs);
258
- ```
259
-
260
- *Returns:* `!(lhs == rhs)`.
261
-
262
- ``` cpp
263
- template <class BiIter>
264
- bool operator<(const typename iterator_traits<BiIter>::value_type* lhs,
265
- const sub_match<BiIter>& rhs);
266
- ```
267
-
268
- *Returns:* `rhs.compare(lhs) > 0`.
269
-
270
- ``` cpp
271
- template <class BiIter>
272
- bool operator>(const typename iterator_traits<BiIter>::value_type* lhs,
273
- const sub_match<BiIter>& rhs);
274
- ```
275
-
276
- *Returns:* `rhs < lhs`.
277
-
278
- ``` cpp
279
- template <class BiIter>
280
- bool operator>=(const typename iterator_traits<BiIter>::value_type* lhs,
281
- const sub_match<BiIter>& rhs);
282
- ```
283
-
284
- *Returns:* `!(lhs < rhs)`.
285
-
286
- ``` cpp
287
- template <class BiIter>
288
- bool operator<=(const typename iterator_traits<BiIter>::value_type* lhs,
289
- const sub_match<BiIter>& rhs);
290
- ```
291
-
292
- *Returns:* `!(rhs < lhs)`.
293
-
294
  ``` cpp
295
  template<class BiIter>
296
  bool operator==(const sub_match<BiIter>& lhs,
297
  const typename iterator_traits<BiIter>::value_type* rhs);
298
  ```
299
 
300
  *Returns:* `lhs.compare(rhs) == 0`.
301
 
302
  ``` cpp
303
  template<class BiIter>
304
- bool operator!=(const sub_match<BiIter>& lhs,
305
  const typename iterator_traits<BiIter>::value_type* rhs);
306
  ```
307
 
308
- *Returns:* `!(lhs == rhs)`.
309
-
310
- ``` cpp
311
- template <class BiIter>
312
- bool operator<(const sub_match<BiIter>& lhs,
313
- const typename iterator_traits<BiIter>::value_type* rhs);
314
- ```
315
-
316
- *Returns:* `lhs.compare(rhs) < 0`.
317
-
318
- ``` cpp
319
- template <class BiIter>
320
- bool operator>(const sub_match<BiIter>& lhs,
321
- const typename iterator_traits<BiIter>::value_type* rhs);
322
- ```
323
-
324
- *Returns:* `rhs < lhs`.
325
-
326
- ``` cpp
327
- template <class BiIter>
328
- bool operator>=(const sub_match<BiIter>& lhs,
329
- const typename iterator_traits<BiIter>::value_type* rhs);
330
- ```
331
-
332
- *Returns:* `!(lhs < rhs)`.
333
-
334
- ``` cpp
335
- template <class BiIter>
336
- bool operator<=(const sub_match<BiIter>& lhs,
337
- const typename iterator_traits<BiIter>::value_type* rhs);
338
- ```
339
-
340
- *Returns:* `!(rhs < lhs)`.
341
-
342
- ``` cpp
343
- template <class BiIter>
344
- bool operator==(const typename iterator_traits<BiIter>::value_type& lhs,
345
- const sub_match<BiIter>& rhs);
346
- ```
347
-
348
- *Returns:*
349
- `rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) == 0`.
350
-
351
- ``` cpp
352
- template <class BiIter>
353
- bool operator!=(const typename iterator_traits<BiIter>::value_type& lhs,
354
- const sub_match<BiIter>& rhs);
355
- ```
356
-
357
- *Returns:* `!(lhs == rhs)`.
358
-
359
- ``` cpp
360
- template <class BiIter>
361
- bool operator<(const typename iterator_traits<BiIter>::value_type& lhs,
362
- const sub_match<BiIter>& rhs);
363
- ```
364
-
365
- *Returns:*
366
- `rhs.compare(typename sub_match<BiIter>::string_type(1, lhs)) > 0`.
367
-
368
- ``` cpp
369
- template <class BiIter>
370
- bool operator>(const typename iterator_traits<BiIter>::value_type& lhs,
371
- const sub_match<BiIter>& rhs);
372
- ```
373
-
374
- *Returns:* `rhs < lhs`.
375
-
376
- ``` cpp
377
- template <class BiIter>
378
- bool operator>=(const typename iterator_traits<BiIter>::value_type& lhs,
379
- const sub_match<BiIter>& rhs);
380
- ```
381
-
382
- *Returns:* `!(lhs < rhs)`.
383
-
384
- ``` cpp
385
- template <class BiIter>
386
- bool operator<=(const typename iterator_traits<BiIter>::value_type& lhs,
387
- const sub_match<BiIter>& rhs);
388
- ```
389
-
390
- *Returns:* `!(rhs < lhs)`.
391
 
392
  ``` cpp
393
  template<class BiIter>
394
  bool operator==(const sub_match<BiIter>& lhs,
395
  const typename iterator_traits<BiIter>::value_type& rhs);
@@ -398,49 +151,23 @@ template <class BiIter>
398
  *Returns:*
399
  `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0`.
400
 
401
  ``` cpp
402
  template<class BiIter>
403
- bool operator!=(const sub_match<BiIter>& lhs,
404
- const typename iterator_traits<BiIter>::value_type& rhs);
405
- ```
406
-
407
- *Returns:* `!(lhs == rhs)`.
408
-
409
- ``` cpp
410
- template <class BiIter>
411
- bool operator<(const sub_match<BiIter>& lhs,
412
  const typename iterator_traits<BiIter>::value_type& rhs);
413
  ```
414
 
415
  *Returns:*
416
- `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) < 0`.
417
 
418
  ``` cpp
419
- template <class BiIter>
420
- bool operator>(const sub_match<BiIter>& lhs,
421
- const typename iterator_traits<BiIter>::value_type& rhs);
 
422
  ```
423
 
424
- *Returns:* `rhs < lhs`.
425
-
426
- ``` cpp
427
- template <class BiIter>
428
- bool operator>=(const sub_match<BiIter>& lhs,
429
- const typename iterator_traits<BiIter>::value_type& rhs);
430
- ```
431
-
432
- *Returns:* `!(lhs < rhs)`.
433
-
434
- ``` cpp
435
- template <class BiIter>
436
- bool operator<=(const sub_match<BiIter>& lhs,
437
- const typename iterator_traits<BiIter>::value_type& rhs);
438
- ```
439
-
440
- *Returns:* `!(rhs < lhs)`.
441
-
442
  ``` cpp
443
  template<class charT, class ST, class BiIter>
444
  basic_ostream<charT, ST>&
445
  operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
446
  ```
 
28
  int compare(const value_type* s) const;
29
  };
30
  }
31
  ```
32
 
33
+ ### Members <a id="re.submatch.members">[[re.submatch.members]]</a>
34
 
35
  ``` cpp
36
  constexpr sub_match();
37
  ```
38
 
 
73
  int compare(const value_type* s) const;
74
  ```
75
 
76
  *Returns:* `str().compare(s)`.
77
 
78
+ ### Non-member operators <a id="re.submatch.op">[[re.submatch.op]]</a>
79
+
80
+ Let `SM-CAT(I)` be
81
+
82
+ ``` cpp
83
+ compare_three_way_result_t<basic_string<typename iterator_traits<I>::value_type>>
84
+ ```
85
 
86
  ``` cpp
87
  template<class BiIter>
88
  bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
89
  ```
90
 
91
  *Returns:* `lhs.compare(rhs) == 0`.
92
 
93
  ``` cpp
94
  template<class BiIter>
95
+ auto operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
96
  ```
97
 
98
+ *Returns:* `static_cast<`*`SM-CAT`*`(BiIter)>(lhs.compare(rhs) <=> 0)`.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
99
 
100
  ``` cpp
101
  template<class BiIter, class ST, class SA>
102
  bool operator==(
103
  const sub_match<BiIter>& lhs,
 
110
  lhs.compare(typename sub_match<BiIter>::string_type(rhs.data(), rhs.size())) == 0
111
  ```
112
 
113
  ``` cpp
114
  template<class BiIter, class ST, class SA>
115
+ auto operator<=>(
 
 
 
 
 
 
 
 
 
116
  const sub_match<BiIter>& lhs,
117
  const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
118
  ```
119
 
120
  *Returns:*
121
 
122
  ``` cpp
123
+ static_cast<SM-CAT(BiIter)>(lhs.compare(
124
+ typename sub_match<BiIter>::string_type(rhs.data(), rhs.size()))
125
+ <=> 0
126
+ )
127
  ```
128
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
129
  ``` cpp
130
  template<class BiIter>
131
  bool operator==(const sub_match<BiIter>& lhs,
132
  const typename iterator_traits<BiIter>::value_type* rhs);
133
  ```
134
 
135
  *Returns:* `lhs.compare(rhs) == 0`.
136
 
137
  ``` cpp
138
  template<class BiIter>
139
+ auto operator<=>(const sub_match<BiIter>& lhs,
140
  const typename iterator_traits<BiIter>::value_type* rhs);
141
  ```
142
 
143
+ *Returns:* `static_cast<`*`SM-CAT`*`(BiIter)>(lhs.compare(rhs) <=> 0)`.
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
144
 
145
  ``` cpp
146
  template<class BiIter>
147
  bool operator==(const sub_match<BiIter>& lhs,
148
  const typename iterator_traits<BiIter>::value_type& rhs);
 
151
  *Returns:*
152
  `lhs.compare(typename sub_match<BiIter>::string_type(1, rhs)) == 0`.
153
 
154
  ``` cpp
155
  template<class BiIter>
156
+ auto operator<=>(const sub_match<BiIter>& lhs,
 
 
 
 
 
 
 
 
157
  const typename iterator_traits<BiIter>::value_type& rhs);
158
  ```
159
 
160
  *Returns:*
 
161
 
162
  ``` cpp
163
+ static_cast<SM-CAT(BiIter)>(lhs.compare(
164
+ typename sub_match<BiIter>::string_type(1, rhs))
165
+ <=> 0
166
+ )
167
  ```
168
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
169
  ``` cpp
170
  template<class charT, class ST, class BiIter>
171
  basic_ostream<charT, ST>&
172
  operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
173
  ```