1 | <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"> |
---|
2 | <html> |
---|
3 | <head> |
---|
4 | <title>Boost.Regex: sub_match</title> |
---|
5 | <meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1"> |
---|
6 | <LINK href="../../../boost.css" type="text/css" rel="stylesheet"></head> |
---|
7 | <body> |
---|
8 | <P> |
---|
9 | <TABLE id="Table1" cellSpacing="1" cellPadding="1" width="100%" border="0"> |
---|
10 | <TR> |
---|
11 | <td vAlign="top" width="300"> |
---|
12 | <h3><A href="../../../index.htm"><IMG height="86" alt="C++ Boost" src="../../../boost.png" width="277" border="0"></A></h3> |
---|
13 | </td> |
---|
14 | <TD width="353"> |
---|
15 | <H1 align="center">Boost.Regex</H1> |
---|
16 | <H2 align="center">sub_match</H2> |
---|
17 | </TD> |
---|
18 | <td width="50"> |
---|
19 | <h3><A href="index.html"><IMG height="45" alt="Boost.Regex Index" src="uarrow.gif" width="43" border="0"></A></h3> |
---|
20 | </td> |
---|
21 | </TR> |
---|
22 | </TABLE> |
---|
23 | </P> |
---|
24 | <HR> |
---|
25 | <H3>Synopsis</H3> |
---|
26 | <P>#include <<A href="../../../boost/regex.hpp">boost/regex.hpp</A>> |
---|
27 | </P> |
---|
28 | <P>Regular expressions are different from many simple pattern-matching algorithms |
---|
29 | in that as well as finding an overall match they can also produce |
---|
30 | sub-expression matches: each sub-expression being delimited in the pattern by a |
---|
31 | pair of parenthesis (...). There has to be some method for reporting |
---|
32 | sub-expression matches back to the user: this is achieved this by defining a |
---|
33 | class <I><A href="match_results.html">match_results</A></I> that acts as an |
---|
34 | indexed collection of sub-expression matches, each sub-expression match being |
---|
35 | contained in an object of type <I>sub_match</I> |
---|
36 | . |
---|
37 | <P>Objects of type <EM>sub_match</EM> may only obtained by subscripting an object |
---|
38 | of type <EM><A href="match_results.html">match_results</A></EM> |
---|
39 | . |
---|
40 | <P>Objects of type <EM>sub_match</EM> may be compared to objects of type <EM>std::basic_string</EM>, |
---|
41 | or <EM>const charT*</EM> or <EM>const charT</EM> |
---|
42 | . |
---|
43 | <P>Objects of type <EM>sub_match</EM> may be added to objects of type <EM>std::basic_string</EM>, |
---|
44 | or <EM>const charT* </EM>or <EM>const charT</EM>, to produce a new <EM>std::basic_string |
---|
45 | </EM> |
---|
46 | object. |
---|
47 | <P>When the marked sub-expression denoted by an object of type sub_match<> |
---|
48 | participated in a regular expression match then member <CODE>matched</CODE> evaluates |
---|
49 | to true, and members <CODE>first</CODE> and <CODE>second</CODE> denote the |
---|
50 | range of characters <CODE>[first,second)</CODE> which formed that match. |
---|
51 | Otherwise <CODE>matched</CODE> is false, and members <CODE>first</CODE> and <CODE>second</CODE> |
---|
52 | contained undefined values.</P> |
---|
53 | <P>When the marked sub-expression denoted by an object of type sub_match<> |
---|
54 | was repeated, then the sub_match object represents the match obtained by the |
---|
55 | last repeat. The complete set of all the captures obtained for all the |
---|
56 | repeats, may be accessed via the captures() member function (Note: this has |
---|
57 | serious performance implications, you have to explicitly enable this feature).</P> |
---|
58 | <P>If an object of type <CODE>sub_match<></CODE> represents sub-expression 0 |
---|
59 | - that is to say the whole match - then member <CODE>matched</CODE> is always |
---|
60 | true, unless a partial match was obtained as a result of the flag <CODE>match_partial</CODE> |
---|
61 | being passed to a regular expression algorithm, in which case member <CODE>matched</CODE> |
---|
62 | is false, and members <CODE>first</CODE> and <CODE>second</CODE> represent the |
---|
63 | character range that formed the partial match.</P> |
---|
64 | <PRE>namespace boost{ |
---|
65 | |
---|
66 | template <class BidirectionalIterator> |
---|
67 | class sub_match; |
---|
68 | |
---|
69 | typedef sub_match<const char*> csub_match; |
---|
70 | typedef sub_match<const wchar_t*> wcsub_match; |
---|
71 | typedef sub_match<std::string::const_iterator> ssub_match; |
---|
72 | typedef sub_match<std::wstring::const_iterator> wssub_match; |
---|
73 | |
---|
74 | template <class BidirectionalIterator> |
---|
75 | class sub_match : public std::pair<BidirectionalIterator, BidirectionalIterator> |
---|
76 | { |
---|
77 | public: |
---|
78 | typedef typename iterator_traits<BidirectionalIterator>::value_type value_type; |
---|
79 | typedef typename iterator_traits<BidirectionalIterator>::difference_type difference_type; |
---|
80 | typedef BidirectionalIterator iterator; |
---|
81 | |
---|
82 | bool <A href="#m1" >matched</A>; |
---|
83 | |
---|
84 | difference_type <A href="#m2" >length</A>()const; |
---|
85 | operator <A href="#m3" >basic_string</A><value_type>()const; |
---|
86 | basic_string<value_type> <A href="#m4" >str</A>()const; |
---|
87 | |
---|
88 | int <A href="#m5" >compare</A>(const sub_match& s)const; |
---|
89 | int <A href="#m6" >compare</A>(const basic_string<value_type>& s)const; |
---|
90 | int <A href="#m7" >compare</A>(const value_type* s)const; |
---|
91 | #ifdef BOOST_REGEX_MATCH_EXTRA |
---|
92 | typedef implementation-private <A href="#m9">capture_sequence_type</A>; |
---|
93 | const capture_sequence_type& <A href="#m8" >captures</A>()const; |
---|
94 | #endif |
---|
95 | }; |
---|
96 | // |
---|
97 | // comparisons to another sub_match: |
---|
98 | // |
---|
99 | template <class BidirectionalIterator> |
---|
100 | bool <A href="#o11" >operator</A> == (const sub_match<BidirectionalIterator>& lhs, |
---|
101 | const sub_match<BidirectionalIterator>& rhs); |
---|
102 | template <class BidirectionalIterator> |
---|
103 | bool <A href="#o12" >operator</A> != (const sub_match<BidirectionalIterator>& lhs, |
---|
104 | const sub_match<BidirectionalIterator>& rhs); |
---|
105 | template <class BidirectionalIterator> |
---|
106 | bool <A href="#o13" >operator</A> < (const sub_match<BidirectionalIterator>& lhs, |
---|
107 | const sub_match<BidirectionalIterator>& rhs); |
---|
108 | template <class BidirectionalIterator> |
---|
109 | bool <A href="#o14" >operator</A> <= (const sub_match<BidirectionalIterator>& lhs, |
---|
110 | const sub_match<BidirectionalIterator>& rhs); |
---|
111 | template <class BidirectionalIterator> |
---|
112 | bool <A href="#o15" >operator</A> >= (const sub_match<BidirectionalIterator>& lhs, |
---|
113 | const sub_match<BidirectionalIterator>& rhs); |
---|
114 | template <class BidirectionalIterator> |
---|
115 | bool <A href="#o16" >operator</A> > (const sub_match<BidirectionalIterator>& lhs, |
---|
116 | const sub_match<BidirectionalIterator>& rhs); |
---|
117 | |
---|
118 | |
---|
119 | // |
---|
120 | // comparisons to a basic_string: |
---|
121 | // |
---|
122 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
123 | bool <A href="#o21" >operator</A> == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
124 | const sub_match<BidirectionalIterator>& rhs); |
---|
125 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
126 | bool <A href="#o22" >operator</A> != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
127 | const sub_match<BidirectionalIterator>& rhs); |
---|
128 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
129 | bool <A href="#o23" >operator</A> < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
130 | const sub_match<BidirectionalIterator>& rhs); |
---|
131 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
132 | bool <A href="#o24" >operator</A> > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
133 | const sub_match<BidirectionalIterator>& rhs); |
---|
134 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
135 | bool <A href="#o25" >operator</A> >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
136 | const sub_match<BidirectionalIterator>& rhs); |
---|
137 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
138 | bool <A href="#o26" >operator</A> <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
139 | const sub_match<BidirectionalIterator>& rhs); |
---|
140 | |
---|
141 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
142 | bool <A href="#o31" >operator</A> == (const sub_match<BidirectionalIterator>& lhs, |
---|
143 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs); |
---|
144 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
145 | bool <A href="#o32" >operator</A> != (const sub_match<BidirectionalIterator>& lhs, |
---|
146 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs); |
---|
147 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
148 | bool <A href="#o33" >operator</A> < (const sub_match<BidirectionalIterator>& lhs, |
---|
149 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs); |
---|
150 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
151 | bool <A href="#o34" >operator</A> > (const sub_match<BidirectionalIterator>& lhs, |
---|
152 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs); |
---|
153 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
154 | bool <A href="#o35" >operator</A> >= (const sub_match<BidirectionalIterator>& lhs, |
---|
155 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs); |
---|
156 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
157 | bool <A href="#o36" >operator</A> <= (const sub_match<BidirectionalIterator>& lhs, |
---|
158 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs); |
---|
159 | |
---|
160 | // |
---|
161 | // comparisons to a pointer to a character array: |
---|
162 | // |
---|
163 | template <class BidirectionalIterator> |
---|
164 | bool <A href="#o41" >operator</A> == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
165 | const sub_match<BidirectionalIterator>& rhs); |
---|
166 | template <class BidirectionalIterator> |
---|
167 | bool <A href="#o42" >operator</A> != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
168 | const sub_match<BidirectionalIterator>& rhs); |
---|
169 | template <class BidirectionalIterator> |
---|
170 | bool <A href="#o43" >operator</A> < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
171 | const sub_match<BidirectionalIterator>& rhs); |
---|
172 | template <class BidirectionalIterator> |
---|
173 | bool <A href="#o44" >operator</A> > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
174 | const sub_match<BidirectionalIterator>& rhs); |
---|
175 | template <class BidirectionalIterator> |
---|
176 | bool <A href="#o45" >operator</A> >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
177 | const sub_match<BidirectionalIterator>& rhs); |
---|
178 | template <class BidirectionalIterator> |
---|
179 | bool <A href="#o46" >operator</A> <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
180 | const sub_match<BidirectionalIterator>& rhs); |
---|
181 | |
---|
182 | template <class BidirectionalIterator> |
---|
183 | bool <A href="#o51" >operator</A> == (const sub_match<BidirectionalIterator>& lhs, |
---|
184 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
---|
185 | template <class BidirectionalIterator> |
---|
186 | bool <A href="#o52" >operator</A> != (const sub_match<BidirectionalIterator>& lhs, |
---|
187 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
---|
188 | template <class BidirectionalIterator> |
---|
189 | bool <A href="#o53" >operator</A> < (const sub_match<BidirectionalIterator>& lhs, |
---|
190 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
---|
191 | template <class BidirectionalIterator> |
---|
192 | bool <A href="#o54" >operator</A> > (const sub_match<BidirectionalIterator>& lhs, |
---|
193 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
---|
194 | template <class BidirectionalIterator> |
---|
195 | bool <A href="#o55" >operator</A> >= (const sub_match<BidirectionalIterator>& lhs, |
---|
196 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
---|
197 | template <class BidirectionalIterator> |
---|
198 | bool <A href="#o56" >operator</A> <= (const sub_match<BidirectionalIterator>& lhs, |
---|
199 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); |
---|
200 | |
---|
201 | // |
---|
202 | // comparisons to a single character: |
---|
203 | // |
---|
204 | template <class BidirectionalIterator> |
---|
205 | bool <A href="#o61" >operator</A> == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
206 | const sub_match<BidirectionalIterator>& rhs); |
---|
207 | template <class BidirectionalIterator> |
---|
208 | bool <A href="#o62" >operator</A> != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
209 | const sub_match<BidirectionalIterator>& rhs); |
---|
210 | template <class BidirectionalIterator> |
---|
211 | bool <A href="#o63" >operator</A> < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
212 | const sub_match<BidirectionalIterator>& rhs); |
---|
213 | template <class BidirectionalIterator> |
---|
214 | bool <A href="#o64" >operator</A> > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
215 | const sub_match<BidirectionalIterator>& rhs); |
---|
216 | template <class BidirectionalIterator> |
---|
217 | bool <A href="#o65" >operator</A> >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
218 | const sub_match<BidirectionalIterator>& rhs); |
---|
219 | template <class BidirectionalIterator> |
---|
220 | bool <A href="#o66" >operator</A> <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
221 | const sub_match<BidirectionalIterator>& rhs); |
---|
222 | |
---|
223 | template <class BidirectionalIterator> |
---|
224 | bool <A href="#o71" >operator</A> == (const sub_match<BidirectionalIterator>& lhs, |
---|
225 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
---|
226 | template <class BidirectionalIterator> |
---|
227 | bool <A href="#o72" >operator</A> != (const sub_match<BidirectionalIterator>& lhs, |
---|
228 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
---|
229 | template <class BidirectionalIterator> |
---|
230 | bool <A href="#o73" >operator</A> < (const sub_match<BidirectionalIterator>& lhs, |
---|
231 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
---|
232 | template <class BidirectionalIterator> |
---|
233 | bool <A href="#o74" >operator</A> > (const sub_match<BidirectionalIterator>& lhs, |
---|
234 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
---|
235 | template <class BidirectionalIterator> |
---|
236 | bool <A href="#o75" >operator</A> >= (const sub_match<BidirectionalIterator>& lhs, |
---|
237 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
---|
238 | template <class BidirectionalIterator> |
---|
239 | bool <A href="#o76" >operator</A> <= (const sub_match<BidirectionalIterator>& lhs, |
---|
240 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); |
---|
241 | // |
---|
242 | // addition operators: |
---|
243 | // |
---|
244 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
245 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator> |
---|
246 | <A href="#o81" >operator</A> + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& s, |
---|
247 | const sub_match<BidirectionalIterator>& m); |
---|
248 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
249 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator> |
---|
250 | <A href="#o82" >operator</A> + (const sub_match<BidirectionalIterator>& m, |
---|
251 | const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& s); |
---|
252 | template <class BidirectionalIterator> std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
253 | <A href="#o83" >operator</A> + (typename iterator_traits<BidirectionalIterator>::value_type const* s, |
---|
254 | const sub_match<BidirectionalIterator>& m); |
---|
255 | template <class BidirectionalIterator> std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
256 | <A href="#o84" >operator</A> + (const sub_match<BidirectionalIterator>& m, |
---|
257 | typename iterator_traits<BidirectionalIterator>::value_type const * s); |
---|
258 | template <class BidirectionalIterator> |
---|
259 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
260 | <A href="#o85" >operator</A> + (typename iterator_traits<BidirectionalIterator>::value_type const& s, |
---|
261 | const sub_match<BidirectionalIterator>& m); |
---|
262 | template <class BidirectionalIterator> |
---|
263 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
264 | <A href="#o86" >operator</A> + (const sub_match<BidirectionalIterator>& m, |
---|
265 | typename iterator_traits<BidirectionalIterator>::value_type const& s); |
---|
266 | template <class BidirectionalIterator> |
---|
267 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
268 | <A href="#o87" >operator</A> + (const sub_match<BidirectionalIterator>& m1, |
---|
269 | const sub_match<BidirectionalIterator>& m2); |
---|
270 | |
---|
271 | // |
---|
272 | // stream inserter: |
---|
273 | // |
---|
274 | template <class charT, class traits, class BidirectionalIterator> |
---|
275 | basic_ostream<charT, traits>& |
---|
276 | <A href="#oi" >operator</A> << (basic_ostream<charT, traits>& os, |
---|
277 | const sub_match<BidirectionalIterator>& m); |
---|
278 | |
---|
279 | } // namespace boost</PRE> |
---|
280 | <H3>Description</H3> |
---|
281 | <H4>sub_match members</H4> |
---|
282 | <PRE>typedef typename std::iterator_traits<iterator>::value_type value_type;</PRE> |
---|
283 | <P>The type pointed to by the iterators.</P> |
---|
284 | <PRE>typedef typename std::iterator_traits<iterator>::difference_type difference_type;</PRE> |
---|
285 | <P>A type that represents the difference between two iterators.</P> |
---|
286 | <PRE>typedef iterator iterator_type;</PRE> |
---|
287 | <P>The iterator type.</P> |
---|
288 | <PRE>iterator first</PRE> |
---|
289 | <P>An iterator denoting the position of the start of the match.</P> |
---|
290 | <PRE>iterator second</PRE> |
---|
291 | <P>An iterator denoting the position of the end of the match.</P> |
---|
292 | <PRE><A name=m1></A>bool matched</PRE> |
---|
293 | <P>A Boolean value denoting whether this sub-expression participated in the match.</P> |
---|
294 | <PRE><A name=m2></A>static difference_type length();</PRE> |
---|
295 | <P><B>Effects: </B>returns the length of this matched sub-expression, or 0 if this |
---|
296 | sub-expression was not matched: <CODE>matched ? distance(first, second) : 0)</CODE>.</P> |
---|
297 | <PRE><A name=m3></A>operator basic_string<value_type>()const;</PRE> |
---|
298 | <P><B>Effects: </B>converts *this into a string: returns <CODE>(matched ? |
---|
299 | basic_string<value_type>(first, second) : |
---|
300 | basic_string<value_type>()).</P> |
---|
301 | </CODE><PRE><A name=m4></A>basic_string<value_type> str()const;</PRE> |
---|
302 | <P><B>Effects: </B>returns a string representation of *this: <CODE>(matched ? |
---|
303 | basic_string<value_type>(first, second) : |
---|
304 | basic_string<value_type>())</CODE>.</P> |
---|
305 | <PRE><A name=m5></A>int compare(const sub_match& s)const;</PRE> |
---|
306 | <P><B>Effects: </B>performs a lexical comparison to <EM>s</EM>: returns <CODE>str().compare(s.str())</CODE>.</P> |
---|
307 | <PRE><A name=m6></A>int compare(const basic_string<value_type>& s)const;</PRE> |
---|
308 | <P><B>Effects: </B>compares *this to the string s: returns <CODE>str().compare(s)</CODE>.</P> |
---|
309 | <PRE><A name=m7></A>int compare(const value_type* s)const;</PRE> |
---|
310 | <P><B>Effects:<B></B> </B>compares *this to the null-terminated string <EM>s</EM>:<B> </B>returns |
---|
311 | <CODE>str().compare(s)</CODE>.</P> |
---|
312 | <PRE><A name=m9></A>typedef implementation-private capture_sequence_type;</PRE> |
---|
313 | <P>Defines an implementation-specific type that satisfies the requirements of |
---|
314 | a standard library Sequence (21.1.1 including the optional Table 68 |
---|
315 | operations), whose value_type is a <EM>sub_match<BidirectionalIterator></EM>. This |
---|
316 | type happens to be <EM>std::vector<sub_match<BidirectionalIterator> ></EM>, |
---|
317 | but you shouldn't actually rely on that.</P> |
---|
318 | <PRE><A name=m8></A>const capture_sequence_type& <A href="#m8" >captures</A>()const; </PRE> |
---|
319 | <P><STRONG>Effects:</STRONG> returns a sequence containing all the captures |
---|
320 | obtained for this sub-expression.</P> |
---|
321 | <P><STRONG>Preconditions:</STRONG> the library must be built and used with |
---|
322 | BOOST_REGEX_MATCH_EXTRA defined, and you must pass the flag <A href="match_flag_type.html"> |
---|
323 | match_extra</A> to the regex matching functions (<A href="regex_match.html">regex_match</A>, |
---|
324 | <A href="regex_search.html">regex_search</A>, <A href="regex_iterator.html">regex_iterator</A> |
---|
325 | or <A href="regex_token_iterator.html">regex_token_iterator</A>) in order for |
---|
326 | this member function to be defined and return useful information.</P> |
---|
327 | <P><STRONG>Rationale:</STRONG> Enabling this feature has several consequences: |
---|
328 | </P> |
---|
329 | <UL> |
---|
330 | <LI> |
---|
331 | sub_match occupies more memory resulting in complex expressions running out of |
---|
332 | memory or stack space more quickly during matching. |
---|
333 | <LI> |
---|
334 | The matching algorithms are less efficient at handling some features |
---|
335 | (independent sub-expressions for example), even when <EM>match_extra</EM> |
---|
336 | is not used. |
---|
337 | <LI> |
---|
338 | The matching algorithms are much less efficient (i.e. slower), when <EM>match_extra</EM> |
---|
339 | is used. Mostly this is down to the extra memory allocations that have to |
---|
340 | take place.</LI></UL> |
---|
341 | <H4>sub_match non-member operators</H4> |
---|
342 | <H5>Comparisons against self</H5> |
---|
343 | <PRE><A name=o11></A>template <class BidirectionalIterator> |
---|
344 | bool operator == (const sub_match<BidirectionalIterator>& lhs, |
---|
345 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
346 | <P><B>Effects: </B>returns <CODE>lhs.compare(rhs) == 0</CODE>.</P> |
---|
347 | <PRE><A name=o12></A>template <class BidirectionalIterator> |
---|
348 | bool operator != (const sub_match<BidirectionalIterator>& lhs, |
---|
349 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
350 | <P><B>Effects: </B>returns <CODE>lhs.compare(rhs) != 0</CODE>.</P> |
---|
351 | <PRE><A name=o13></A>template <class BidirectionalIterator> |
---|
352 | bool operator < (const sub_match<BidirectionalIterator>& lhs, |
---|
353 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
354 | <P><B>Effects: </B>returns <CODE>lhs.compare(rhs) < 0</CODE>.</P> |
---|
355 | <PRE><A name=o14></A>template <class BidirectionalIterator> |
---|
356 | bool operator <= (const sub_match<BidirectionalIterator>& lhs, |
---|
357 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
358 | <P><B>Effects: </B>returns <CODE>lhs.compare(rhs) <= 0</CODE>.</P> |
---|
359 | <PRE><A name=o15></A>template <class BidirectionalIterator> |
---|
360 | bool operator >= (const sub_match<BidirectionalIterator>& lhs, |
---|
361 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
362 | <P><B>Effects: </B>returns <CODE>lhs.compare(rhs) >= 0</CODE>.</P> |
---|
363 | <PRE><A name=o16></A>template <class BidirectionalIterator> |
---|
364 | bool operator > (const sub_match<BidirectionalIterator>& lhs, |
---|
365 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
366 | <P><B>Effects: </B>returns <CODE>lhs.compare(rhs) > 0</CODE>.</P> |
---|
367 | <H5>Comparisons with std::basic_string</H5> |
---|
368 | <pre><A name=o21></A> |
---|
369 | template <class BidirectionalIterator, class traits, class Allocator> |
---|
370 | bool operator == (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, |
---|
371 | Allocator>& lhs, const sub_match<BidirectionalIterator>& rhs); |
---|
372 | </pre> |
---|
373 | <P><B>Effects: </B>returns <CODE>lhs == rhs.str()</CODE>.</P> |
---|
374 | <PRE><A name=o22></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
375 | bool operator != (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
376 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
377 | <P><B>Effects: </B>returns <CODE>lhs != rhs.str()</CODE>.</P> |
---|
378 | <PRE><A name=o23></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
379 | bool operator < (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
380 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
381 | <P><B>Effects: </B>returns <CODE>lhs < rhs.str()</CODE>.</P> |
---|
382 | <PRE><A name=o24></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
383 | bool operator > (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
384 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
385 | <P><B>Effects: </B>returns <CODE>lhs > rhs.str()</CODE>.</P> |
---|
386 | <PRE><A name=o25></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
387 | bool operator >= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
388 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
389 | <P><B>Effects: </B>returns <CODE>lhs >= rhs.str()</CODE>.</P> |
---|
390 | <PRE><A name=o26></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
391 | bool operator <= (const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& lhs, |
---|
392 | const sub_match<BidirectionalIterator>& rhs);</PRE> |
---|
393 | <P><B>Effects: </B>returns <CODE>lhs <= rhs.str()</CODE>.</P> |
---|
394 | <PRE><A name=o31></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
395 | bool operator == (const sub_match<BidirectionalIterator>& lhs, |
---|
396 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs);</PRE> |
---|
397 | <P><B>Effects: </B>returns <CODE>lhs.str() == rhs</CODE>.</P> |
---|
398 | <PRE><A name=o32></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
399 | bool operator != (const sub_match<BidirectionalIterator>& lhs, |
---|
400 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs);</PRE> |
---|
401 | <P><B>Effects: </B>returns <CODE>lhs.str() != rhs</CODE>.</P> |
---|
402 | <PRE><A name=o33></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
403 | bool operator < (const sub_match<BidirectionalIterator>& lhs, |
---|
404 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs);</PRE> |
---|
405 | <P><B>Effects: </B>returns <CODE>lhs.str() < rhs</CODE>.</P> |
---|
406 | <PRE><A name=o34></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
407 | bool operator > (const sub_match<BidirectionalIterator>& lhs, |
---|
408 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs);</PRE> |
---|
409 | <P><B>Effects: </B>returns <CODE>lhs.str() > rhs</CODE>.</P> |
---|
410 | <PRE><A name=o35></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
411 | bool operator >= (const sub_match<BidirectionalIterator>& lhs, |
---|
412 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs);</PRE> |
---|
413 | <P><B>Effects: </B>returns <CODE>lhs.str() >= rhs</CODE>.</P> |
---|
414 | <PRE><A name=o36></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
415 | bool operator <= (const sub_match<BidirectionalIterator>& lhs, |
---|
416 | const std::basic_string<iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& rhs);</PRE> |
---|
417 | <P><B>Effects: </B>returns <CODE>lhs.str() <= rhs</CODE>.</P> |
---|
418 | <H5>Comparisons with null-terminated strings</H5> |
---|
419 | <PRE><A name=o41></A>template <class BidirectionalIterator> |
---|
420 | bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
421 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
422 | <P><B>Effects: </B>returns <CODE>lhs == rhs.str()</CODE>.</P> |
---|
423 | <PRE><A name=o42></A>template <class BidirectionalIterator> |
---|
424 | bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
425 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
426 | <P><B>Effects: </B>returns <CODE>lhs != rhs.str()</CODE>.</P> |
---|
427 | <PRE></A><A name=o43></A>template <class BidirectionalIterator> |
---|
428 | bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
429 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
430 | <P><B>Effects: </B>returns <CODE>lhs < rhs.str()</CODE>.</P> |
---|
431 | <PRE><A name=o44></A>template <class BidirectionalIterator> |
---|
432 | bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
433 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
434 | <P><B>Effects: </B>returns <CODE>lhs > rhs.str()</CODE>.</P> |
---|
435 | <PRE><A name=o45></A>template <class BidirectionalIterator> |
---|
436 | bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
437 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
438 | <P><B>Effects: </B>returns <CODE>lhs >= rhs.str()</CODE>.</P> |
---|
439 | <PRE><A name=o46></A>template <class BidirectionalIterator> |
---|
440 | bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const* lhs, |
---|
441 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
442 | <P><B>Effects: </B>returns <CODE>lhs <= rhs.str()</CODE>.</P> |
---|
443 | <PRE><A name=o51></A>template <class BidirectionalIterator> |
---|
444 | bool operator == (const sub_match<BidirectionalIterator>& lhs, |
---|
445 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); </PRE> |
---|
446 | <P><B>Effects: </B>returns <CODE>lhs.str() == rhs</CODE>.</P> |
---|
447 | <PRE><A name=o52></A>template <class BidirectionalIterator> |
---|
448 | bool operator != (const sub_match<BidirectionalIterator>& lhs, |
---|
449 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); </PRE> |
---|
450 | <P><B>Effects: </B>returns <CODE>lhs.str() != rhs</CODE>.</P> |
---|
451 | <PRE><A name=o53></A>template <class BidirectionalIterator> |
---|
452 | bool operator < (const sub_match<BidirectionalIterator>& lhs, |
---|
453 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); </PRE> |
---|
454 | <P><B>Effects: </B>returns <CODE>lhs.str() < rhs</CODE>.</P> |
---|
455 | <PRE><A name=o54></A>template <class BidirectionalIterator> |
---|
456 | bool operator > (const sub_match<BidirectionalIterator>& lhs, |
---|
457 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); </PRE> |
---|
458 | <P><B>Effects: </B>returns <CODE>lhs.str() > rhs</CODE>.</P> |
---|
459 | <PRE><A name=o55></A>template <class BidirectionalIterator> |
---|
460 | bool operator >= (const sub_match<BidirectionalIterator>& lhs, |
---|
461 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); </PRE> |
---|
462 | <P><B>Effects: </B>returns <CODE>lhs.str() >= rhs</CODE>.</P> |
---|
463 | <PRE><A name=o56></A>template <class BidirectionalIterator> |
---|
464 | bool operator <= (const sub_match<BidirectionalIterator>& lhs, |
---|
465 | typename iterator_traits<BidirectionalIterator>::value_type const* rhs); </PRE> |
---|
466 | <P><B>Effects: </B>returns <CODE>lhs.str() <= rhs</CODE>.</P> |
---|
467 | <H5>Comparisons with a single character</H5> |
---|
468 | <PRE><A name=o61></A>template <class BidirectionalIterator> |
---|
469 | bool operator == (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
470 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
471 | <P><B>Effects: </B>returns <CODE>lhs == rhs.str()</CODE>.</P> |
---|
472 | <PRE><A name=o62></A>template <class BidirectionalIterator> |
---|
473 | bool operator != (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
474 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
475 | <P><B>Effects: </B>returns <CODE>lhs != rhs.str()</CODE>.</P> |
---|
476 | <PRE><A name=o63></A>template <class BidirectionalIterator> |
---|
477 | bool operator < (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
478 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
479 | <P><B>Effects: </B>returns <CODE>lhs < rhs.str()</CODE>.</P> |
---|
480 | <PRE><A name=o64></A>template <class BidirectionalIterator> |
---|
481 | bool operator > (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
482 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
483 | <P><B>Effects: </B>returns <CODE>lhs > rhs.str()</CODE>.</P> |
---|
484 | <PRE><A name=o65></A>template <class BidirectionalIterator> |
---|
485 | bool operator >= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
486 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
487 | <P><B>Effects: </B>returns <CODE>lhs >= rhs.str()</CODE>.</P> |
---|
488 | <PRE><A name=o66></A>template <class BidirectionalIterator> |
---|
489 | bool operator <= (typename iterator_traits<BidirectionalIterator>::value_type const& lhs, |
---|
490 | const sub_match<BidirectionalIterator>& rhs); </PRE> |
---|
491 | <P><B>Effects: </B>returns <CODE>lhs <= rhs.str()</CODE>.</P> |
---|
492 | <PRE><A name=o71></A>template <class BidirectionalIterator> |
---|
493 | bool operator == (const sub_match<BidirectionalIterator>& lhs, |
---|
494 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); </PRE> |
---|
495 | <P><B>Effects: </B>returns <CODE>lhs.str() == rhs</CODE>.</P> |
---|
496 | <PRE><A name=o72></A>template <class BidirectionalIterator> |
---|
497 | bool operator != (const sub_match<BidirectionalIterator>& lhs, |
---|
498 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); </PRE> |
---|
499 | <P><B>Effects: </B>returns <CODE>lhs.str() != rhs</CODE>.</P> |
---|
500 | <PRE><A name=o73></A>template <class BidirectionalIterator> |
---|
501 | bool operator < (const sub_match<BidirectionalIterator>& lhs, |
---|
502 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); </PRE> |
---|
503 | <P><B>Effects: </B>returns <CODE>lhs.str() < rhs</CODE>.</P> |
---|
504 | <PRE><A name=o74></A>template <class BidirectionalIterator> |
---|
505 | bool operator > (const sub_match<BidirectionalIterator>& lhs, |
---|
506 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); </PRE> |
---|
507 | <P><B>Effects: </B>returns <CODE>lhs.str() > rhs</CODE>.</P> |
---|
508 | <PRE><A name=o75></A>template <class BidirectionalIterator> |
---|
509 | bool operator >= (const sub_match<BidirectionalIterator>& lhs, |
---|
510 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); </PRE> |
---|
511 | <P><B>Effects: </B>returns <CODE>lhs.str() >= rhs</CODE>.</P> |
---|
512 | <PRE><A name=o76></A>template <class BidirectionalIterator> |
---|
513 | bool operator <= (const sub_match<BidirectionalIterator>& lhs, |
---|
514 | typename iterator_traits<BidirectionalIterator>::value_type const& rhs); </PRE> |
---|
515 | <P><B>Effects: </B>returns <CODE>lhs.str() <= rhs</CODE>.</P> |
---|
516 | <h5>Addition operators</h5> |
---|
517 | <P>The addition operators for sub_match allow you to add a sub_match to any type |
---|
518 | to which you can add a std::string and obtain a new string as the result.</P> |
---|
519 | <PRE><A name=o81></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
520 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator> |
---|
521 | operator + (const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& s, |
---|
522 | const sub_match<BidirectionalIterator>& m); </PRE> |
---|
523 | <P><B>Effects: </B>returns <CODE>s + m.str()</CODE>.</P> |
---|
524 | <PRE><A name=o82></A>template <class BidirectionalIterator, class traits, class Allocator> |
---|
525 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator> |
---|
526 | operator + (const sub_match<BidirectionalIterator>& m, |
---|
527 | const std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type, traits, Allocator>& s); </PRE> |
---|
528 | <P><B>Effects: </B>returns <CODE>m.str() + s</CODE>.</P> |
---|
529 | <PRE><A name=o83></A>template <class BidirectionalIterator> std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
530 | operator + (typename iterator_traits<BidirectionalIterator>::value_type const* s, |
---|
531 | const sub_match<BidirectionalIterator>& m); </PRE> |
---|
532 | <P><B>Effects: </B>returns <CODE>s + m.str()</CODE>.</P> |
---|
533 | <PRE><A name=o84></A>template <class BidirectionalIterator> std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
534 | operator + (const sub_match<BidirectionalIterator>& m, |
---|
535 | typename iterator_traits<BidirectionalIterator>::value_type const * s);</PRE> |
---|
536 | <P><B>Effects: </B>returns <CODE>m.str() + s</CODE>.</P> |
---|
537 | <PRE><A name=o85></A>template <class BidirectionalIterator> |
---|
538 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
539 | operator + (typename iterator_traits<BidirectionalIterator>::value_type const& s, |
---|
540 | const sub_match<BidirectionalIterator>& m); </PRE> |
---|
541 | <P><B>Effects: </B>returns <CODE>s + m.str()</CODE>.</P> |
---|
542 | <PRE><A name=o86></A>template <class BidirectionalIterator> |
---|
543 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
544 | operator + (const sub_match<BidirectionalIterator>& m, |
---|
545 | typename iterator_traits<BidirectionalIterator>::value_type const& s); </PRE> |
---|
546 | <P><B>Effects: </B>returns <CODE>m.str() + s</CODE>.</P> |
---|
547 | <PRE><A name=o87></A>template <class BidirectionalIterator> |
---|
548 | std::basic_string<typename iterator_traits<BidirectionalIterator>::value_type> |
---|
549 | operator + (const sub_match<BidirectionalIterator>& m1, |
---|
550 | const sub_match<BidirectionalIterator>& m2);</PRE> |
---|
551 | <P><B>Effects: </B>returns <CODE>m1.str() + m2.str()</CODE>.</P> |
---|
552 | <h5>Stream inserter</h5> |
---|
553 | <PRE><A name=oi></A>template <class charT, class traits, class BidirectionalIterator> |
---|
554 | basic_ostream<charT, traits>& |
---|
555 | operator << (basic_ostream<charT, traits>& os |
---|
556 | const sub_match<BidirectionalIterator>& m);</PRE> |
---|
557 | <P> |
---|
558 | <B>Effects: </B>returns <CODE>(os << m.str())</CODE>. |
---|
559 | <HR> |
---|
560 | <p>Revised |
---|
561 | <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B, %Y" startspan --> |
---|
562 | 22 Dec 2004 |
---|
563 | <!--webbot bot="Timestamp" endspan i-checksum="39359" --></p> |
---|
564 | <p><i>© Copyright John Maddock 1998- |
---|
565 | <!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%Y" startspan --> |
---|
566 | 2004</i></p> |
---|
567 | <P><I>Use, modification and distribution are subject to the Boost Software License, |
---|
568 | Version 1.0. (See accompanying file <A href="../../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> |
---|
569 | or copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>)</I></P> |
---|
570 | </body> |
---|
571 | </html> |
---|