From Jason Turner

[re.submatch.op]

C++14 → C++17 11.9 KB 131 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game

Diff to HTML by rtfpessoa

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