Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_34_1/libs/regex/doc/sub_match.html @ 29

Last change on this file since 29 was 29, checked in by landauf, 16 years ago
updated boost from 1_33_1 to 1_34_1
File size: 41.0 KB

Line
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>

Note: See TracBrowser for help on using the repository browser.

Download in other formats: