From Jason Turner

[re.syn]

C++17 → C++20 8.3 KB 130 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/tmpa1tw7kmg/{from.md → to.md} +6 -119
tmp/tmpa1tw7kmg/{from.md → to.md} RENAMED
@@ -1,9 +1,10 @@
1
  ## Header `<regex>` synopsis <a id="re.syn">[[re.syn]]</a>
2
 
3
  ``` cpp
4
- #include <initializer_list>
 
5
 
6
  namespace std {
7
  // [re.const], regex constants
8
  namespace regex_constants {
9
  using syntax_option_type = T1;
@@ -38,144 +39,33 @@ namespace std {
38
 
39
  // [re.submatch.op], sub_match non-member operators
40
  template<class BiIter>
41
  bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
42
  template<class BiIter>
43
- bool operator!=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
44
- template <class BiIter>
45
- bool operator<(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
46
- template <class BiIter>
47
- bool operator<=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
48
- template <class BiIter>
49
- bool operator>=(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
50
- template <class BiIter>
51
- bool operator>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
52
-
53
- template <class BiIter, class ST, class SA>
54
- bool operator==(
55
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
56
- const sub_match<BiIter>& rhs);
57
- template <class BiIter, class ST, class SA>
58
- bool operator!=(
59
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
60
- const sub_match<BiIter>& rhs);
61
- template <class BiIter, class ST, class SA>
62
- bool operator<(
63
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
64
- const sub_match<BiIter>& rhs);
65
- template <class BiIter, class ST, class SA>
66
- bool operator>(
67
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
68
- const sub_match<BiIter>& rhs);
69
- template <class BiIter, class ST, class SA>
70
- bool operator>=(
71
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
72
- const sub_match<BiIter>& rhs);
73
- template <class BiIter, class ST, class SA>
74
- bool operator<=(
75
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& lhs,
76
- const sub_match<BiIter>& rhs);
77
 
78
  template<class BiIter, class ST, class SA>
79
  bool operator==(
80
  const sub_match<BiIter>& lhs,
81
  const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
82
  template<class BiIter, class ST, class SA>
83
- bool operator!=(
84
  const sub_match<BiIter>& lhs,
85
  const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
86
- template <class BiIter, class ST, class SA>
87
- bool operator<(
88
- const sub_match<BiIter>& lhs,
89
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
90
- template <class BiIter, class ST, class SA>
91
- bool operator>(
92
- const sub_match<BiIter>& lhs,
93
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
94
- template <class BiIter, class ST, class SA>
95
- bool operator>=(
96
- const sub_match<BiIter>& lhs,
97
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
98
- template <class BiIter, class ST, class SA>
99
- bool operator<=(
100
- const sub_match<BiIter>& lhs,
101
- const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
102
-
103
- template <class BiIter>
104
- bool operator==(const typename iterator_traits<BiIter>::value_type* lhs,
105
- const sub_match<BiIter>& rhs);
106
- template <class BiIter>
107
- bool operator!=(const typename iterator_traits<BiIter>::value_type* lhs,
108
- const sub_match<BiIter>& rhs);
109
- template <class BiIter>
110
- bool operator<(const typename iterator_traits<BiIter>::value_type* lhs,
111
- const sub_match<BiIter>& rhs);
112
- template <class BiIter>
113
- bool operator>(const typename iterator_traits<BiIter>::value_type* lhs,
114
- const sub_match<BiIter>& rhs);
115
- template <class BiIter>
116
- bool operator>=(const typename iterator_traits<BiIter>::value_type* lhs,
117
- const sub_match<BiIter>& rhs);
118
- template <class BiIter>
119
- bool operator<=(const typename iterator_traits<BiIter>::value_type* lhs,
120
- const sub_match<BiIter>& rhs);
121
 
122
  template<class BiIter>
123
  bool operator==(const sub_match<BiIter>& lhs,
124
  const typename iterator_traits<BiIter>::value_type* rhs);
125
  template<class BiIter>
126
- bool operator!=(const sub_match<BiIter>& lhs,
127
- const typename iterator_traits<BiIter>::value_type* rhs);
128
- template <class BiIter>
129
- bool operator<(const sub_match<BiIter>& lhs,
130
- const typename iterator_traits<BiIter>::value_type* rhs);
131
- template <class BiIter>
132
- bool operator>(const sub_match<BiIter>& lhs,
133
- const typename iterator_traits<BiIter>::value_type* rhs);
134
- template <class BiIter>
135
- bool operator>=(const sub_match<BiIter>& lhs,
136
- const typename iterator_traits<BiIter>::value_type* rhs);
137
- template <class BiIter>
138
- bool operator<=(const sub_match<BiIter>& lhs,
139
  const typename iterator_traits<BiIter>::value_type* rhs);
140
 
141
- template <class BiIter>
142
- bool operator==(const typename iterator_traits<BiIter>::value_type& lhs,
143
- const sub_match<BiIter>& rhs);
144
- template <class BiIter>
145
- bool operator!=(const typename iterator_traits<BiIter>::value_type& lhs,
146
- const sub_match<BiIter>& rhs);
147
- template <class BiIter>
148
- bool operator<(const typename iterator_traits<BiIter>::value_type& lhs,
149
- const sub_match<BiIter>& rhs);
150
- template <class BiIter>
151
- bool operator>(const typename iterator_traits<BiIter>::value_type& lhs,
152
- const sub_match<BiIter>& rhs);
153
- template <class BiIter>
154
- bool operator>=(const typename iterator_traits<BiIter>::value_type& lhs,
155
- const sub_match<BiIter>& rhs);
156
- template <class BiIter>
157
- bool operator<=(const typename iterator_traits<BiIter>::value_type& lhs,
158
- const sub_match<BiIter>& rhs);
159
-
160
  template<class BiIter>
161
  bool operator==(const sub_match<BiIter>& lhs,
162
  const typename iterator_traits<BiIter>::value_type& rhs);
163
  template<class BiIter>
164
- bool operator!=(const sub_match<BiIter>& lhs,
165
- const typename iterator_traits<BiIter>::value_type& rhs);
166
- template <class BiIter>
167
- bool operator<(const sub_match<BiIter>& lhs,
168
- const typename iterator_traits<BiIter>::value_type& rhs);
169
- template <class BiIter>
170
- bool operator>(const sub_match<BiIter>& lhs,
171
- const typename iterator_traits<BiIter>::value_type& rhs);
172
- template <class BiIter>
173
- bool operator>=(const sub_match<BiIter>& lhs,
174
- const typename iterator_traits<BiIter>::value_type& rhs);
175
- template <class BiIter>
176
- bool operator<=(const sub_match<BiIter>& lhs,
177
  const typename iterator_traits<BiIter>::value_type& rhs);
178
 
179
  template<class charT, class ST, class BiIter>
180
  basic_ostream<charT, ST>&
181
  operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
@@ -192,13 +82,10 @@ namespace std {
192
 
193
  // match_results comparisons
194
  template<class BidirectionalIterator, class Allocator>
195
  bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
196
  const match_results<BidirectionalIterator, Allocator>& m2);
197
- template <class BidirectionalIterator, class Allocator>
198
- bool operator!=(const match_results<BidirectionalIterator, Allocator>& m1,
199
- const match_results<BidirectionalIterator, Allocator>& m2);
200
 
201
  // [re.results.swap], match_results swap
202
  template<class BidirectionalIterator, class Allocator>
203
  void swap(match_results<BidirectionalIterator, Allocator>& m1,
204
  match_results<BidirectionalIterator, Allocator>& m2);
 
1
  ## Header `<regex>` synopsis <a id="re.syn">[[re.syn]]</a>
2
 
3
  ``` cpp
4
+ #include <compare> // see [compare.syn]
5
+ #include <initializer_list> // see [initializer.list.syn]
6
 
7
  namespace std {
8
  // [re.const], regex constants
9
  namespace regex_constants {
10
  using syntax_option_type = T1;
 
39
 
40
  // [re.submatch.op], sub_match non-member operators
41
  template<class BiIter>
42
  bool operator==(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
43
  template<class BiIter>
44
+ auto operator<=>(const sub_match<BiIter>& lhs, const sub_match<BiIter>& rhs);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
45
 
46
  template<class BiIter, class ST, class SA>
47
  bool operator==(
48
  const sub_match<BiIter>& lhs,
49
  const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
50
  template<class BiIter, class ST, class SA>
51
+ auto operator<=>(
52
  const sub_match<BiIter>& lhs,
53
  const basic_string<typename iterator_traits<BiIter>::value_type, ST, SA>& rhs);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
54
 
55
  template<class BiIter>
56
  bool operator==(const sub_match<BiIter>& lhs,
57
  const typename iterator_traits<BiIter>::value_type* rhs);
58
  template<class BiIter>
59
+ auto operator<=>(const sub_match<BiIter>& lhs,
 
 
 
 
 
 
 
 
 
 
 
 
60
  const typename iterator_traits<BiIter>::value_type* rhs);
61
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
62
  template<class BiIter>
63
  bool operator==(const sub_match<BiIter>& lhs,
64
  const typename iterator_traits<BiIter>::value_type& rhs);
65
  template<class BiIter>
66
+ auto operator<=>(const sub_match<BiIter>& lhs,
 
 
 
 
 
 
 
 
 
 
 
 
67
  const typename iterator_traits<BiIter>::value_type& rhs);
68
 
69
  template<class charT, class ST, class BiIter>
70
  basic_ostream<charT, ST>&
71
  operator<<(basic_ostream<charT, ST>& os, const sub_match<BiIter>& m);
 
82
 
83
  // match_results comparisons
84
  template<class BidirectionalIterator, class Allocator>
85
  bool operator==(const match_results<BidirectionalIterator, Allocator>& m1,
86
  const match_results<BidirectionalIterator, Allocator>& m2);
 
 
 
87
 
88
  // [re.results.swap], match_results swap
89
  template<class BidirectionalIterator, class Allocator>
90
  void swap(match_results<BidirectionalIterator, Allocator>& m1,
91
  match_results<BidirectionalIterator, Allocator>& m2);