boostorg/regex
1
0
Fork 1
mirror of https://github.com/boostorg/regex.git synced 2025-07-29 20:17:24 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merged typo fixes from trunk.

Browse Source 
[SVN r42026]
This commit is contained in:
John Maddock
2007-12-14 10:16:35 +00:00
parent 45891854d9
commit 79d7e84f26
86 changed files with 3114 additions and 3578 deletions
Download Patch File Download Diff File Expand all files Collapse all files

25
doc/html/boost_regex/ref/non_std_strings/icu.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title> Working With
Unicode and ICU String Types</title>
<title>Working With Unicode and ICU String Types</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../index.html" title="Boost.Regex">
<link rel="up" href="../non_std_strings.html" title=" Interfacing With Non-Standard
String Types">
<link rel="prev" href="../non_std_strings.html" title=" Interfacing With Non-Standard
String Types">
<link rel="next" href="icu/intro.html" title=" Introduction
to using Regex with ICU">
<link rel="up" href="../non_std_strings.html" title="Interfacing With Non-Standard String Types">
<link rel="prev" href="../non_std_strings.html" title="Interfacing With Non-Standard String Types">
<link rel="next" href="icu/intro.html" title="Introduction to using Regex with ICU">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,9 +24,9 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_regex.ref.non_std_strings.icu"></a><a href="icu.html" title=" Working With
Unicode and ICU String Types"> Working With
Unicode and ICU String Types</a></h4></div></div></div>
<a name="boost_regex.ref.non_std_strings.icu"></a><a href="icu.html" title="Working With Unicode and ICU String Types"> Working With
Unicode and ICU String Types</a>
</h4></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="icu/intro.html"> Introduction
to using Regex with ICU</a></span></dt>
@ -44,10 +40,11 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

28
doc/html/boost_regex/ref/non_std_strings/icu/intro.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title> Introduction
to using Regex with ICU</title>
<title>Introduction to using Regex with ICU</title>
<link rel="stylesheet" href="../../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../../index.html" title="Boost.Regex">
<link rel="up" href="../icu.html" title=" Working With
Unicode and ICU String Types">
<link rel="prev" href="../icu.html" title=" Working With
Unicode and ICU String Types">
<link rel="next" href="unicode_types.html" title="
Unicode regular expression types">
<link rel="up" href="../icu.html" title="Working With Unicode and ICU String Types">
<link rel="prev" href="../icu.html" title="Working With Unicode and ICU String Types">
<link rel="next" href="unicode_types.html" title="Unicode regular expression types">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,14 +24,13 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_regex.ref.non_std_strings.icu.intro"></a><a href="intro.html" title=" Introduction
to using Regex with ICU"> Introduction
to using Regex with ICU</a></h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.icu.intro"></a><a href="intro.html" title="Introduction to using Regex with ICU"> Introduction
to using Regex with ICU</a>
</h5></div></div></div>
<p>
The header:
</p>
<pre class="programlisting">
<span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
</pre>
<p>
contains the data types and algorithms necessary for working with regular
@ -67,10 +62,11 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

85
doc/html/boost_regex/ref/non_std_strings/icu/unicode_algo.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>
Unicode Regular Expression Algorithms</title>
<title>Unicode Regular Expression Algorithms</title>
<link rel="stylesheet" href="../../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../../index.html" title="Boost.Regex">
<link rel="up" href="../icu.html" title=" Working With
Unicode and ICU String Types">
<link rel="prev" href="unicode_types.html" title="
Unicode regular expression types">
<link rel="next" href="unicode_iter.html" title="
Unicode Aware Regex Iterators">
<link rel="up" href="../icu.html" title="Working With Unicode and ICU String Types">
<link rel="prev" href="unicode_types.html" title="Unicode regular expression types">
<link rel="next" href="unicode_iter.html" title="Unicode Aware Regex Iterators">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,41 +24,40 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_regex.ref.non_std_strings.icu.unicode_algo"></a><a href="unicode_algo.html" title="
Unicode Regular Expression Algorithms">
Unicode Regular Expression Algorithms</a></h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.icu.unicode_algo"></a><a href="unicode_algo.html" title="Unicode Regular Expression Algorithms">
Unicode Regular Expression Algorithms</a>
</h5></div></div></div>
<p>
The regular expression algorithms <a href="../../regex_match.html" title=" regex_match"><tt class="computeroutput"><span class="identifier">regex_match</span></tt></a>, <a href="../../regex_search.html" title=" regex_search"><tt class="computeroutput"><span class="identifier">regex_search</span></tt></a> and <a href="../../regex_replace.html" title=" regex_replace"><tt class="computeroutput"><span class="identifier">regex_replace</span></tt></a> all expect that
The regular expression algorithms <a href="../../regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>, <a href="../../regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a> and <a href="../../regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> all expect that
the character sequence upon which they operate, is encoded in the same
character encoding as the regular expression object with which they are
used. For Unicode regular expressions that behavior is undesirable: while
we may want to process the data in UTF-32 "chunks", the actual
data is much more likely to encoded as either UTF-8 or UTF-16. Therefore
the header &lt;boost/regex/icu.hpp&gt; provides a series of thin wrappers
around these algorithms, called <tt class="computeroutput"><span class="identifier">u32regex_match</span></tt>,
<tt class="computeroutput"><span class="identifier">u32regex_search</span></tt>, and
<tt class="computeroutput"><span class="identifier">u32regex_replace</span></tt>. These
around these algorithms, called <code class="computeroutput"><span class="identifier">u32regex_match</span></code>,
<code class="computeroutput"><span class="identifier">u32regex_search</span></code>, and
<code class="computeroutput"><span class="identifier">u32regex_replace</span></code>. These
wrappers use iterator-adapters internally to make external UTF-8 or UTF-16
data look as though it's really a UTF-32 sequence, that can then be passed
on to the "real" algorithm.
</p>
<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_match"></a><h4>
<a name="id572213"></a>
<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_match"></a><h5>
<a name="id605222"></a>
<a href="unicode_algo.html#boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_match">u32regex_match</a>
</h4>
</h5>
<p>
For each <a href="../../regex_match.html" title=" regex_match"><tt class="computeroutput"><span class="identifier">regex_match</span></tt></a>
algorithm defined by <tt class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>,
then <tt class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt> defines an overloaded algorithm that
takes the same arguments, but which is called <tt class="computeroutput"><span class="identifier">u32regex_match</span></tt>,
For each <a href="../../regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a>
algorithm defined by <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>,
then <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> defines an overloaded algorithm that
takes the same arguments, but which is called <code class="computeroutput"><span class="identifier">u32regex_match</span></code>,
and which will accept UTF-8, UTF-16 or UTF-32 encoded data, as well as
an ICU UnicodeString as input.
</p>
<p>
Example: match a password, encoded in a UTF-16 UnicodeString:
</p>
<pre class="programlisting">
<span class="comment">//
<pre class="programlisting"><span class="comment">//
</span><span class="comment">// Find out if *password* meets our password requirements,
</span><span class="comment">// as defined by the regular expression *requirements*.
</span><span class="comment">//
@ -74,8 +69,7 @@
<p>
Example: match a UTF-8 encoded filename:
</p>
<pre class="programlisting">
<span class="comment">//
<pre class="programlisting"><span class="comment">//
</span><span class="comment">// Extract filename part of a path from a UTF-8 encoded std::string and return the result
</span><span class="comment">// as another std::string:
</span><span class="comment">//
@ -94,23 +88,22 @@
<span class="special">}</span>
<span class="special">}</span>
</pre>
<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_search"></a><h4>
<a name="id572936"></a>
<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_search"></a><h5>
<a name="id605941"></a>
<a href="unicode_algo.html#boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_search">u32regex_search</a>
</h4>
</h5>
<p>
For each <a href="../../regex_search.html" title=" regex_search"><tt class="computeroutput"><span class="identifier">regex_search</span></tt></a>
algorithm defined by <tt class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>,
then <tt class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt> defines an overloaded algorithm that
takes the same arguments, but which is called <tt class="computeroutput"><span class="identifier">u32regex_search</span></tt>,
For each <a href="../../regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>
algorithm defined by <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>,
then <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> defines an overloaded algorithm that
takes the same arguments, but which is called <code class="computeroutput"><span class="identifier">u32regex_search</span></code>,
and which will accept UTF-8, UTF-16 or UTF-32 encoded data, as well as
an ICU UnicodeString as input.
</p>
<p>
Example: search for a character sequence in a specific language block:
</p>
<pre class="programlisting">
<span class="identifier">UnicodeString</span> <span class="identifier">extract_greek</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">UnicodeString</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
<pre class="programlisting"><span class="identifier">UnicodeString</span> <span class="identifier">extract_greek</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">UnicodeString</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
<span class="special">{</span>
<span class="comment">// searches through some UTF-16 encoded text for a block encoded in Greek,
</span> <span class="comment">// this expression is imperfect, but the best we can do for now - searching
@ -134,15 +127,15 @@
<span class="special">}</span>
<span class="special">}</span>
</pre>
<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_replace"></a><h4>
<a name="id573532"></a>
<a name="boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_replace"></a><h5>
<a name="id606534"></a>
<a href="unicode_algo.html#boost_regex.ref.non_std_strings.icu.unicode_algo.u32regex_replace">u32regex_replace</a>
</h4>
</h5>
<p>
For each <a href="../../regex_replace.html" title=" regex_replace"><tt class="computeroutput"><span class="identifier">regex_replace</span></tt></a> algorithm defined
by <tt class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>, then <tt class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt>
For each <a href="../../regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a> algorithm defined
by <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>, then <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
defines an overloaded algorithm that takes the same arguments, but which
is called <tt class="computeroutput"><span class="identifier">u32regex_replace</span></tt>,
is called <code class="computeroutput"><span class="identifier">u32regex_replace</span></code>,
and which will accept UTF-8, UTF-16 or UTF-32 encoded data, as well as
an ICU UnicodeString as input. The input sequence and the format string
specifier passed to the algorithm, can be encoded independently (for
@ -153,8 +146,7 @@
<p>
Example: Credit card number reformatting:
</p>
<pre class="programlisting">
<span class="comment">//
<pre class="programlisting"><span class="comment">//
</span><span class="comment">// Take a credit card number as a string of digits,
</span><span class="comment">// and reformat it as a human readable string with "-"
</span><span class="comment">// separating each group of four digit;,
@ -174,10 +166,11 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

83
doc/html/boost_regex/ref/non_std_strings/icu/unicode_iter.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>
Unicode Aware Regex Iterators</title>
<title>Unicode Aware Regex Iterators</title>
<link rel="stylesheet" href="../../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../../index.html" title="Boost.Regex">
<link rel="up" href="../icu.html" title=" Working With
Unicode and ICU String Types">
<link rel="prev" href="unicode_algo.html" title="
Unicode Regular Expression Algorithms">
<link rel="next" href="../mfc_strings.html" title=" Using
Boost Regex With MFC Strings">
<link rel="up" href="../icu.html" title="Working With Unicode and ICU String Types">
<link rel="prev" href="unicode_algo.html" title="Unicode Regular Expression Algorithms">
<link rel="next" href="../mfc_strings.html" title="Using Boost Regex With MFC Strings">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,23 +24,22 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_regex.ref.non_std_strings.icu.unicode_iter"></a><a href="unicode_iter.html" title="
Unicode Aware Regex Iterators">
Unicode Aware Regex Iterators</a></h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_iterator"></a><h4>
<a name="id573998"></a>
<a name="boost_regex.ref.non_std_strings.icu.unicode_iter"></a><a href="unicode_iter.html" title="Unicode Aware Regex Iterators">
Unicode Aware Regex Iterators</a>
</h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_iterator"></a><h5>
<a name="id606994"></a>
<a href="unicode_iter.html#boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_iterator">u32regex_iterator</a>
</h4>
</h5>
<p>
Type <tt class="computeroutput"><span class="identifier">u32regex_iterator</span></tt>
is in all respects the same as <a href="../../regex_iterator.html" title=" regex_iterator"><tt class="computeroutput"><span class="identifier">regex_iterator</span></tt></a> except that since
the regular expression type is always <tt class="computeroutput"><span class="identifier">u32regex</span></tt>
Type <code class="computeroutput"><span class="identifier">u32regex_iterator</span></code>
is in all respects the same as <a href="../../regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a> except that since
the regular expression type is always <code class="computeroutput"><span class="identifier">u32regex</span></code>
it only takes one template parameter (the iterator type). It also calls
<tt class="computeroutput"><span class="identifier">u32regex_search</span></tt> internally,
<code class="computeroutput"><span class="identifier">u32regex_search</span></code> internally,
allowing it to interface correctly with UTF-8, UTF-16, and UTF-32 data:
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">u32regex_iterator</span>
<span class="special">{</span>
<span class="comment">// for members see regex_iterator
@ -55,12 +50,11 @@
<span class="keyword">typedef</span> <span class="identifier">u32regex_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">UChar32</span><span class="special">*&gt;</span> <span class="identifier">utf32regex_iterator</span><span class="special">;</span>
</pre>
<p>
In order to simplify the construction of a <tt class="computeroutput"><span class="identifier">u32regex_iterator</span></tt>
In order to simplify the construction of a <code class="computeroutput"><span class="identifier">u32regex_iterator</span></code>
from a string, there are a series of non-member helper functions called
make_u32regex_iterator:
</p>
<pre class="programlisting">
<span class="identifier">u32regex_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span>
<pre class="programlisting"><span class="identifier">u32regex_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span>
<span class="identifier">make_u32regex_iterator</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">u32regex</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span>
<span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">m</span> <span class="special">=</span> <span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>
@ -95,8 +89,7 @@
Example: search for international currency symbols, along with their
associated numeric value:
</p>
<pre class="programlisting">
<span class="keyword">void</span> <span class="identifier">enumerate_currencies</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">enumerate_currencies</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
<span class="special">{</span>
<span class="comment">// enumerate and print all the currency symbols, along
</span> <span class="comment">// with any associated numeric values:
@ -132,20 +125,19 @@
<p>
Provided of course that the input is encoded as UTF-8.
</p>
<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_token_iterator"></a><h4>
<a name="id575751"></a>
<a name="boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_token_iterator"></a><h5>
<a name="id608741"></a>
<a href="unicode_iter.html#boost_regex.ref.non_std_strings.icu.unicode_iter.u32regex_token_iterator">u32regex_token_iterator</a>
</h4>
</h5>
<p>
Type <tt class="computeroutput"><span class="identifier">u32regex_token_iterator</span></tt>
is in all respects the same as <a href="../../regex_token_iterator.html" title=" regex_token_iterator"><tt class="computeroutput"><span class="identifier">regex_token_iterator</span></tt></a> except
that since the regular expression type is always <tt class="computeroutput"><span class="identifier">u32regex</span></tt>
Type <code class="computeroutput"><span class="identifier">u32regex_token_iterator</span></code>
is in all respects the same as <a href="../../regex_token_iterator.html" title="regex_token_iterator"><code class="computeroutput"><span class="identifier">regex_token_iterator</span></code></a> except
that since the regular expression type is always <code class="computeroutput"><span class="identifier">u32regex</span></code>
it only takes one template parameter (the iterator type). It also calls
<tt class="computeroutput"><span class="identifier">u32regex_search</span></tt> internally,
<code class="computeroutput"><span class="identifier">u32regex_search</span></code> internally,
allowing it to interface correctly with UTF-8, UTF-16, and UTF-32 data:
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">&gt;</span>
<span class="keyword">class</span> <span class="identifier">u32regex_token_iterator</span>
<span class="special">{</span>
<span class="comment">// for members see regex_token_iterator
@ -156,12 +148,11 @@
<span class="keyword">typedef</span> <span class="identifier">u32regex_token_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">UChar32</span><span class="special">*&gt;</span> <span class="identifier">utf32regex_token_iterator</span><span class="special">;</span>
</pre>
<p>
In order to simplify the construction of a <tt class="computeroutput"><span class="identifier">u32regex_token_iterator</span></tt>
In order to simplify the construction of a <code class="computeroutput"><span class="identifier">u32regex_token_iterator</span></code>
from a string, there are a series of non-member helper functions called
<tt class="computeroutput"><span class="identifier">make_u32regex_token_iterator</span></tt>:
<code class="computeroutput"><span class="identifier">make_u32regex_token_iterator</span></code>:
</p>
<pre class="programlisting">
<span class="identifier">u32regex_token_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span>
<pre class="programlisting"><span class="identifier">u32regex_token_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span>
<span class="identifier">make_u32regex_token_iterator</span><span class="special">(</span>
<span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">s</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">u32regex</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span>
@ -202,8 +193,7 @@
of marked sub-expression sub in regular expression <span class="emphasis"><em>e</em></span>,
found in text <span class="emphasis"><em>s</em></span>, using match_flags <span class="emphasis"><em>m</em></span>.
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span>
<span class="identifier">u32regex_token_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span>
<span class="identifier">make_u32regex_token_iterator</span><span class="special">(</span>
<span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
@ -248,8 +238,7 @@
for each submatch in regular expression <span class="emphasis"><em>e</em></span>, found
in text <span class="emphasis"><em>s</em></span>, using match_flags <span class="emphasis"><em>m</em></span>.
</p>
<pre class="programlisting">
<span class="identifier">u32regex_token_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span>
<pre class="programlisting"><span class="identifier">u32regex_token_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*&gt;</span>
<span class="identifier">make_u32regex_token_iterator</span><span class="special">(</span>
<span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">u32regex</span><span class="special">&amp;</span> <span class="identifier">e</span><span class="special">,</span>
@ -294,8 +283,7 @@
Example: search for international currency symbols, along with their
associated numeric value:
</p>
<pre class="programlisting">
<span class="keyword">void</span> <span class="identifier">enumerate_currencies2</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">enumerate_currencies2</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&amp;</span> <span class="identifier">text</span><span class="special">)</span>
<span class="special">{</span>
<span class="comment">// enumerate and print all the currency symbols, along
</span> <span class="comment">// with any associated numeric values:
@ -321,10 +309,11 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

74
doc/html/boost_regex/ref/non_std_strings/icu/unicode_types.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>
Unicode regular expression types</title>
<title>Unicode regular expression types</title>
<link rel="stylesheet" href="../../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../../index.html" title="Boost.Regex">
<link rel="up" href="../icu.html" title=" Working With
Unicode and ICU String Types">
<link rel="prev" href="intro.html" title=" Introduction
to using Regex with ICU">
<link rel="next" href="unicode_algo.html" title="
Unicode Regular Expression Algorithms">
<link rel="up" href="../icu.html" title="Working With Unicode and ICU String Types">
<link rel="prev" href="intro.html" title="Introduction to using Regex with ICU">
<link rel="next" href="unicode_algo.html" title="Unicode Regular Expression Algorithms">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,113 +24,105 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_regex.ref.non_std_strings.icu.unicode_types"></a><a href="unicode_types.html" title="
Unicode regular expression types">
Unicode regular expression types</a></h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.icu.unicode_types"></a><a href="unicode_types.html" title="Unicode regular expression types">
Unicode regular expression types</a>
</h5></div></div></div>
<p>
Header <tt class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt> provides a regular expression traits
Header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">icu</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> provides a regular expression traits
class that handles UTF-32 characters:
</p>
<pre class="programlisting">
<span class="keyword">class</span> <span class="identifier">icu_regex_traits</span><span class="special">;</span>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">icu_regex_traits</span><span class="special">;</span>
</pre>
<p>
and a regular expression type based upon that:
</p>
<pre class="programlisting">
<span class="keyword">typedef</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">UChar32</span><span class="special">,</span><span class="identifier">icu_regex_traits</span><span class="special">&gt;</span> <span class="identifier">u32regex</span><span class="special">;</span>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">UChar32</span><span class="special">,</span><span class="identifier">icu_regex_traits</span><span class="special">&gt;</span> <span class="identifier">u32regex</span><span class="special">;</span>
</pre>
<p>
The type <tt class="computeroutput"><span class="identifier">u32regex</span></tt> is
The type <code class="computeroutput"><span class="identifier">u32regex</span></code> is
regular expression type to use for all Unicode regular expressions; internally
it uses UTF-32 code points, but can be created from, and used to search,
either UTF-8, or UTF-16 encoded strings as well as UTF-32 ones.
</p>
<p>
The constructors, and assign member functions of <tt class="computeroutput"><span class="identifier">u32regex</span></tt>,
The constructors, and assign member functions of <code class="computeroutput"><span class="identifier">u32regex</span></code>,
require UTF-32 encoded strings, but there are a series of overloaded
algorithms called <tt class="computeroutput"><span class="identifier">make_u32regex</span></tt>
algorithms called <code class="computeroutput"><span class="identifier">make_u32regex</span></code>
which allow regular expressions to be created from UTF-8, UTF-16, or
UTF-32 encoded strings:
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">InputIterator</span><span class="special">&gt;</span>
<span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="identifier">InputIterator</span> <span class="identifier">i</span><span class="special">,</span>
<span class="identifier">InputIterator</span> <span class="identifier">j</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">syntax_option_type</span> <span class="identifier">opt</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: Creates a regular expression
<span class="bold"><strong>Effects</strong></span>: Creates a regular expression
object from the iterator sequence [i,j). The character encoding of the
sequence is determined based upon sizeof(*i): 1 implies UTF-8, 2 implies
UTF-16, and 4 implies UTF-32.
</p>
<pre class="programlisting">
<span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
<pre class="programlisting"><span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">syntax_option_type</span> <span class="identifier">opt</span>
<span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">perl</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: Creates a regular expression
<span class="bold"><strong>Effects</strong></span>: Creates a regular expression
object from the Null-terminated UTF-8 characater sequence <span class="emphasis"><em>p</em></span>.
</p>
<pre class="programlisting">
<span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">unsigned</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
<pre class="programlisting"><span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">unsigned</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">syntax_option_type</span> <span class="identifier">opt</span>
<span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">perl</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: Creates a regular expression
<span class="bold"><strong>Effects</strong></span>: Creates a regular expression
object from the Null-terminated UTF-8 characater sequence p.
</p>
<pre class="programlisting">
<span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
<pre class="programlisting"><span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="keyword">wchar_t</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">syntax_option_type</span> <span class="identifier">opt</span>
<span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">perl</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: Creates a regular expression
<span class="bold"><strong>Effects</strong></span>: Creates a regular expression
object from the Null-terminated characater sequence p. The character
encoding of the sequence is determined based upon sizeof(wchar_t): 1
implies UTF-8, 2 implies UTF-16, and 4 implies UTF-32.
</p>
<pre class="programlisting">
<span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">UChar</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
<pre class="programlisting"><span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">UChar</span><span class="special">*</span> <span class="identifier">p</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">syntax_option_type</span> <span class="identifier">opt</span>
<span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">perl</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: Creates a regular expression
<span class="bold"><strong>Effects</strong></span>: Creates a regular expression
object from the Null-terminated UTF-16 characater sequence p.
</p>
<pre class="programlisting">
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">C</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A</span><span class="special">&gt;</span>
<span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">,</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">A</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">syntax_option_type</span> <span class="identifier">opt</span>
<span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">perl</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: Creates a regular expression
<span class="bold"><strong>Effects</strong></span>: Creates a regular expression
object from the string s. The character encoding of the string is determined
based upon sizeof(C): 1 implies UTF-8, 2 implies UTF-16, and 4 implies
UTF-32.
</p>
<pre class="programlisting">
<span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">UnicodeString</span><span class="special">&amp;</span> <span class="identifier">s</span><span class="special">,</span>
<pre class="programlisting"><span class="identifier">u32regex</span> <span class="identifier">make_u32regex</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">UnicodeString</span><span class="special">&amp;</span> <span class="identifier">s</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">syntax_option_type</span> <span class="identifier">opt</span>
<span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">perl</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: Creates a regular expression
<span class="bold"><strong>Effects</strong></span>: Creates a regular expression
object from the UTF-16 encoding string s.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

25
doc/html/boost_regex/ref/non_std_strings/mfc_strings.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title> Using
Boost Regex With MFC Strings</title>
<title>Using Boost Regex With MFC Strings</title>
<link rel="stylesheet" href="../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../index.html" title="Boost.Regex">
<link rel="up" href="../non_std_strings.html" title=" Interfacing With Non-Standard
String Types">
<link rel="prev" href="icu/unicode_iter.html" title="
Unicode Aware Regex Iterators">
<link rel="next" href="mfc_strings/mfc_intro.html" title="
Introduction to Boost.Regex and MFC Strings">
<link rel="up" href="../non_std_strings.html" title="Interfacing With Non-Standard String Types">
<link rel="prev" href="icu/unicode_iter.html" title="Unicode Aware Regex Iterators">
<link rel="next" href="mfc_strings/mfc_intro.html" title="Introduction to Boost.Regex and MFC Strings">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,9 +24,9 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h4 class="title">
<a name="boost_regex.ref.non_std_strings.mfc_strings"></a><a href="mfc_strings.html" title=" Using
Boost Regex With MFC Strings"> Using
Boost Regex With MFC Strings</a></h4></div></div></div>
<a name="boost_regex.ref.non_std_strings.mfc_strings"></a><a href="mfc_strings.html" title="Using Boost Regex With MFC Strings"> Using
Boost Regex With MFC Strings</a>
</h4></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="mfc_strings/mfc_intro.html">
Introduction to Boost.Regex and MFC Strings</a></span></dt>
@ -46,10 +42,11 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

125
doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_algo.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>
Overloaded Algorithms For MFC String Types</title>
<title>Overloaded Algorithms For MFC String Types</title>
<link rel="stylesheet" href="../../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../../index.html" title="Boost.Regex">
<link rel="up" href="../mfc_strings.html" title=" Using
Boost Regex With MFC Strings">
<link rel="prev" href="mfc_regex_create.html" title="
Regular Expression Creation From an MFC String">
<link rel="next" href="mfc_iter.html" title="
Iterating Over the Matches Within An MFC String">
<link rel="up" href="../mfc_strings.html" title="Using Boost Regex With MFC Strings">
<link rel="prev" href="mfc_regex_create.html" title="Regular Expression Creation From an MFC String">
<link rel="next" href="mfc_iter.html" title="Iterating Over the Matches Within An MFC String">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,31 +24,30 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo"></a><a href="mfc_algo.html" title="
Overloaded Algorithms For MFC String Types">
Overloaded Algorithms For MFC String Types</a></h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo"></a><a href="mfc_algo.html" title="Overloaded Algorithms For MFC String Types">
Overloaded Algorithms For MFC String Types</a>
</h5></div></div></div>
<p>
For each regular expression algorithm that's overloaded for a <tt class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></tt> argument, there is also
For each regular expression algorithm that's overloaded for a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">basic_string</span></code> argument, there is also
one overloaded for the MFC/ATL string types. These algorithm signatures
all look a lot more complex than they actually are, but for completeness
here they are anyway:
</p>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match"></a><h4>
<a name="id580927"></a>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match"></a><h5>
<a name="id613898"></a>
<a href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match">regex_match</a>
</h4>
</h5>
<p>
There are two overloads, the first reports what matched in a match_results
structure, the second does not.
</p>
<p>
All the usual caveats for <a href="../../regex_match.html" title=" regex_match"><tt class="computeroutput"><span class="identifier">regex_match</span></tt></a> apply, in particular
All the usual caveats for <a href="../../regex_match.html" title="regex_match"><code class="computeroutput"><span class="identifier">regex_match</span></code></a> apply, in particular
the algorithm will only report a successful match if all of the input
text matches the expression, if this isn't what you want then use <a href="../../regex_search.html" title=" regex_search"><tt class="computeroutput"><span class="identifier">regex_search</span></tt></a>
text matches the expression, if this isn't what you want then use <a href="../../regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>
instead.
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_match</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
<span class="identifier">match_results</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">B</span><span class="special">*,</span> <span class="identifier">A</span><span class="special">&gt;&amp;</span> <span class="identifier">what</span><span class="special">,</span>
@ -60,15 +55,14 @@
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns <tt class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_match</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span>
<span class="bold"><strong>Effects</strong></span>: returns <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_match</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span>
<span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span> <span class="identifier">what</span><span class="special">,</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span></tt>
<span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span> <span class="identifier">what</span><span class="special">,</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span></code>
</p>
<p>
<span class="bold"><b>Example:</b></span>
<span class="bold"><strong>Example:</strong></span>
</p>
<pre class="programlisting">
<span class="comment">//
<pre class="programlisting"><span class="comment">//
</span><span class="comment">// Extract filename part of a path from a CString and return the result
</span><span class="comment">// as another CString:
</span><span class="comment">//
@ -87,28 +81,26 @@
<span class="special">}</span>
<span class="special">}</span>
</pre>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match__second_overload_"></a><h4>
<a name="id581844"></a>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match__second_overload_"></a><h5>
<a name="id614810"></a>
<a href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_match__second_overload_">regex_match
(second overload)</a>
</h4>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
</h5>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_match</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">)</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns <tt class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_match</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span>
<span class="bold"><strong>Effects</strong></span>: returns <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_match</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span>
<span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span></tt>
<span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span></code>
</p>
<p>
<span class="bold"><b>Example:</b></span>
<span class="bold"><strong>Example:</strong></span>
</p>
<pre class="programlisting">
<span class="comment">//
<pre class="programlisting"><span class="comment">//
</span><span class="comment">// Find out if *password* meets our password requirements,
</span><span class="comment">// as defined by the regular expression *requirements*.
</span><span class="comment">//
@ -117,31 +109,29 @@
<span class="keyword">return</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_match</span><span class="special">(</span><span class="identifier">password</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">make_regex</span><span class="special">(</span><span class="identifier">requirements</span><span class="special">));</span>
<span class="special">}</span>
</pre>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search"></a><h4>
<a name="id582440"></a>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search"></a><h5>
<a name="id615401"></a>
<a href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search">regex_search</a>
</h4>
</h5>
<p>
There are two additional overloads for <a href="../../regex_search.html" title=" regex_search"><tt class="computeroutput"><span class="identifier">regex_search</span></tt></a>, the first reports
There are two additional overloads for <a href="../../regex_search.html" title="regex_search"><code class="computeroutput"><span class="identifier">regex_search</span></code></a>, the first reports
what matched the second does not:
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">A</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">bool</span> <span class="identifier">regex_search</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
<span class="identifier">match_results</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">charT</span><span class="special">*,</span> <span class="identifier">A</span><span class="special">&gt;&amp;</span> <span class="identifier">what</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">)</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns ::boost::regex_search(s.GetString(),
<span class="bold"><strong>Effects</strong></span>: returns ::boost::regex_search(s.GetString(),
s.GetString() + s.GetLength(), what, e, f);
</p>
<p>
<span class="bold"><b>Example</b></span>: Postcode extraction from an
<span class="bold"><strong>Example</strong></span>: Postcode extraction from an
address string.
</p>
<pre class="programlisting">
<span class="identifier">CString</span> <span class="identifier">extract_postcode</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CString</span><span class="special">&amp;</span> <span class="identifier">address</span><span class="special">)</span>
<pre class="programlisting"><span class="identifier">CString</span> <span class="identifier">extract_postcode</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CString</span><span class="special">&amp;</span> <span class="identifier">address</span><span class="special">)</span>
<span class="special">{</span>
<span class="comment">// searches throw address for a UK postcode and returns the result,
</span> <span class="comment">// the expression used is by Phil A. on www.regxlib.com:
@ -158,32 +148,30 @@
<span class="special">}</span>
<span class="special">}</span>
</pre>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search__second_overload_"></a><h4>
<a name="id583183"></a>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search__second_overload_"></a><h5>
<a name="id616138"></a>
<a href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_search__second_overload_">regex_search
(second overload)</a>
</h4>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
</h5>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">T</span><span class="special">&gt;</span>
<span class="keyword">inline</span> <span class="keyword">bool</span> <span class="identifier">regex_search</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">T</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">)</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns <tt class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_search</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span>
<span class="bold"><strong>Effects</strong></span>: returns <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_search</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span>
<span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span>
<span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span></tt>
<span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">f</span><span class="special">);</span></code>
</p>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_replace"></a><h4>
<a name="id583590"></a>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_replace"></a><h5>
<a name="id616543"></a>
<a href="mfc_algo.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_algo.regex_replace">regex_replace</a>
</h4>
</h5>
<p>
There are two additional overloads for <a href="../../regex_replace.html" title=" regex_replace"><tt class="computeroutput"><span class="identifier">regex_replace</span></tt></a>, the first sends
There are two additional overloads for <a href="../../regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a>, the first sends
output to an output iterator, while the second creates a new string
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">,</span> <span class="keyword">class</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BidirectionalIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">traits</span><span class="special">,</span> <span class="keyword">class</span>
<span class="identifier">charT</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">regex_replace</span><span class="special">(</span><span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
<span class="identifier">BidirectionalIterator</span> <span class="identifier">first</span><span class="special">,</span>
@ -193,26 +181,24 @@
<span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">match_default</span><span class="special">)</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns <tt class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_replace</span><span class="special">(</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">fmt</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span>
<span class="identifier">flags</span><span class="special">);</span></tt>
<span class="bold"><strong>Effects</strong></span>: returns <code class="computeroutput"><span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_replace</span><span class="special">(</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">last</span><span class="special">,</span> <span class="identifier">e</span><span class="special">,</span> <span class="identifier">fmt</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span>
<span class="identifier">flags</span><span class="special">);</span></code>
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">traits</span><span class="special">,</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">traits</span><span class="special">,</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span> <span class="identifier">regex_replace</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">,</span> <span class="identifier">traits</span><span class="special">&gt;&amp;</span> <span class="identifier">e</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">fmt</span><span class="special">,</span>
<span class="identifier">match_flag_type</span> <span class="identifier">flags</span> <span class="special">=</span> <span class="identifier">match_default</span><span class="special">)</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns a new string created
using <a href="../../regex_replace.html" title=" regex_replace"><tt class="computeroutput"><span class="identifier">regex_replace</span></tt></a>,
<span class="bold"><strong>Effects</strong></span>: returns a new string created
using <a href="../../regex_replace.html" title="regex_replace"><code class="computeroutput"><span class="identifier">regex_replace</span></code></a>,
and the same memory manager as string <span class="emphasis"><em>s</em></span>.
</p>
<p>
<span class="bold"><b>Example</b></span>:
<span class="bold"><strong>Example</strong></span>:
</p>
<pre class="programlisting">
<span class="comment">//
<pre class="programlisting"><span class="comment">//
</span><span class="comment">// Take a credit card number as a string of digits,
</span><span class="comment">// and reformat it as a human readable string with "-"
</span><span class="comment">// separating each group of four digits:
@ -228,10 +214,11 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

30
doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_intro.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>
Introduction to Boost.Regex and MFC Strings</title>
<title>Introduction to Boost.Regex and MFC Strings</title>
<link rel="stylesheet" href="../../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../../index.html" title="Boost.Regex">
<link rel="up" href="../mfc_strings.html" title=" Using
Boost Regex With MFC Strings">
<link rel="prev" href="../mfc_strings.html" title=" Using
Boost Regex With MFC Strings">
<link rel="next" href="mfc_regex_types.html" title="
Regex Types Used With MFC Strings">
<link rel="up" href="../mfc_strings.html" title="Using Boost Regex With MFC Strings">
<link rel="prev" href="../mfc_strings.html" title="Using Boost Regex With MFC Strings">
<link rel="next" href="mfc_regex_types.html" title="Regex Types Used With MFC Strings">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,11 +24,11 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_intro"></a><a href="mfc_intro.html" title="
Introduction to Boost.Regex and MFC Strings">
Introduction to Boost.Regex and MFC Strings</a></h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_intro"></a><a href="mfc_intro.html" title="Introduction to Boost.Regex and MFC Strings">
Introduction to Boost.Regex and MFC Strings</a>
</h5></div></div></div>
<p>
The header <tt class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">mfc</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></tt> provides Boost.Regex support for
The header <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">regex</span><span class="special">/</span><span class="identifier">mfc</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code> provides Boost.Regex support for
MFC string types: note that this support requires Visual Studio .NET
(Visual C++ 7) or later, where all of the MFC and ATL string types are
based around the CSimpleStringT class template.
@ -42,8 +38,7 @@
then you can substitute any of the following MFC/ATL types (all of which
inherit from CSimpleStringT):
</p>
<pre class="programlisting">
<span class="identifier">CString</span>
<pre class="programlisting"><span class="identifier">CString</span>
<span class="identifier">CStringA</span>
<span class="identifier">CStringW</span>
<span class="identifier">CAtlString</span>
@ -56,10 +51,11 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

76
doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_iter.html
View File

@ -1,16 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>
Iterating Over the Matches Within An MFC String</title>
<title>Iterating Over the Matches Within An MFC String</title>
<link rel="stylesheet" href="../../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../../index.html" title="Boost.Regex">
<link rel="up" href="../mfc_strings.html" title=" Using
Boost Regex With MFC Strings">
<link rel="prev" href="mfc_algo.html" title="
Overloaded Algorithms For MFC String Types">
<link rel="next" href="../../posix.html" title=" POSIX Compatible C API's">
<link rel="up" href="../mfc_strings.html" title="Using Boost Regex With MFC Strings">
<link rel="prev" href="mfc_algo.html" title="Overloaded Algorithms For MFC String Types">
<link rel="next" href="../../posix.html" title="POSIX Compatible C API's">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -27,20 +24,19 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter"></a><a href="mfc_iter.html" title="
Iterating Over the Matches Within An MFC String">
Iterating Over the Matches Within An MFC String</a></h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter"></a><a href="mfc_iter.html" title="Iterating Over the Matches Within An MFC String">
Iterating Over the Matches Within An MFC String</a>
</h5></div></div></div>
<p>
The following helper functions are provided to ease the conversion from
an MFC/ATL string to a <a href="../../regex_iterator.html" title=" regex_iterator"><tt class="computeroutput"><span class="identifier">regex_iterator</span></tt></a> or <a href="../../regex_token_iterator.html" title=" regex_token_iterator"><tt class="computeroutput"><span class="identifier">regex_token_iterator</span></tt></a>:
an MFC/ATL string to a <a href="../../regex_iterator.html" title="regex_iterator"><code class="computeroutput"><span class="identifier">regex_iterator</span></code></a> or <a href="../../regex_token_iterator.html" title="regex_token_iterator"><code class="computeroutput"><span class="identifier">regex_token_iterator</span></code></a>:
</p>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_iterator_creation_helper"></a><h4>
<a name="id584678"></a>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_iterator_creation_helper"></a><h5>
<a name="id617624"></a>
<a href="mfc_iter.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_iterator_creation_helper">regex_iterator
creation helper</a>
</h4>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
</h5>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<span class="identifier">regex_iterator</span><span class="special">&lt;</span><span class="identifier">charT</span> <span class="keyword">const</span><span class="special">*&gt;</span>
<span class="identifier">make_regex_iterator</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
@ -48,15 +44,14 @@
<span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns <tt class="computeroutput"><span class="identifier">regex_iterator</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="bold"><strong>Effects</strong></span>: returns <code class="computeroutput"><span class="identifier">regex_iterator</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="identifier">e</span><span class="special">,</span>
<span class="identifier">f</span><span class="special">);</span></tt>
<span class="identifier">f</span><span class="special">);</span></code>
</p>
<p>
<span class="bold"><b>Example</b></span>:
<span class="bold"><strong>Example</strong></span>:
</p>
<pre class="programlisting">
<span class="keyword">void</span> <span class="identifier">enumerate_links</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CString</span><span class="special">&amp;</span> <span class="identifier">html</span><span class="special">)</span>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">enumerate_links</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CString</span><span class="special">&amp;</span> <span class="identifier">html</span><span class="special">)</span>
<span class="special">{</span>
<span class="comment">// enumerate and print all the links in some HTML text,
</span> <span class="comment">// the expression used is by Andew Lee on www.regxlib.com:
@ -72,13 +67,12 @@
<span class="special">}</span>
<span class="special">}</span>
</pre>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_token_iterator_creation_helpers"></a><h4>
<a name="id585433"></a>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_token_iterator_creation_helpers"></a><h5>
<a name="id618372"></a>
<a href="mfc_iter.html#boost_regex.ref.non_std_strings.mfc_strings.mfc_iter.regex_token_iterator_creation_helpers">regex_token_iterator
creation helpers</a>
</h4>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
</h5>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<span class="identifier">regex_token_iterator</span><span class="special">&lt;</span><span class="identifier">charT</span> <span class="keyword">const</span><span class="special">*&gt;</span>
<span class="identifier">make_regex_token_iterator</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
@ -87,13 +81,12 @@
<span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns <tt class="computeroutput"><span class="identifier">regex_token_iterator</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="bold"><strong>Effects</strong></span>: returns <code class="computeroutput"><span class="identifier">regex_token_iterator</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="identifier">e</span><span class="special">,</span>
<span class="identifier">sub</span><span class="special">,</span>
<span class="identifier">f</span><span class="special">);</span></tt>
<span class="identifier">f</span><span class="special">);</span></code>
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<span class="identifier">regex_token_iterator</span><span class="special">&lt;</span><span class="identifier">charT</span> <span class="keyword">const</span><span class="special">*&gt;</span>
<span class="identifier">make_regex_token_iterator</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
@ -102,13 +95,12 @@
<span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns <tt class="computeroutput"><span class="identifier">regex_token_iterator</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="bold"><strong>Effects</strong></span>: returns <code class="computeroutput"><span class="identifier">regex_token_iterator</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="identifier">e</span><span class="special">,</span>
<span class="identifier">subs</span><span class="special">,</span>
<span class="identifier">f</span><span class="special">);</span></tt>
<span class="identifier">f</span><span class="special">);</span></code>
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">N</span><span class="special">&gt;</span>
<span class="identifier">regex_token_iterator</span><span class="special">&lt;</span><span class="identifier">charT</span> <span class="keyword">const</span><span class="special">*&gt;</span>
<span class="identifier">make_regex_token_iterator</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
@ -117,16 +109,15 @@
<span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_flag_type</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">match_default</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns <tt class="computeroutput"><span class="identifier">regex_token_iterator</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="bold"><strong>Effects</strong></span>: returns <code class="computeroutput"><span class="identifier">regex_token_iterator</span><span class="special">(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="identifier">e</span><span class="special">,</span>
<span class="identifier">subs</span><span class="special">,</span>
<span class="identifier">f</span><span class="special">);</span></tt>
<span class="identifier">f</span><span class="special">);</span></code>
</p>
<p>
<span class="bold"><b>Example</b></span>:
<span class="bold"><strong>Example</strong></span>:
</p>
<pre class="programlisting">
<span class="keyword">void</span> <span class="identifier">enumerate_links2</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CString</span><span class="special">&amp;</span> <span class="identifier">html</span><span class="special">)</span>
<pre class="programlisting"><span class="keyword">void</span> <span class="identifier">enumerate_links2</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">CString</span><span class="special">&amp;</span> <span class="identifier">html</span><span class="special">)</span>
<span class="special">{</span>
<span class="comment">// enumerate and print all the links in some HTML text,
</span> <span class="comment">// the expression used is by Andew Lee on www.regxlib.com:
@ -145,10 +136,11 @@
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

32
doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_create.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>
Regular Expression Creation From an MFC String</title>
<title>Regular Expression Creation From an MFC String</title>
<link rel="stylesheet" href="../../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../../index.html" title="Boost.Regex">
<link rel="up" href="../mfc_strings.html" title=" Using
Boost Regex With MFC Strings">
<link rel="prev" href="mfc_regex_types.html" title="
Regex Types Used With MFC Strings">
<link rel="next" href="mfc_algo.html" title="
Overloaded Algorithms For MFC String Types">
<link rel="up" href="../mfc_strings.html" title="Using Boost Regex With MFC Strings">
<link rel="prev" href="mfc_regex_types.html" title="Regex Types Used With MFC Strings">
<link rel="next" href="mfc_algo.html" title="Overloaded Algorithms For MFC String Types">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,30 +24,30 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_regex_create"></a><a href="mfc_regex_create.html" title="
Regular Expression Creation From an MFC String">
Regular Expression Creation From an MFC String</a></h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_regex_create"></a><a href="mfc_regex_create.html" title="Regular Expression Creation From an MFC String">
Regular Expression Creation From an MFC String</a>
</h5></div></div></div>
<p>
The following helper function is available to assist in the creation
of a regular expression from an MFC/ATL string type:
</p>
<pre class="programlisting">
<span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">charT</span><span class="special">&gt;</span>
<span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;</span>
<span class="identifier">make_regex</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ATL</span><span class="special">::</span><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;&amp;</span> <span class="identifier">s</span><span class="special">,</span>
<span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">syntax_option_type</span> <span class="identifier">f</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">normal</span><span class="special">);</span>
</pre>
<p>
<span class="bold"><b>Effects</b></span>: returns <tt class="computeroutput"><span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="identifier">f</span><span class="special">);</span></tt>
<span class="bold"><strong>Effects</strong></span>: returns <code class="computeroutput"><span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">charT</span><span class="special">&gt;(</span><span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">(),</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetString</span><span class="special">()</span> <span class="special">+</span> <span class="identifier">s</span><span class="special">.</span><span class="identifier">GetLength</span><span class="special">(),</span>
<span class="identifier">f</span><span class="special">);</span></code>
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">

32
doc/html/boost_regex/ref/non_std_strings/mfc_strings/mfc_regex_types.html
View File

@ -1,17 +1,13 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>
Regex Types Used With MFC Strings</title>
<title>Regex Types Used With MFC Strings</title>
<link rel="stylesheet" href="../../../../../../../../doc/html/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.66.1">
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot_2006-12-17_0120">
<link rel="start" href="../../../../index.html" title="Boost.Regex">
<link rel="up" href="../mfc_strings.html" title=" Using
Boost Regex With MFC Strings">
<link rel="prev" href="mfc_intro.html" title="
Introduction to Boost.Regex and MFC Strings">
<link rel="next" href="mfc_regex_create.html" title="
Regular Expression Creation From an MFC String">
<link rel="up" href="../mfc_strings.html" title="Using Boost Regex With MFC Strings">
<link rel="prev" href="mfc_intro.html" title="Introduction to Boost.Regex and MFC Strings">
<link rel="next" href="mfc_regex_create.html" title="Regular Expression Creation From an MFC String">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
@ -28,31 +24,31 @@
</div>
<div class="section" lang="en">
<div class="titlepage"><div><div><h5 class="title">
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_regex_types"></a><a href="mfc_regex_types.html" title="
Regex Types Used With MFC Strings">
Regex Types Used With MFC Strings</a></h5></div></div></div>
<a name="boost_regex.ref.non_std_strings.mfc_strings.mfc_regex_types"></a><a href="mfc_regex_types.html" title="Regex Types Used With MFC Strings">
Regex Types Used With MFC Strings</a>
</h5></div></div></div>
<p>
The following typedefs are provided for the convenience of those working
with TCHAR's:
</p>
<pre class="programlisting">
<span class="keyword">typedef</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">TCHAR</span><span class="special">&gt;</span> <span class="identifier">tregex</span><span class="special">;</span>
<pre class="programlisting"><span class="keyword">typedef</span> <span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">TCHAR</span><span class="special">&gt;</span> <span class="identifier">tregex</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">match_results</span><span class="special">&lt;</span><span class="identifier">TCHAR</span> <span class="keyword">const</span><span class="special">*&gt;</span> <span class="identifier">tmatch</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">regex_iterator</span><span class="special">&lt;</span><span class="identifier">TCHAR</span> <span class="keyword">const</span><span class="special">*&gt;</span> <span class="identifier">tregex_iterator</span><span class="special">;</span>
<span class="keyword">typedef</span> <span class="identifier">regex_token_iterator</span><span class="special">&lt;</span><span class="identifier">TCHAR</span> <span class="keyword">const</span><span class="special">*&gt;</span> <span class="identifier">tregex_token_iterator</span><span class="special">;</span>
</pre>
<p>
If you are working with explicitly narrow or wide characters rather than
TCHAR, then use the regular Boost.Regex types <tt class="computeroutput"><span class="identifier">regex</span></tt>
and <tt class="computeroutput"><span class="identifier">wregex</span></tt> instead.
TCHAR, then use the regular Boost.Regex types <code class="computeroutput"><span class="identifier">regex</span></code>
and <code class="computeroutput"><span class="identifier">wregex</span></code> instead.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"></td>
<td align="right"><div class="copyright-footer"><small>Copyright <20> 2007 John Maddock<p>
<td align="right"><div class="copyright-footer">Copyright <20> 1998 -2007 John Maddock<p>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
</p></small></div></td>
</p>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">