Compare commits

..

1 Commits

Author SHA1 Message Date
a4c9c3eb65 Branch at revision 46530
[SVN r46531]
2008-06-19 18:57:10 +00:00
557 changed files with 5460 additions and 61127 deletions

View File

@ -8,23 +8,25 @@
#// For more information, see http://www.boost.org/libs/range/
#//
project boost/libs/range/doc ;
using boostbook ;
using quickbook ;
path-constant images_location : html ;
use-project boost : $(BOOST_ROOT) ;
boostbook quickbook
import boostbook : boostbook ;
import quickbook ;
xml boost_range : boost_range.qbk ;
boostbook standalone
:
boost_range.qbk
boost_range
:
<xsl:param>boost.root=../../../..
<xsl:param>chunk.section.depth=4
<xsl:param>chunk.first.sections=1
<xsl:param>toc.section.depth=3
<xsl:param>toc.max.depth=3
<xsl:param>generate.section.toc.level=4
<format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
<format>pdf:<xsl:param>img.src.path=$(images_location)/
<xsl:param>toc.max.depth=2
<xsl:param>toc.section.depth=4
<xsl:param>chunk.section.depth=2
# <xsl:param>generate.section.toc.level=4
# <xsl:param>chunk.first.sections=7
# <xsl:param>toc.section.depth=10
;

769
doc/boost_range.html Normal file
View File

@ -0,0 +1,769 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<title>Boost.Range Reference </title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body>
<table>
<tr>
<td><img src="../../../boost.png" width="100%" border="0"></td>
<td><h1><br>
Boost.Range
</h1>
</td>
</tr>
</table>
<h2>Synopsis and Reference
</h2>
<ul>
<li>
<a href="#overview">Overview</a>
<li>
<a href="#Synopsis">Synopsis</a>
<li>
<a href="#Semantics">Semantics</a>
<li>
<a href="#minimal_interface">Extending the library</a></li>
</ul>
<hr size="1">
<a name="overview"></a>
<h3>Overview</h3>
<p>
Three types of objects are currently supported by the library:
<ul>
<li>
standard-like containers
<li>
<code>std::pair&lt;iterator,iterator&gt;</code>
<li>
built-in arrays
</li>
</ul>
Even though the behavior of the primary templates are exactly such that
standard containers will be supported by default, the requirements are much
lower than the standard container requirements. For example, the utility class <a href="utility_class.html#iter_range">
<code>iterator_range</code></a> implements the <a href="#minimal_interface">minimal
interface</a> required to make the class a <a href="range.html#forward_range">Forward
Range</a>
.
<P></P>
<p>
Please also see <a href="range.html">Range concepts</a> for more details.
</p>
<a name="Synopsis"></a>
<h3>Synopsis</h3>
<p>
<pre>
<span class=keyword>namespace </span><span class=identifier>boost</span>
<span class=special>{
</span><span class=comment>//
// Single Pass Range metafunctions
//
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>struct </span><a href="#range_iterator"><span
class=identifier>range_iterator</span></a><span class=special>;
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>struct </span><a href="#range_value"><span
class=identifier>range_value</span></a><span class=special>;
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>struct </span><a href="#range_reference"><span
class=identifier>range_reference</span></a><span class=special>;
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>struct </span><a href="#range_pointer"><span
class=identifier>range_pointer</span></a><span class=special>;
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>struct </span><a href="#range_category"><span
class=identifier>range_category</span></a><span class=special>;
</span><span class=comment>//
// Forward Range metafunctions
//
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>struct </span><a href="#range_difference"><span
class=identifier>range_difference</span></a><span class=special>;
</span><span class=comment>//
// Bidirectional Range metafunctions
//
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>struct </span><a
href="#range_reverse_iterator"><span
class=identifier>range_reverse_iterator</span></a><span class=special>;
</span><span class=comment>//
// Single Pass Range functions
//
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#begin"><span class=identifier>begin</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#begin"><span class=identifier>begin</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#end"><span class=identifier>end</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#end"><span class=identifier>end</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>bool
</span><a href="#empty"><span class=identifier>empty</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span><span class=comment>//
// Forward Range functions
//
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_difference</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#size"><span class=identifier>distance</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span><span class=comment>//
// Bidirectional Range functions
//
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#rbegin"><span class=identifier>rbegin</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#rbegin"><span class=identifier>rbegin</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#rend"><span class=identifier>rend</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#rend"><span class=identifier>rend</span></a><span class=special>( </span><span class=keyword>const </span><span
class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span>
</span><span class=comment>//
// Random Access Range functions
//
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_difference</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
</span><a href="#size"><span class=identifier>size</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);</span>
<span class=comment>//
// Special const Range functions
//
</span>
<span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;</span>
<span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
<a href="#const_begin"><span class=identifier>const_begin</span></a><span class=special>(</span><span class=keyword> const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span>
<span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;</span>
<span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
<a href="#const_end"><span class=identifier>const_end</span></a><span class=special>(</span><span class=keyword> const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span>
<span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;</span>
<span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
<a href="#const_rbegin"><span class=identifier>const_rbegin</span></a><span class=special>(</span><span class=keyword> const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
</span>
<span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;</span>
<span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
<a href="#const_rend"><span class=identifier>const_rend</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);</span>
<span class=comment>//
// String utilities
//</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=identifier>iterator_range</span><span class=special>&lt;...</span><span class=identifier>see</span> <span class=identifier>below</span><span class=special>...&gt;</span>
<span class=identifier><a href="#as_literal">as_literal</a></span><span class=special>(</span> <span class=identifier>T</span><span class=special>&amp;</span> <span class=identifier>r</span> <span class=special>);</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=identifier>iterator_range</span><span class=special>&lt;...</span><span class=identifier>see</span> <span class=identifier>below</span><span class=special>...&gt;</span>
<span class=identifier><a href="#as_array">as_literal</a></span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>T</span><span class=special>&amp;</span> <span class=identifier>r</span> <span class=special>);</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=identifier>iterator_range</span><span class=special>&lt;</span> <span class=keyword>typename</span> <span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=special>&gt;</span>
<span class=identifier><a href="#as_array">as_array</a></span><span class=special>(</span> <span class=identifier>T</span><span class=special>&amp;</span> <span class=identifier>r</span> <span class=special>);</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=identifier>iterator_range</span><span class=special>&lt;</span> <span class=keyword>typename</span> <span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=keyword>const</span> <span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=special>&gt;</span>
<span class=identifier><a href="#as_literal">as_array</a></span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>T</span><span class=special>&amp;</span> <span class=identifier>r</span> <span class=special>);</span>
<span class=special>} </span><span class=comment>// namespace 'boost'
</span>
</pre>
<P></P>
<a name="Semantics"></a>
<h3>Semantics</h3>
<h4>notation</h4>
<p>
<table cellpadding="5" border="1">
<tr>
<th>
Type
<th>
Object
<th>
Describes
</tr>
<tr>
<td><code>X</code>
<td><code>x</code>
<td>any type</td>
<tr>
<td><code>T</code>
</td>
<td><code>t</code>
<td>denotes behavior of the primary templates</td>
</tr>
<tr>
<td><code>P</code>
<td><code>p</code>
<td>denotes <code>std::pair&lt;iterator,iterator&gt;</code></td>
<tr>
<td><code>A[sz]</code>
<td><code>a</code>
<td>denotes an array of type <code>A</code> of size <code>sz</code>
<tr>
<tr>
<td><code>Char*</code>
<td><code>s</code>
<td>denotes either <code>char*</code> or <code>wchar_t*</code></td>
</tr>
</table>
</p>
<p>
Please notice in tables below that when four lines appear in a cell, the first
line will describe the primary template, the second line pairs of iterators,
the third line arrays and the last line null-terminated strings.
</p>
<h4>Metafunctions</h4>
<p>
<table border="1" cellpadding="5">
<tr>
<th>
Expression</th>
<th>
Return type</th>
<th>
Complexity</th>
</tr>
<tr>
<a name="range_iterator"></a>
<td><code>range_iterator&lt;X&gt;::type</code></td>
<td><code>T::iterator</code><br>
<code>P::first_type</code><br>
<code>A*</code><br>
<td>compile time</td>
</tr>
<tr>
<a name="range_const_iterator"></a>
<td><code>range_iterator&lt;const X&gt;::type</code></td>
<td><code>T::const_iterator</code><br>
<code>P::first_type</code><br>
<code>const A*</code><br>
<td>compile time</td>
</tr>
<tr>
<a name="range_value"></a>
<td><code>range_value&lt;X&gt;::type</code></td>
<td><code>boost::iterator_value&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
</td>
<td>compile time</td>
</tr>
<tr>
<a name="range_reference"></a>
<td><code>range_reference&lt;X&gt;::type</code></td>
<td><code>boost::iterator_reference&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
</td>
<td>compile time</td>
</tr>
<tr>
<a name="range_pointer"></a>
<td><code>range_pointer&lt;X&gt;::type</code></td>
<td><code>boost::iterator_pointer&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
</td>
<td>compile time</td>
</tr>
<tr>
<a name="range_category"></a>
<td><code>range_category&lt;X&gt;::type</code></td>
<td><code>boost::iterator_category&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
</td>
<td>compile time</td>
</tr>
<tr>
<a name="range_difference"></a>
<td><code>range_difference&lt;X&gt;::type</code></td>
<td>
<code>boost::iterator_difference&lt;range_iterator&lt;X&gt;::type&gt;::type</code></td>
<td>compile time</td>
</tr>
</tr>
<tr>
<a name="range_reverse_iterator"></a>
<td><code>range_reverse_iterator&lt;X&gt;::type</code></td>
<td><code>boost::reverse_iterator&lt;range_iterator&lt;X&gt;::type&gt;</code><br>
<td>compile time</td>
</tr>
<tr>
<a name="range_const_reverse_iterator"></a>
<td><code>range_reverse_iterator&lt;const X&gt;::type</code></td>
<td><code>boost::reverse_iterator&lt;range_iterator&lt;const X&gt;::type&gt;</code>
<br>
<td>compile time</td>
</tr>
</table>
</p>
<h4>Functions</h4>
<p>
<table border="1" cellpadding="5">
<tr>
<th>
Expression</th>
<th>
Return type</th>
<th>
Returns</th>
<th>
Complexity</th>
</tr>
<tr>
<a name="begin"></a>
<td><code>begin(x)</code></td>
<td><code>range_iterator&lt;X&gt;::type</code></td>
<td>
<code>p.first</code> if <code>p</code> is of type <code>std::pair&ltT&gt;<code><br>
<code>a</code> if <code>a</code> is an array <br>
<code>range_begin(x)</code> if that expression would invoke a function found by ADL <br>
<code>t.begin()</code> otherwise
<td>constant time</td>
</tr>
<tr>
<a name="end"></a>
<td><code>end(x)</code></td>
<td><code>range_iterator&lt;X&gt;::type</code></td>
<td>
<code>p.second</code> if <code>p</code> is of type <code>std::pair&ltT&gt;<code><br>
<code>a + sz</code> if <code>a</code> is an array of size <code>sz</code>
<br>
<code>range_end(x)</code> if that expression would invoke a function found by ADL <br>
<code>t.end()</code> otherwise
<td>
constant time </td>
</tr>
<tr>
<a name="empty"></a>
<td><code>empty(x)</code></td>
<td><code>bool</code></td>
<td><code>boost::begin(x) == boost::end(x)</code><br>
<td> constant time <br>
</td>
</tr>
<tr>
<a name="distance"></a>
<td><code>distance(x)</code></td>
<td><code>range_difference&lt;X&gt;::type</code></td>
<td>
<code>
std::distance(boost::begin(x),boost::end(x))
</code>
</td>
<td>-</td>
</tr>
<tr>
<a name="size"></a>
<td><code>size(x)</code></td>
<td><code>range_difference&lt;X&gt;::type</code></td>
<td><code> boost::end(x) - boost::begin(x)</code>
<td> constant time </td>
</tr>
<tr>
<a name="rbegin"></a>
<td><code>rbegin(x)</code></td>
<td><code>range_reverse_iterator&lt;X&gt;::type</code></td>
<td><code>range_reverse_iterator&lt;X&gt;::type( boost::end(x) )</code>
<br>
<td>constant time
</td>
</tr>
<tr>
<a name="rend"></a>
<td><code>rend(x)</code></td>
<td><code>range_reverse_iterator&lt;X&gt;::type</code></td>
<td><code>range_reverse_iterator&lt;X&gt;::type( boost::begin(x) )</code>
<td>constant time</td>
</tr>
<tr>
<a name="const_begin"></a>
<td><code>const_begin(x)</code></td>
<td><code>range_iterator&lt;const X&gt;::type</code></td>
<td><code>range_iterator&lt;const X&gt;::type( boost::begin(x) )</code>
<br>
<td>constant time
</td>
</tr>
<tr>
<a name="const_end"></a>
<td><code>const_end(x)</code></td>
<td><code>range_iterator&lt;const X&gt;::type</code></td>
<td><code>range_iterator&lt;const X&gt;::type( boost::end(x) )</code>
<td>constant time</td>
</tr>
<tr>
<a name="const_rbegin"></a>
<td><code>const_rbegin(x)</code></td>
<td><code>range_reverse_iterator&lt;const X&gt;::type</code></td>
<td><code>range_reverse_iterator&lt;const X&gt;::type( boost::rbegin(x) )</code>
<br>
<td>constant time
</td>
</tr>
<tr>
<a name="const_rend"></a>
<td><code>const_rend(x)</code></td>
<td><code>range_reverse_iterator&lt;const X&gt;::type</code></td>
<td><code>range_reverse_iterator&lt;const X&gt;::type( boost::rend(x) )</code>
<td>constant time</td>
</tr>
<tr>
<a name="as_literal"></a>
<td><code>as_literal(x)</code></td>
<td><code>iterator_range&lt;U></code> where <code>U</code> is
<code>Char*</code> if <code>x</code> is a pointer to a
string and <code>U</code> is
<code>range_iterator&lt;X>::type</code> otherwise
</td>
<td>
<code>[a,a+sz-1)</code> if <code>a</code> is an array of size <code>sz</code><br>
<code>[s,s + std::char_traits&lt;X&gt;::length(s))</code> if <code>s</code> is a <code>Char*</code>
<br>
<code>[boost::begin(x),boost::end(x))</code> otherwise
</td>
<td>linear time for pointers to a string, constant time
otherwise</td>
</tr>
<tr>
<a name="as_array"></a>
<td><code>as_array(x)</code></td>
<td><code>iterator_range&lt;X></code> </td>
<td>
<code>[boost::begin(x),boost::end(x))</code>
</td>
<td>constant time otherwise</td>
</tr>
</table>
</p>
<p>
The special <code>const_</code>-named functions are useful when you
want to document clearly that your code is read-only.
</p>
<p>
<code>as_literal()</code> can be used <i>internally</i> in string
algorithm librararies such that arrays of characters are
handled correctly.
</p>
<p>
<code>as_array()</code> can be used with string algorithm libraries to make it clear that arrays of characters are handled like an array and not like a string.
</p>
<p>Notice that the above functions should always be called with
qualification (<code>boost::</code>) to prevent <i>unintended</i>
Argument Dependent Lookup (ADL).
</p>
<hr>
<a name="minimal_interface"></a>
<h3>Extending the library</h3>
<ul>
<li><a href="#method1">Method 1: provide member functions and nested types</a></li>
<li><a href="#method2">Method 2: provide free-standing functions and specialize metafunctions</a></li>
</ul>
<!--<b>Warning:</b><i> If possible, then prefer method 1 if you want to be absolutely sure your code is forward compatible.
</i>-->
<a name="method1"></a>
<h4>Method 1: provide member functions and nested types</h4>
<p>
This procedure assumes that you have control over the types that should be made
conformant to a Range concept. If not, see <a href="#method2">method 2</a>.
</p>
<p>
The primary templates in this library are implemented such that standard
containers will work automatically and so will <code>boost::<a href="../../array/index.html">array</a></code>.
Below is given an overview of which member functions and member types a class
must specify to be useable as a certain Range concept.
</p>
<p>
<table cellpadding="5" border="1">
<tr>
<th>
Member function</th>
<th>
Related concept</th>
<tr>
<td><code>begin()</code></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a></td>
</tr>
<tr>
<td><code>end()</code>
</td>
<td><a href="range.html#single_pass_range">Single Pass Range</a></td>
</tr>
</table>
</p>
<p>
Notice that <code>rbegin()</code> and <code>rend()</code> member functions are
not needed even though the container can support bidirectional iteration.
</p>
<p>
The required member types are:
</p>
<p>
<table cellpadding="5" border="1">
<tr>
<th>
Member type</th>
<th>
Related concept</th>
<tr>
<tr>
<td><code>iterator</code></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a></td>
</tr>
<tr>
<td><code>const_iterator</code></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a></td>
</tr>
</table>
</p>
<p>
Again one should notice that member types <code>reverse_iterator</code> and <code>const_reverse_iterator</code>
are not needed.
</p>
<a name="method2"></a>
<h4>Method 2: provide free-standing functions and specialize metafunctions</h4>
<p>
This procedure assumes that you cannot (or do not wish to) change the types that should be made
conformant to a Range concept. If this is not true, see <a href="#method1">method 1</a>.
</p>
<p>
The primary templates in this library are implemented such that
certain functions are found via argument-dependent-lookup (ADL).
Below is given an overview of which free-standing functions a class
must specify to be useable as a certain Range concept.
Let <code>x</code> be a variable (<code>const</code> or mutable)
of the class in question.
</p>
<p>
<table cellpadding="5" border="1" ID="Table1">
<tr>
<th>
Function</th>
<th>
Related concept</th>
<tr>
<td><code>range_begin(x)</code></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a></td>
</tr>
<tr>
<td><code>range_end(x)</code>
</td>
<td><a href="range.html#single_pass_range">Single Pass Range</a></td>
</tr>
</table>
</p>
<p><code>range_begin()</code> and <code>range_end()</code> must be
overloaded for both <code>const</code> and mutable reference arguments.
</p>
<p>
You must also specialize two metafunctions for your type <code>X</code>:
</p>
<p>
<table cellpadding="5" border="1" ID="Table2">
<tr>
<th>
Metafunction</th>
<th>
Related concept</th>
<tr>
<td><code>boost::range_mutable_iterator</code></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a></td>
</tr>
<tr>
<td><code>boost::range_const_iterator</code></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a></td>
</tr>
</table>
</p>
<p>
A complete example is given here:
</p>
<blockquote>
<pre>
<span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>boost</span><span class=special>/</span><span class=identifier>range</span><span class=special>.</span><span class=identifier>hpp</span><span class=special>&gt;</span>
<span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>iterator</span><span class=special>&gt;</span> <span class=comment>// for std::iterator_traits, std::distance()</span>
<span class=keyword>namespace</span> <span class=identifier>Foo</span>
<span class=special>{</span>
<span class=comment>//
// Our sample UDT. A 'Pair'
// will work as a range when the stored
// elements are iterators.
//</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=keyword>struct</span> <span class=identifier>Pair</span>
<span class=special>{</span>
<span class=identifier>T</span> <span class=identifier>first</span><span class=special>,</span> <span class=identifier>last</span><span class=special>;</span>
<span class=special>};</span>
<span class=special>}</span> <span class=comment>// namespace 'Foo'</span>
<span class=keyword>namespace</span> <span class=identifier>boost</span>
<span class=special>{</span>
<span class=comment>//
// Specialize metafunctions. We must include the range.hpp header.
// We must open the 'boost' namespace.
//</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=keyword>struct</span> <span class=identifier>range_mutable_iterator</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;</span> <span class=special>&gt;</span>
<span class=special>{</span>
<span class=keyword>typedef</span> <span class=identifier>T</span> <span class=identifier>type</span><span class=special>;</span>
<span class=special>};</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=keyword>struct</span> <span class=identifier>range_const_iterator</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;</span> <span class=special>&gt;</span>
<span class=special>{</span>
<span class=comment>//
// Remark: this is defined similar to 'range_mutable_iterator'
// because the 'Pair' type does not distinguish
// between an iterator and a const_iterator.
//</span>
<span class=keyword>typedef</span> <span class=identifier>T</span> <span class=identifier>type</span><span class=special>;</span>
<span class=special>};</span>
<span class=special>}</span> <span class=comment>// namespace 'boost'</span>
<span class=keyword>namespace</span> <span class=identifier>Foo</span>
<span class=special>{</span>
<span class=comment>//
// The required functions. These should be defined in
// the same namespace as 'Pair', in this case
// in namespace 'Foo'.
//</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=keyword>inline</span> <span class=identifier>T</span> <span class=identifier>range_begin</span><span class=special>(</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
<span class=special>{</span>
<span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>first</span><span class=special>;</span>
<span class=special>}</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=keyword>inline</span> <span class=identifier>T</span> <span class=identifier>range_begin</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
<span class=special>{</span>
<span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>first</span><span class=special>;</span>
<span class=special>}</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=keyword>inline</span> <span class=identifier>T</span> <span class=identifier>range_end</span><span class=special>(</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
<span class=special>{</span>
<span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>last</span><span class=special>;</span>
<span class=special>}</span>
<span class=keyword>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
<span class=keyword>inline</span> <span class=identifier>T</span> <span class=identifier>range_end</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
<span class=special>{</span>
<span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>last</span><span class=special>;</span>
<span class=special>}</span>
<span class=special>}</span> <span class=comment>// namespace 'Foo'</span>
<span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>vector</span><span class=special>&gt;</span>
<span class=keyword>int</span> <span class=identifier>main</span><span class=special>()</span>
<span class=special>{</span>
<span class=keyword>typedef</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;::</span><span class=identifier>iterator</span> <span class=identifier>iter</span><span class=special>;</span>
<span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;</span> <span class=identifier>vec</span><span class=special>;</span>
<span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;</span> <span class=identifier>pair</span> <span class=special>=</span> <span class=special>{</span> <span class=identifier>vec</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span> <span class=identifier>vec</span><span class=special>.</span><span class=identifier>end</span><span class=special>()</span> <span class=special>};</span>
<span class=keyword>const</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;&amp;</span> <span class=identifier>cpair</span> <span class=special>=</span> <span class=identifier>pair</span><span class=special>;</span>
<span class=comment>//
// Notice that we call 'begin' etc with qualification.
//</span>
<span class=identifier>iter</span> <span class=identifier>i</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>(</span> <span class=identifier>pair</span> <span class=special>);</span>
<span class=identifier>iter</span> <span class=identifier>e</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>(</span> <span class=identifier>pair</span> <span class=special>);</span>
<span class=identifier>i</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>(</span> <span class=identifier>cpair</span> <span class=special>);</span>
<span class=identifier>e</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>(</span> <span class=identifier>cpair</span> <span class=special>);</span>
<span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_difference</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;</span> <span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>s</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>size</span><span class=special>(</span> <span class=identifier>pair</span> <span class=special>);</span>
<span class=identifier>s</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>size</span><span class=special>(</span> <span class=identifier>cpair</span> <span class=special>);</span>
<span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span> <span class=identifier>const Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;</span> <span class=special>&gt;::</span><span class=identifier>type</span>
<span class=identifier>ri</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>rbegin</span><span class=special>(</span> <span class=identifier>cpair</span> <span class=special>),</span>
<span class=identifier>re</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>rend</span><span class=special>(</span> <span class=identifier>cpair</span> <span class=special>);</span>
<span class=special>}</span>
</pre>
</blockquote>
<hr>
<p>
&copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
</p>
<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">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
</body>
</html>

File diff suppressed because it is too large Load Diff

View File

@ -1,255 +0,0 @@
[/
Copyright 2010 Neil Groves
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
/]
[section:concepts Range Concepts]
[section Overview]
A Range is a [*/concept/] similar to the STL [@http://www.sgi.com/Technology/STL/Container.html Container] concept. A Range provides iterators for accessing a half-open range `[first,one_past_last)` of elements and provides information about the number of elements in the Range. However, a Range has fewer requirements than a Container.
The motivation for the Range concept is that there are many useful Container-like types that do not meet the full requirements of Container, and many algorithms that can be written with this reduced set of requirements. In particular, a Range does not necessarily
* own the elements that can be accessed through it,
* have copy semantics,
Because of the second requirement, a Range object must be passed by (const or non-const) reference in generic code.
The operations that can be performed on a Range is dependent on the [@boost:/libs/iterator/doc/new-iter-concepts.html#iterator-traversal-concepts-lib-iterator-traversal traversal category] of the underlying iterator type. Therefore the range concepts are named to reflect which traversal category its iterators support. See also terminology and style guidelines. for more information about naming of ranges.
The concepts described below specifies associated types as [@boost:/libs/mpl/doc/refmanual/metafunction.html metafunctions] and all functions as free-standing functions to allow for a layer of indirection.
[endsect]
[section Single Pass Range]
[heading Notation]
[table
[]
[[`X`] [A type that is a model of __single_pass_range__.]]
[[`a`] [Object of type X.]]
]
[heading Description]
A range `X` where `boost::range_iterator<X>::type` is a model of __single_pass_iterator__.
[heading Associated types]
[table
[]
[[Iterator type ] [`boost::range_iterator<X>::type` ] [The type of iterator used to iterate through a Range's elements. The iterator's value type is expected to be the Range's value type. A conversion from the iterator type to the `const` iterator type must exist.]]
[[Const iterator type] [`boost::range_iterator<const X>::type`] [A type of iterator that may be used to examine, but not to modify, a Range's elements.]]
]
[heading Valid expressions]
The following expressions must be valid.
[table
[[Name ] [Expression ] [Return type ]]
[[Beginning of range] [`boost::begin(a)`] [`boost::range_iterator<X>::type` if `a` is mutable, `boost::range_iterator<const X>::type` otherwise]]
[[End of range ] [`boost::end(a)` ] [`boost::range_iterator<X>::type` if `a` is mutable, `boost::range_iterator<const X>::type` otherwise]]
]
[heading Expression semantics]
[table
[[Expression ] [Semantics ] [Postcondition]]
[[`boost::begin(a)`] [Returns an iterator pointing to the first element in the Range. ] [`boost::begin(a)` is either dereferenceable or past-the-end. It is past-the-end if and only if `boost::distance(a) == 0`.]]
[[`boost::end(a)` ] [Returns an iterator pointing one past the last element in the Range. ] [`boost::end(a)` is past-the-end.]]
]
[heading Complexity guarantees]
`boost::end(a)` is at most amortized linear time, `boost::begin(a)` is amortized constant time. For most practical purposes, one can expect both to be amortized constant time.
[heading Invariants]
[table
[]
[[Valid range ] [For any Range `a`, `[boost::begin(a),boost::end(a))` is a valid range, that is, `boost::end(a)` is reachable from `boost::begin(a)` in a finite number of increments.]]
[[Completeness] [An algorithm that iterates through the range `[boost::begin(a),boost::end(a))` will pass through every element of `a`.]]
]
[heading See also]
__extending_for_udts__
__implementation_of_metafunctions__
__implementation_of_functions__
__container__
[endsect]
[section Forward Range]
[heading Notation]
[table
[]
[[`X`] [A type that is a model of __forward_range__.]]
[[`a`] [Object of type X.]]
]
[heading Description]
A range `X` where `boost::range_iterator<X>::type` is a model of __forward_traversal_iterator__.
[heading Refinement of]
__single_pass_range__
[heading Associated types]
[table
[]
[[Distance type] [`boost::range_difference<X>::type`] [A signed integral type used to represent the distance between two of the Range's iterators. This type must be the same as the iterator's distance type.]]
[[Size type ] [`boost::range_size<X>::type` ] [An unsigned integral type that can represent any nonnegative value of the Range's distance type.]]
]
[heading See also]
__implementation_of_metafunctions__
__implementation_of_functions__
[endsect]
[section Bidirectional Range]
[heading Notation]
[table
[]
[[`X`] [A type that is a model of __bidirectional_range__.]]
[[`a`] [Object of type X.]]
]
[heading Description]
This concept provides access to iterators that traverse in both directions (forward and reverse). The `boost::range_iterator<X>::type` iterator must meet all of the requirements of __bidirectional_traversal_iterator__.
[heading Refinement of]
__forward_range__
[heading Associated types]
[table
[]
[[Reverse Iterator type ] [`boost::range_reverse_iterator<X>::type` ] [The type of iterator used to iterate through a Range's elements in reverse order. The iterator's value type is expected to be the Range's value type. A conversion from the reverse iterator type to the const reverse iterator type must exist.]]
[[Const reverse iterator type] [`boost::range_reverse_iterator<const X>::type`] [A type of reverse iterator that may be used to examine, but not to modify, a Range's elements.]]
]
[heading Valid expressions]
[table
[[Name ] [Expression ] [Return type] [Semantics]]
[[Beginning of range] [`boost::rbegin(a)`] [`boost::range_reverse_iterator<X>::type` if `a` is mutable `boost::range_reverse_iterator<const X>::type` otherwise.] [Equivalent to `boost::range_reverse_iterator<X>::type(boost::end(a))`.]]
[[End of range ] [`boost::rend(a)` ] [`boost::range_reverse_iterator<X>::type` if `a` is mutable, `boost::range_reverse_iterator<const X>::type` otherwise.] [Equivalent to `boost::range_reverse_iterator<X>::type(boost::begin(a))`.]]
]
[heading Complexity guarantees]
`boost::rbegin(a)` has the same complexity as `boost::end(a)` and `boost::rend(a)` has the same complexity as `boost::begin(a)` from __forward_range__.
[heading Invariants]
[table
[]
[[Valid reverse range] [For any Bidirectional Range a, `[boost::rbegin(a),boost::rend(a))` is a valid range, that is, `boost::rend(a)` is reachable from `boost::rbegin(a)` in a finite number of increments.]]
[[Completeness ] [An algorithm that iterates through the range `[boost::rbegin(a),boost::rend(a))` will pass through every element of `a`.]]
]
[heading See also]
__implementation_of_metafunctions__
__implementation_of_functions__
[endsect]
[section Random Access Range]
[heading Description]
A range `X` where `boost::range_iterator<X>::type` is a model of __random_access_traversal_iterator__.
[heading Refinement of]
__bidirectional_range__
[heading Valid expressions]
[table
[[Name ] [Expression ] [Return type ]]
[[Size of range] [`boost::size(a)`] [`boost::range_size<X>::type`]]
]
[heading Expression semantics]
[table
[[Expression ] [Semantics] [Postcondition]]
[[`boost::size(a)`] [Returns the size of the Range, that is, its number of elements. Note `boost::size(a) == 0u` is equivalent to `boost::empty(a)`.] [`boost::size(a) >= 0`]]
]
[heading Complexity guarantees]
`boost::size(a)` completes in amortized constant time.
[heading Invariants]
[table
[]
[[Range size] [`boost::size(a)` is equal to the `boost::end(a)` - `boost::begin(a)`.]]
]
[endsect]
[section Concept Checking]
Each of the range concepts has a corresponding concept checking class in the file [@boost:/boost/range/concepts.hpp `<boost/range/concepts.hpp>`]. These classes may be used in conjunction with the __concept_check__ to ensure that the type of a template parameter is compatible with a range concept. If not, a meaningful compile time error is generated. Checks are provided for the range concepts related to iterator traversal categories. For example, the following line checks that the type `T` models the __forward_range__ concept.
``
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<T> ));
``
An additional concept check is required for the value access property of the range based on the range's iterator type. For example to check for a ForwardReadableRange, the following code is required.
``
BOOST_CONCEPT_ASSERT(( ForwardRangeConcept<T> ));
BOOST_CONCEPT_ASSERT(( ReadableIteratorConcept<typename range_iterator<T>::type> ));
``
The following range concept checking classes are provided.
* Class SinglePassRangeConcept checks for __single_pass_range__
* Class ForwardRangeConcept checks for __forward_range__
* Class BidirectionalRangeConcept checks for __bidirectional_range__
* Class RandomAccessRangeConcept checks for __random_access_range__
[heading See also]
[link range.style_guide Range Terminology and style guidelines]
__iterator_concepts__
__concept_check__
[endsect]
[endsect]

72
doc/examples.html Normal file
View File

@ -0,0 +1,72 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Boost.Range Examples </title>
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body>
<table border="0" >
<tr>
<td ><img src="../../../boost.png" border="0" ></td>
<td ><h1 align="center">Boost.Range </h1></td>
</tr>
</table>
<h2 >Examples</h2><a name="Examples" ></a>
<p >
Some examples are given in the accompanying test files:
</p>
<ul >
<li >
<a href="../test/string.cpp" target="_self" ><code >string.cpp</code></a>
</li>
shows how to implement a container version of <code >std::find()</code> that
works with <code >char[],wchar_t[],char*,wchar_t*.</code>
<li >
<a href="../test/algorithm_example.cpp" target="_self" ><code >algorithm_example.cpp</code></a>
</li>
shows the replace example from the introduction.
<li> <a href="../test/iterator_range.cpp">iterator_range.cpp</a>
<li> <a href="../test/sub_range.cpp">sub_range.cpp</a>
<li> <a href="../test/iterator_pair.cpp">iterator_pair.cpp</a>
<li> <a href="../test/reversible_range.cpp">reversible_range.cpp</a>
<li> <a href="../test/std_container.cpp">std_container.cpp</a>
<li> <a href="../test/array.cpp">array.cpp</a>
</ul>
<hr>
<p>
&copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
</p>
<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">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
</body>
</html>

View File

@ -1,28 +0,0 @@
[/
Copyright 2010 Neil Groves
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
/]
[section:examples Examples]
Some examples are given in the accompanying test files:
* [@http://www.boost.org/libs/range/test/string.cpp string.cpp] shows how to implement a container version of `std::find()` that works with `char[]`,`wchar_t[]`,`char*`,`wchar_t*`.
* [@http://www.boost.org/libs/range/test/algorithm_example.cpp algorithm_example.cpp] shows the replace example from the introduction.
* [@http://www.boost.org/libs/range/test/iterator_range.cpp iterator_range.cpp]
* [@http://www.boost.org/libs/range/test/sub_range.cpp sub_range.cpp]
* [@http://www.boost.org/libs/range/test/iterator_pair.cpp iterator_pair.cpp]
* [@http://www.boost.org/libs/range/test/reversible_range.cpp reversible_range.cpp]
* [@http://www.boost.org/libs/range/test/std_container.cpp std_container.cpp]
* [@http://www.boost.org/libs/range/test/array.cpp array.cpp]
[endsect]

145
doc/faq.html Normal file
View File

@ -0,0 +1,145 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Boost.Range FAQ </title>
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body>
<table border="0" >
<tr>
<td ><img src="../../../boost.png" border="0" ></td>
<td ><h1 align="center">Boost.Range</h1></td>
</tr>
</table>
<p>
<h2 >FAQ</h2> <a name="FAQ" ></a>
<ol >
<li >
<i>Why is there no difference between <code >range_iterator&lt;C&gt;::type</code>
and <code >range_const_iterator&lt;C&gt;::type</code> for <code>std::pair&lt;iterator, iterator&gt;</code></i>.
</li>
<p >
In general it is not possible nor desirable to find a corresponding <code >const_iterator</code>.
When it is possible to come up with one, the client might choose to construct a <code >std::pair&lt;const_iterator,const_iterator&gt;</code>
object.
</p>
<p>
Note that an <a href="utility_class.html#iter_range">iterator_range</a>
is somewhat more convenient than a <code>pair</code> and that a <a
href="utility_class.html#sub_range"><code>sub_range</code></a> does
propagate const-ness. </p>
<li >
<i>Why is there not supplied more types or more functions?</i>
<p >
The library has been kept small because its current interface will
serve most
purposes. If and when a genuine need arises for more functionality, it can be
implemented.
</p>
</li>
<li >
<i>How should I implement generic algorithms for ranges?</i>
<p >
One should always start with a generic algorithm that takes two iterators (or
more) as input. Then use Boost.Range to build handier versions on top of the
iterator based algorithm. Please notice that once the range version of the
algorithm is done, it makes sense <i>not</i> to expose the iterator version in
the public interface.
</p>
</li>
<li>
<i>Why is there no Incrementable Range concept?</i>
<p>
Even though we speak of incrementable iterators, it would not make
much sense for ranges; for example, we cannot determine the size and
emptiness of a range since we cannot even compare
its iterators.
</p>
<p>
Note also that incrementable iterators are derived from output
iterators and so there exist no output range.
</p>
</li>
<!--
<li>
<i>Should I use qualified syntax, for example
<blockquote><pre>
<span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>r </span><span class=special>); </span>
</pre></blockquote>
instead of
<blockquote>
<pre><span class=keyword>using </span><span class=keyword>namespace </span><span class=identifier>boost</span><span class=special>;</span>
<span class=identifier>begin</span><span class=special>( </span><span class=identifier>r </span><span class=special>)</span></pre></blockquote>
when calling functions in this library? If so, can I still rely on argument
dependent lookup (ADL) to kick in?</i>
<p>
The answer to the first question is that "it's up to you". The
answer to the second question is Yes. Normally qualified syntax
disables ADL, but the functions are implemented in a special
manner that preserves ADL properties. The trick was explained by
Daniel Frey on comp.lang.std.c++ in the thread "Whence Swap" and
it is best explained by some code: <blockquote>
<pre>
<span class=keyword>namespace </span><span class=identifier>boost</span>
<span class=special>{
</span><span class=keyword>namespace </span><span class=identifier>range_detail
</span><span class=special>{
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;:</span><span class=identifier>type </span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>)
</span><span class=special>{ </span><span class=comment>/* normal implementation */ </span><span class=special>}
</span><span class=special>}
</span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
</span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>)
</span><span class=special>{
</span><span class=comment>//
// Create ADL hook
//
</span><span class=keyword>using </span><span class=identifier>range_detail</span><span class=special>::</span><span class=identifier>begin</span><span class=special>;
</span><span class=keyword>return </span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>r </span><span class=special>);
</span><span class=special>}</span>
<span class=special>} </span>
</pre>
</blockquote>
Cool indeed!
</p>
-->
</ol>
<hr>
<p>
&copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
</p>
<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">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
</body>
</html>

View File

@ -1,30 +0,0 @@
[/
Copyright 2010 Neil Groves
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
/]
[section:faq FAQ]
1. ['[*Why is there no difference between `range_iterator<C>::type` and `range_const_iterator<C>::type` for `std::pair<iterator, iterator>`?]]
[:In general it is not possible nor desirable to find a corresponding `const_iterator`. When it is possible to come up with one, the client might choose to construct a `std::pair<const_iterator,const_iterator>` object.]
[:Note that an __iterator_range__ is somewhat more convenient than a `pair` and that a __sub_range__ does propagate const-ness.]
2. ['[*Why is there not supplied more types or more functions?]]
[:The library has been kept small because its current interface will serve most purposes. If and when a genuine need arises for more functionality, it can be implemented.]
3. ['[*How should I implement generic algorithms for ranges?]]
[:One should always start with a generic algorithm that takes two iterators (or more) as input. Then use Boost.Range to build handier versions on top of the iterator based algorithm. Please notice that once the range version of the algorithm is done, it makes sense not to expose the iterator version in the public interface.]
4. ['[*Why is there no Incrementable Range concept?]]
[:Even though we speak of incrementable iterators, it would not make much sense for ranges; for example, we cannot determine the size and emptiness of a range since we cannot even compare its iterators.]
[:Note also that incrementable iterators are derived from output iterators and so there exist no output range.]
[endsect]

202
doc/headers.html Normal file
View File

@ -0,0 +1,202 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Boost.Range Headers </title>
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body>
<table border="0" >
<tr>
<td ><img src="../../../boost.png" border="0" ></td>
<td ><h1 align="center">Boost.Range</h1></td>
</tr>
</table>
<p>
<h2 >Library headers</h2><a name="Library headers" ></a>
<table cellpadding="5" border="1" >
<tr >
<th >Header</th>
<th >Includes</th>
<th>Related concept </th>
</tr>
<tr >
<td ><code >&lt;boost/range.hpp&gt;</code></td>
<td >everything</td>
<td>- </td>
</tr>
<tr >
<td ><code >&lt;boost/range/metafunctions.hpp&gt;</code></td>
<td >every metafunction</td>
<td>- </td>
</tr>
<tr >
<td ><code >&lt;boost/range/functions.hpp&gt;</code></td>
<td >every function</td>
<td>- </td>
</tr>
<tr >
<td ><code >&lt;boost/range/value_type.hpp&gt;</code></td>
<td ><a href="boost_range.html#range_value" >range_value</a></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a></td>
</tr>
<tr >
<td ><code >&lt;boost/range/iterator.hpp&gt;</code></td>
<td ><a href="boost_range.html#range_iterator"
>range_iterator</a></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/mutable_iterator.hpp&gt;</code></td>
<td ><a href="boost_range.html#range_mutable_iterator"
>range_mutable_iterator</a></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/const_iterator.hpp&gt;</code></td>
<td ><a href="boost_range.html#range_const_iterator"
>range_const_iterator</a></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/difference_type.hpp&gt;</code></td>
<td ><a href="boost_range.html#range_difference"
>range_difference</a></td>
<td><a href="range.html#forward_range">Forward Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/pointer.hpp&gt;</code></td>
<td ><a href="boost_range.html#range_pointer"
>range_pointer</a></td>
<td>- </td>
</tr>
<tr >
<td ><code >&lt;boost/range/category.hpp&gt;</code></td>
<td ><a href="boost_range.html#range_category"
>range_category</a></td>
<td>- </td>
</tr>
<tr >
<td ><code >&lt;boost/range/reverse_iterator.hpp&gt;</code></td>
<td ><a href="boost_range.html#range_reverse_iterator" >range_reverse_iterator</a></td>
<td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/begin.hpp&gt;</code></td>
<td >
<a href="boost_range.html#begin" >begin</a> and
<a href="boost_range.html#const_begin" >const_begin</a>
</td>
<td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/end.hpp&gt;</code></td>
<td >
<a href="boost_range.html#end" >end</a> and
<a href="boost_range.html#const_end" >const_end</a>
</td>
<td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/empty.hpp&gt;</code></td>
<td ><a href="boost_range.html#empty" >empty</a></td>
<td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/distance.hpp&gt;</code></td>
<td ><a href="boost_range.html#distance" >distance</a></td>
<td><a href="range.html#forward_range">Forward Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/size.hpp&gt;</code></td>
<td ><a href="boost_range.html#size" >size</a></td>
<td><a href="range.html#random_access_range">Random Access Range</a>
</td>
</tr>
<tr >
<td ><code >&lt;boost/range/rbegin.hpp&gt;</code></td>
<td >
<a href="boost_range.html#rbegin" >rbegin</a> and
<a href="boost_range.html#const_rbegin" >const_rbegin</a>
</td>
<td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/rend.hpp&gt;</code></td>
<td >
<a href="boost_range.html#rend" >rend</a> and
<a href="boost_range.html#const_rend" >const_rend</a>
</td>
<td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
</tr>
<tr >
<td ><code >&lt;boost/range/as_array.hpp&gt;</code></td>
<td >
<a href="boost_range.html#as_array" >as_array</a>
</td>
<td>-</td>
</tr>
<tr >
<td ><code >&lt;boost/range/as_literal.hpp&gt;</code></td>
<td >
<a href="boost_range.html#as_literal" >as_literal</a>
</td>
<td>-</td>
</tr>
<tr >
<td ><code >&lt;boost/range/iterator_range.hpp&gt;</code></td>
<td ><a href="utility_class.html#iter_range"
>iterator_range</a></td>
<td>- </td>
</tr>
<tr >
<td ><code >&lt;boost/range/sub_range.hpp&gt;</code></td>
<td ><a href="utility_class.html#sub_range" >sub_range</a></td>
<td>- </td>
</tr>
<tr >
<td ><code >&lt;boost/range/concepts.hpp&gt;</code></td>
<td ><a href="range.html#concept_checking" >concept checks</a></td>
<td>- </td>
</tr>
</table>
<br
</p>
<hr>
<p>
&copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
</p>
<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">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
</body>
</html>

View File

@ -1,143 +0,0 @@
[/
Copyright 2010 Neil Groves
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
/]
[section:headers Library Headers]
[section:general General]
[table
[[Header ] [Includes ] [Related Concept ]]
[[`<boost/range.hpp>` ] [everything from Boost.Range version 1 (Boost versions 1.42 and below). Includes the core range functions and metafunctinos, but excludes Range Adaptors and Range Algorithms. ] [- ]]
[[`<boost/range/metafunctions.hpp>` ] [every metafunction ] [- ]]
[[`<boost/range/functions.hpp>` ] [every function ] [- ]]
[[`<boost/range/value_type.hpp>` ] [__range_value__ ] [__single_pass_range__ ]]
[[`<boost/range/iterator.hpp>` ] [__range_iterator__ ] [__single_pass_range__ ]]
[[`<boost/range/difference_type.hpp>` ] [__range_difference__ ] [__forward_range__ ]]
[[`<boost/range/pointer.hpp>` ] [__range_pointer__ ] [-]]
[[`<boost/range/category.hpp>` ] [__range_category__ ] [-]]
[[`<boost/range/reverse_iterator.hpp>`] [__range_reverse_iterator__ ] [__bidirectional_range__ ]]
[[`<boost/range/begin.hpp>` ] [__begin__ and __const_begin__ ] [__single_pass_range__ ]]
[[`<boost/range/end.hpp>` ] [__end__ and __const_end__ ] [__single_pass_range__ ]]
[[`<boost/range/empty.hpp>` ] [__empty__ ] [__single_pass_range__ ]]
[[`<boost/range/distance.hpp>` ] [__distance__ ] [__forward_range__ ]]
[[`<boost/range/size.hpp>` ] [__size__ ] [__random_access_range__ ]]
[[`<boost/range/rbegin.hpp>` ] [__rbegin__ and __const_rbegin__] [__bidirectional_range__ ]]
[[`<boost/range/rend.hpp>` ] [__rend__ and __const_rend__ ] [__bidirectional_range__ ]]
[[`<boost/range/as_array.hpp>` ] [__as_array__ ] [- ]]
[[`<boost/range/as_literal.hpp>` ] [__as_literal__ ] [- ]]
[[`<boost/range/iterator_range.hpp>` ] [__iterator_range__ ] [- ]]
[[`<boost/range/sub_range.hpp>` ] [__sub_range__ ] [- ]]
[[`<boost/range/concepts.hpp>` ] [__range_concepts__ ] [- ]]
[[`<boost/range/adaptors.hpp>` ] [every range adaptor ] [- ]]
[[`<boost/range/algorithm.hpp>` ] [every range equivalent of an STL algorithm ] [- ]]
[[`<boost/range/algorithm_ext.hpp>` ] [every range algorithm that is an extension of the STL algorithms ] [- ]]
[[`<boost/range/counting_range.hpp>` ] [ __counting_range__ ] [-]]
[[`<boost/range/istream_range.hpp>` ] [ __istream_range__ ] [-]]
[[`<boost/range/irange.hpp>` ] [ __irange__ ] [-]]
[[`<boost/range/join.hpp>` ] [ __join__ ] [-]]
]
[endsect]
[section:adaptors Adaptors]
[table
[[Header ][Includes ]]
[[`<boost/range/adaptor/adjacent_filtered.hpp>`] [__range_adaptors_adjacent_filtered__ ]]
[[`<boost/range/adaptor/copied.hpp>`] [__range_adaptors_copied__]]
[[`<boost/range/adaptor/filtered.hpp>`] [__range_adaptors_filtered__]]
[[`<boost/range/adaptor/indexed.hpp>`] [__range_adaptors_indexed__]]
[[`<boost/range/adaptor/indirected.hpp.`] [__range_adaptors_indirected__]]
[[`<boost/range/adaptor/map.hpp>`] [__range_adaptors_map_keys__ __range_adaptors_map_values__]]
[[`<boost/range/adaptor/replaced.hpp>`] [__range_adaptors_replaced__]]
[[`<boost/range/adaptor/replaced_if.hpp>`] [__range_adaptors_replaced_if__]]
[[`<boost/range/adaptor/reversed.hpp>`] [__range_adaptors_reversed__]]
[[`<boost/range/adaptor/sliced.hpp>`] [__range_adaptors_sliced__]]
[[`<boost/range/adaptor/strided.hpp>`] [__range_adaptors_strided__]]
[[`<boost/range/adaptor/tokenized.hpp>`] [__range_adaptors_tokenized__]]
[[`<boost/range/adaptor/transformed.hpp>`] [__range_adaptors_transformed__]]
[[`<boost/range/adaptor/uniqued.hpp>`] [__range_adaptors_uniqued__]]
]
[endsect]
[section:algorithm Algorithm]
[table
[[Header ][Includes ]]
[[`<boost/range/algorithm/adjacent_find.hpp>`] [__range_algorithms_adjacent_find__]]
[[`<boost/range/algorithm/binary_search.hpp>`] [__range_algorithms_binary_search__]]
[[`<boost/range/algorithm/copy.hpp>`] [__range_algorithms_copy__]]
[[`<boost/range/algorithm/copy_backward.hpp>`] [__range_algorithms_copy_backward__]]
[[`<boost/range/algorithm/count.hpp>`] [__range_algorithms_count__]]
[[`<boost/range/algorithm/count_if.hpp>`] [__range_algorithms_count_if__]]
[[`<boost/range/algorithm/equal.hpp>`] [__range_algorithms_equal__]]
[[`<boost/range/algorithm/equal_range.hpp>`] [__range_algorithms_equal_range__]]
[[`<boost/range/algorithm/fill.hpp>`] [__range_algorithms_fill__]]
[[`<boost/range/algorithm/fill_n.hpp>`] [__range_algorithms_fill_n__]]
[[`<boost/range/algorithm/find.hpp>`] [__range_algorithms_find__]]
[[`<boost/range/algorithm/find_end.hpp>`] [__range_algorithms_find_end__]]
[[`<boost/range/algorithm/find_first_of.hpp>`] [__range_algorithms_find_first_of__]]
[[`<boost/range/algorithm/find_if.hpp>`] [__range_algorithms_find_if__]]
[[`<boost/range/algorithm/for_each.hpp>`] [__range_algorithms_for_each__]]
[[`<boost/range/algorithm/generate.hpp>`] [__range_algorithms_generate__]]
[[`<boost/range/algorithm/heap_algorithm.hpp>`] [__range_algorithms_push_heap__
__range_algorithms_pop_heap__
__range_algorithms_make_heap__
__range_algorithms_sort_heap__]]
[[`<boost/range/algorithm/inplace_merge.hpp>`] [__range_algorithms_inplace_merge__]]
[[`<boost/range/algorithm/lexicographical_compare.hpp>`] [__range_algorithms_lexicographical_compare__]]
[[`<boost/range/algorithm/lower_bound.hpp>`] [__range_algorithms_lower_bound__]]
[[`<boost/range/algorithm/max_element.hpp>`] [__range_algorithms_max_element__]]
[[`<boost/range/algorithm/merge.hpp>`] [__range_algorithms_merge__]]
[[`<boost/range/algorithm/min_element.hpp>`] [__range_algorithms_min_element__]]
[[`<boost/range/algorithm/mismatch.hpp>`] [__range_algorithms_mismatch__]]
[[`<boost/range/algorithm/nth_element.hpp>`] [__range_algorithms_nth_element__]]
[[`<boost/range/algorithm/partial_sort.hpp>`] [__range_algorithms_partial_sort__]]
[[`<boost/range/algorithm/partition.hpp>`] [__range_algorithms_partition__]]
[[`<boost/range/algorithm/permutation.hpp>`] [__range_algorithms_next_permutation__
__range_algorithms_prev_permutation__]]
[[`<boost/range/algorithm/random_shuffle.hpp>`] [__range_algorithms_random_shuffle__]]
[[`<boost/range/algorithm/remove.hpp>`] [__range_algorithms_remove__]]
[[`<boost/range/algorithm/remove_copy.hpp>`] [__range_algorithms_remove_copy__]]
[[`<boost/range/algorithm/remove_copy_if.hpp>`] [__range_algorithms_remove_copy_if__]]
[[`<boost/range/algorithm/remove_if.hpp>`] [__range_algorithms_remove_if__]]
[[`<boost/range/algorithm/replace.hpp>`] [__range_algorithms_replace__]]
[[`<boost/range/algorithm/replace_copy.hpp>`] [__range_algorithms_replace_copy__]]
[[`<boost/range/algorithm/replace_copy_if.hpp>`] [__range_algorithms_replace_copy_if__]]
[[`<boost/range/algorithm/replace_if.hpp>`] [__range_algorithms_replace_if__]]
[[`<boost/range/algorithm/reverse.hpp>`] [__range_algorithms_reverse__]]
[[`<boost/range/algorithm/reverse_copy.hpp>`] [__range_algorithms_reverse_copy__]]
[[`<boost/range/algorithm/rotate.hpp>`] [__range_algorithms_rotate__]]
[[`<boost/range/algorithm/rotate_copy.hpp>`] [__range_algorithms_rotate_copy__]]
[[`<boost/range/algorithm/search.hpp>`] [__range_algorithms_search__]]
[[`<boost/range/algorithm/search_n.hpp>`] [__range_algorithms_search_n__]]
[[`<boost/range/algorithm/set_algorithm.hpp>`] [__range_algorithms_includes__
__range_algorithms_set_union__
__range_algorithms_set_intersection__
__range_algorithms_set_difference__
__range_algorithms_set_symmetric_difference__]]
[[`<boost/range/algorithm/sort.hpp>`] [__range_algorithms_sort__]]
[[`<boost/range/algorithm/stable_partition.hpp>`] [__range_algorithms_stable_partition__]]
[[`<boost/range/algorithm/swap_ranges.hpp>`] [__range_algorithms_swap_ranges__]]
[[`<boost/range/algorithm/transform.hpp>`] [__range_algorithms_transform__]]
[[`<boost/range/algorithm/unique.hpp>`] [__range_algorithms_unique__]]
[[`<boost/range/algorithm/unique_copy.hpp>`] [__range_algorithms_unique_copy__]]
[[`<boost/range/algorithm/upper_bound.hpp>`] [__range_algorithms_upper_bound__]]
]
[endsect]
[section:algorithm_ext Algorithm Extensions]
[table
[[Header ][Includes ]]
[[`<boost/range/algorithm_ext/copy_n.hpp>`] [__range_algorithm_ext_copy_n__]]
[[`<boost/range/algorithm_ext/erase.hpp>`] [__range_algorithm_ext_erase__]]
[[`<boost/range/algorithm_ext/for_each.hpp>`] [__range_algorithm_ext_for_each__]]
[[`<boost/range/algorithm_ext/insert.hpp>`] [__range_algorithm_ext_insert__]]
[[`<boost/range/algorithm_ext/iota.hpp>`] [__range_algorithm_ext_iota__]]
[[`<boost/range/algorithm_ext/is_sorted.hpp>`] [__range_algorithm_ext_is_sorted__]]
[[`<boost/range/algorithm_ext/overwrite.hpp>`] [__range_algorithm_ext_overwrite__]]
[[`<boost/range/algorithm_ext/push_back.hpp>`] [__range_algorithm_ext_push_back__]]
[[`<boost/range/algorithm_ext/push_front.hpp>`] [__range_algorithm_ext_push_front__]]
]
[endsect]
[endsect]

90
doc/history_ack.html Normal file
View File

@ -0,0 +1,90 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Boost.Range History and Acknowledgement </title>
<link rel="stylesheet" href="style.css" type="text/css">
</head>
<body>
<table border="0" >
<tr>
<td><img src="../../../boost.png" border="0" ></td>
<td><h1 align="center">Boost.Range </h1></td>
</tr>
</table>
<h2 >History and Acknowledgement</h2><a name="History" ></a>
<p >
The library was under way for a long time. Dietmar K<>hl originally intended
to submit an <code >array_traits</code> class template which had most of
the functionality present now, but only for arrays and standard containers.
I believe this was back in 2001 or 2002.
</p>
<p>
Meanwhile work on algorithms for containers in various contexts showed the
need for handling pairs of iterators, and string libraries needed special
treatment of character arrays. In the end it made sense to formalize the
minimal requirements of these similar concepts. And the results are the
Range concepts found in this library. </p>
<p>
The term Range was adopted because of paragraph <code>24.1/7</code> from the
C++ standard: <blockquote>
Most of the library's algorithmic templates that operate on data
structures have interfaces that use ranges. A <i>range</i> is a pair of
iterators that designate the beginning and end of the computation. A
range [i, i) is an empty range; in general, a range [i, j) refers to
the elements in the data structure starting with the one pointed to
by i and up to but not including the one pointed to by j. Range [i,
j) is valid if and only if j is reachable from i. The result of the
application of functions in the library to invalid ranges is
undefined.
</blockquote>
<p>
Special thanks goes to
<ul>
<li> Pavol Droba for help with documentation and implementation
<li> Pavel Vozenilek for help with porting the library
<li> Jonathan Turkanis and John Torjo for help with documentation
<li> Hartmut Kaiser for being review manager
<li> Jonathan Turkanis for porting the lib (as far sa possible) to
vc6 and vc7.
</ul>
</p>
<p>
The concept checks and their documentation was provided by Daniel Walker.
<hr>
<p>
&copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
</p>
<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">www.boost.org/LICENSE_1_0.txt</a>)
</p>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
<br>
</body>
</html>

View File

@ -1,58 +0,0 @@
[/
Copyright 2010 Neil Groves
Distributed under the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
/]
[section:history_ack History and Acknowledgement]
[heading Version 1 - before Boost 1.43]
The library have been under way for a long time. Dietmar Kühl originally intended to submit an `array_traits` class template which had most of the functionality present now, but only for arrays and standard containers.
Meanwhile work on algorithms for containers in various contexts showed the need for handling pairs of iterators, and string libraries needed special treatment of character arrays. In the end it made sense to formalize the minimal requirements of these similar concepts. And the results are the Range concepts found in this library.
The term Range was adopted because of paragraph 24.1/7 from the C++ standard:
Most of the library's algorithmic templates that operate on data structures have interfaces that use ranges. A range is a pair of iterators that designate the beginning and end of the computation. A range [i, i) is an empty range; in general, a range [i, j) refers to the elements in the data structure starting with the one pointed to by i and up to but not including the one pointed to by j. Range [i, j) is valid if and only if j is reachable from i. The result of the application of functions in the library to invalid ranges is undefined.
Special thanks goes to
* Pavol Droba for help with documentation and implementation
* Pavel Vozenilek for help with porting the library
* Jonathan Turkanis and John Torjo for help with documentation
* Hartmut Kaiser for being review manager
* Jonathan Turkanis for porting the lib (as far sa possible) to vc6 and vc7.
The concept checks and their documentation was provided by Daniel Walker.
[heading Version 2 - Boost 1.43 and beyond]
This version introduced Range Adaptors and Range Algorithms. This version 2 is
the result of a merge of all of the RangeEx features into Boost.Range.
There were an enormous number of very significant contributors through all
stages of this library.
Prior to Boost.RangeEx there had been a number of Range library implementations,
these include library implementations by Eric Niebler, Adobe,
Shunsuke Sogame etc. Eric Niebler contributed the Range Adaptor idea which is
arguably the single biggest innovation in this library. Inevitably a great deal
of commonality evolved in each of these libraries, but a considerable amount
of effort was expended to learn from all of the divergent techniques.
The people in the following list all made contributions in the form of reviews,
user feedback, design suggestions, or defect detection:
* Thorsten Ottosen: review management, design advice, documentation feedback
* Eric Niebler: early implementation, and review feedback
* Joel de Guzman: review
* Mathias Gaunard: review
* David Abrahams: implementation advice
* Robert Jones: defect reports, usage feedback
* Sean Parent: contributed experience from the Adobe range library
* Arno Schoedl: implementations, and review
* Rogier van Dalen: review
* Vincente Botet: review, documentation feedback
Regardless of how I write this section it will never truly fairly capture the
gratitude that I feel to all who have contributed. Thank you everyone.
[endsect]

View File

@ -1,153 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Chapter&#160;1.&#160;Range 2.0</title>
<link rel="stylesheet" href="../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="next" href="range/introduction.html" title="Introduction">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../boost.png"></td>
<td align="center"><a href="../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav"><a accesskey="n" href="range/introduction.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
<div class="chapter">
<div class="titlepage"><div>
<div><h2 class="title">
<a name="range"></a>Chapter&#160;1.&#160;Range 2.0</h2></div>
<div><div class="author"><h3 class="author">
<span class="firstname">Thorsten</span> <span class="surname">Ottosen</span>
</h3></div></div>
<div><div class="author"><h3 class="author">
<span class="firstname">Neil</span> <span class="surname">Groves</span>
</h3></div></div>
<div><p class="copyright">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves</p></div>
<div><div class="legalnotice">
<a name="id607962"></a><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>
</div></div>
</div></div>
<div class="toc">
<p><b>Table of Contents</b></p>
<dl>
<dt><span class="section"><a href="range/introduction.html">Introduction</a></span></dt>
<dt><span class="section"><a href="range/concepts.html">Range Concepts</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/concepts/overview.html">Overview</a></span></dt>
<dt><span class="section"><a href="range/concepts/single_pass_range.html">Single Pass Range</a></span></dt>
<dt><span class="section"><a href="range/concepts/forward_range.html">Forward Range</a></span></dt>
<dt><span class="section"><a href="range/concepts/bidirectional_range.html">Bidirectional Range</a></span></dt>
<dt><span class="section"><a href="range/concepts/random_access_range.html">Random Access Range</a></span></dt>
<dt><span class="section"><a href="range/concepts/concept_checking.html">Concept Checking</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="range/reference.html">Reference</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/reference/overview.html">Overview</a></span></dt>
<dt><span class="section"><a href="range/reference/concept_implementation.html">Range concept
implementation</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/reference/concept_implementation/synopsis.html">Synopsis</a></span></dt>
<dt><span class="section"><a href="range/reference/concept_implementation/semantics.html">Semantics</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="range/reference/adaptors.html">Range Adaptors</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/reference/adaptors/introduction.html">Introduction
and motivation</a></span></dt>
<dt><span class="section"><a href="range/reference/adaptors/general_requirements.html">General
Requirements</a></span></dt>
<dt><span class="section"><a href="range/reference/adaptors/reference.html">Reference</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="range/reference/algorithms.html">Range Algorithms</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/reference/algorithms/introduction.html">Introduction
and motivation</a></span></dt>
<dt><span class="section"><a href="range/reference/algorithms/mutating.html">Mutating algorithms</a></span></dt>
<dt><span class="section"><a href="range/reference/algorithms/non_mutating.html">Non-mutating
algorithms</a></span></dt>
<dt><span class="section"><a href="range/reference/algorithms/set.html">Set algorithms</a></span></dt>
<dt><span class="section"><a href="range/reference/algorithms/heap.html">Heap algorithms</a></span></dt>
<dt><span class="section"><a href="range/reference/algorithms/permutation.html">Permutation
algorithms</a></span></dt>
<dt><span class="section"><a href="range/reference/algorithms/new.html">New algorithms</a></span></dt>
<dt><span class="section"><a href="range/reference/algorithms/numeric.html">Numeric algorithms</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="range/reference/ranges.html">Provided Ranges</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/reference/ranges/any_range.html">any_range</a></span></dt>
<dt><span class="section"><a href="range/reference/ranges/counting_range.html">counting_range</a></span></dt>
<dt><span class="section"><a href="range/reference/ranges/istream_range.html">istream_range</a></span></dt>
<dt><span class="section"><a href="range/reference/ranges/irange.html">irange</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="range/reference/utilities.html">Utilities</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/reference/utilities/iterator_range.html">Class <code class="computeroutput"><span class="identifier">iterator_range</span></code></a></span></dt>
<dt><span class="section"><a href="range/reference/utilities/sub_range.html">Class <code class="computeroutput"><span class="identifier">sub_range</span></code></a></span></dt>
<dt><span class="section"><a href="range/reference/utilities/join.html">Function join</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="range/reference/extending.html">Extending the library</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/reference/extending/method_1.html">Method 1: provide
member functions and nested types</a></span></dt>
<dt><span class="section"><a href="range/reference/extending/method_2.html">Method 2: provide
free-standing functions and specialize metafunctions</a></span></dt>
<dt><span class="section"><a href="range/reference/extending/method_3.html">Method 3: provide
range adaptor implementations</a></span></dt>
</dl></dd>
</dl></dd>
<dt><span class="section"><a href="range/style_guide.html">Terminology and style guidelines</a></span></dt>
<dt><span class="section"><a href="range/headers.html">Library Headers</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/headers/general.html">General</a></span></dt>
<dt><span class="section"><a href="range/headers/adaptors.html">Adaptors</a></span></dt>
<dt><span class="section"><a href="range/headers/algorithm.html">Algorithm</a></span></dt>
<dt><span class="section"><a href="range/headers/algorithm_ext.html">Algorithm Extensions</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="range/examples.html">Examples</a></span></dt>
<dt><span class="section"><a href="range/mfc_atl.html">MFC/ATL (courtesy of Shunsuke Sogame)</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/mfc_atl/requirements.html">Requirements</a></span></dt>
<dt><span class="section"><a href="range/mfc_atl/mfc_ranges.html">MFC Ranges</a></span></dt>
<dt><span class="section"><a href="range/mfc_atl/atl_ranges.html">ATL Ranges</a></span></dt>
<dt><span class="section"><a href="range/mfc_atl/const_ranges.html">const Ranges</a></span></dt>
<dt><span class="section"><a href="range/mfc_atl/references.html">References</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="range/upgrade.html">Upgrade version of Boost.Range</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="range/upgrade/upgrade_from_1_45.html">Upgrade from version
1.45</a></span></dt>
<dt><span class="section"><a href="range/upgrade/upgrade_from_1_42.html">Upgrade from version
1.42</a></span></dt>
<dt><span class="section"><a href="range/upgrade/upgrade_from_1_34.html">Upgrade from version
1.34</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="range/portability.html">Portability</a></span></dt>
<dt><span class="section"><a href="range/faq.html">FAQ</a></span></dt>
<dt><span class="section"><a href="range/history_ack.html">History and Acknowledgement</a></span></dt>
</dl>
</div>
<p>
Boost.Range is a collection of concepts and utilities, range-based algorithms,
as well as range adaptors that allow for efficient and expressive code.
</p>
<p>
Using Boost.Range inplace of the standard library alternatives results in more
readable code and in many cases greater efficiency.
</p>
</div>
<table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
<td align="left"><p><small>Last revised: January 01, 2011 at 16:31:27 GMT</small></p></td>
<td align="right"><div class="copyright-footer"></div></td>
</tr></table>
<hr>
<div class="spirit-nav"><a accesskey="n" href="range/introduction.html"><img src="../../../../doc/src/images/next.png" alt="Next"></a></div>
</body>
</html>

View File

@ -1,155 +0,0 @@
index.html
range/introduction.html
range/concepts.html
range/concepts/overview.html
range/concepts/single_pass_range.html
range/concepts/forward_range.html
range/concepts/bidirectional_range.html
range/concepts/random_access_range.html
range/concepts/concept_checking.html
range/reference.html
range/reference/overview.html
range/reference/concept_implementation.html
range/reference/concept_implementation/synopsis.html
range/reference/concept_implementation/semantics.html
range/reference/concept_implementation/semantics/metafunctions.html
range/reference/concept_implementation/semantics/functions.html
range/reference/adaptors.html
range/reference/adaptors/introduction.html
range/reference/adaptors/general_requirements.html
range/reference/adaptors/reference.html
range/reference/adaptors/reference/adjacent_filtered.html
range/reference/adaptors/reference/copied.html
range/reference/adaptors/reference/filtered.html
range/reference/adaptors/reference/indexed.html
range/reference/adaptors/reference/indirected.html
range/reference/adaptors/reference/map_keys.html
range/reference/adaptors/reference/map_values.html
range/reference/adaptors/reference/replaced.html
range/reference/adaptors/reference/replaced_if.html
range/reference/adaptors/reference/reversed.html
range/reference/adaptors/reference/sliced.html
range/reference/adaptors/reference/strided.html
range/reference/adaptors/reference/type_erased.html
range/reference/adaptors/reference/tokenized.html
range/reference/adaptors/reference/transformed.html
range/reference/adaptors/reference/uniqued.html
range/reference/algorithms.html
range/reference/algorithms/introduction.html
range/reference/algorithms/mutating.html
range/reference/algorithms/mutating/copy.html
range/reference/algorithms/mutating/copy_backward.html
range/reference/algorithms/mutating/fill.html
range/reference/algorithms/mutating/fill_n.html
range/reference/algorithms/mutating/generate.html
range/reference/algorithms/mutating/inplace_merge.html
range/reference/algorithms/mutating/merge.html
range/reference/algorithms/mutating/nth_element.html
range/reference/algorithms/mutating/partial_sort.html
range/reference/algorithms/mutating/partition.html
range/reference/algorithms/mutating/random_shuffle.html
range/reference/algorithms/mutating/remove.html
range/reference/algorithms/mutating/remove_copy.html
range/reference/algorithms/mutating/remove_copy_if.html
range/reference/algorithms/mutating/remove_if.html
range/reference/algorithms/mutating/replace.html
range/reference/algorithms/mutating/replace_copy.html
range/reference/algorithms/mutating/replace_copy_if.html
range/reference/algorithms/mutating/replace_if.html
range/reference/algorithms/mutating/reverse.html
range/reference/algorithms/mutating/reverse_copy.html
range/reference/algorithms/mutating/rotate.html
range/reference/algorithms/mutating/rotate_copy.html
range/reference/algorithms/mutating/sort.html
range/reference/algorithms/mutating/stable_partition.html
range/reference/algorithms/mutating/stable_sort.html
range/reference/algorithms/mutating/swap_ranges.html
range/reference/algorithms/mutating/transform.html
range/reference/algorithms/mutating/unique.html
range/reference/algorithms/mutating/unique_copy.html
range/reference/algorithms/non_mutating.html
range/reference/algorithms/non_mutating/adjacent_find.html
range/reference/algorithms/non_mutating/binary_search.html
range/reference/algorithms/non_mutating/count.html
range/reference/algorithms/non_mutating/count_if.html
range/reference/algorithms/non_mutating/equal.html
range/reference/algorithms/non_mutating/equal_range.html
range/reference/algorithms/non_mutating/for_each.html
range/reference/algorithms/non_mutating/find.html
range/reference/algorithms/non_mutating/find_end.html
range/reference/algorithms/non_mutating/find_first_of.html
range/reference/algorithms/non_mutating/find_if.html
range/reference/algorithms/non_mutating/lexicographical_compare.html
range/reference/algorithms/non_mutating/lower_bound.html
range/reference/algorithms/non_mutating/max_element.html
range/reference/algorithms/non_mutating/min_element.html
range/reference/algorithms/non_mutating/mismatch.html
range/reference/algorithms/non_mutating/search.html
range/reference/algorithms/non_mutating/search_n.html
range/reference/algorithms/non_mutating/upper_bound.html
range/reference/algorithms/set.html
range/reference/algorithms/set/includes.html
range/reference/algorithms/set/set_union.html
range/reference/algorithms/set/set_intersection.html
range/reference/algorithms/set/set_difference.html
range/reference/algorithms/set/set_symmetric_difference.html
range/reference/algorithms/heap.html
range/reference/algorithms/heap/push_heap.html
range/reference/algorithms/heap/pop_heap.html
range/reference/algorithms/heap/make_heap.html
range/reference/algorithms/heap/sort_heap.html
range/reference/algorithms/permutation.html
range/reference/algorithms/permutation/next_permutation.html
range/reference/algorithms/permutation/prev_permutation.html
range/reference/algorithms/new.html
range/reference/algorithms/new/copy_n.html
range/reference/algorithms/new/erase.html
range/reference/algorithms/new/for_each.html
range/reference/algorithms/new/insert.html
range/reference/algorithms/new/iota.html
range/reference/algorithms/new/is_sorted.html
range/reference/algorithms/new/overwrite.html
range/reference/algorithms/new/push_back.html
range/reference/algorithms/new/push_front.html
range/reference/algorithms/new/remove_erase.html
range/reference/algorithms/new/remove_erase_if.html
range/reference/algorithms/numeric.html
range/reference/algorithms/numeric/accumulate.html
range/reference/algorithms/numeric/adjacent_difference.html
range/reference/algorithms/numeric/inner_product.html
range/reference/algorithms/numeric/partial_sum.html
range/reference/ranges.html
range/reference/ranges/any_range.html
range/reference/ranges/counting_range.html
range/reference/ranges/istream_range.html
range/reference/ranges/irange.html
range/reference/utilities.html
range/reference/utilities/iterator_range.html
range/reference/utilities/sub_range.html
range/reference/utilities/join.html
range/reference/extending.html
range/reference/extending/method_1.html
range/reference/extending/method_2.html
range/reference/extending/method_3.html
range/reference/extending/method_3/method_3_1.html
range/reference/extending/method_3/method_3_2.html
range/style_guide.html
range/headers.html
range/headers/general.html
range/headers/adaptors.html
range/headers/algorithm.html
range/headers/algorithm_ext.html
range/examples.html
range/mfc_atl.html
range/mfc_atl/requirements.html
range/mfc_atl/mfc_ranges.html
range/mfc_atl/atl_ranges.html
range/mfc_atl/const_ranges.html
range/mfc_atl/references.html
range/upgrade.html
range/upgrade/upgrade_from_1_45.html
range/upgrade/upgrade_from_1_42.html
range/upgrade/upgrade_from_1_34.html
range/portability.html
range/faq.html
range/history_ack.html

View File

@ -1,51 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Range Concepts</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="introduction.html" title="Introduction">
<link rel="next" href="concepts/overview.html" title="Overview">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="introduction.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concepts/overview.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.concepts"></a><a class="link" href="concepts.html" title="Range Concepts">Range Concepts</a>
</h2></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="concepts/overview.html">Overview</a></span></dt>
<dt><span class="section"><a href="concepts/single_pass_range.html">Single Pass Range</a></span></dt>
<dt><span class="section"><a href="concepts/forward_range.html">Forward Range</a></span></dt>
<dt><span class="section"><a href="concepts/bidirectional_range.html">Bidirectional Range</a></span></dt>
<dt><span class="section"><a href="concepts/random_access_range.html">Random Access Range</a></span></dt>
<dt><span class="section"><a href="concepts/concept_checking.html">Concept Checking</a></span></dt>
</dl></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="introduction.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concepts/overview.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,300 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Bidirectional Range</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../concepts.html" title="Range Concepts">
<link rel="prev" href="forward_range.html" title="Forward Range">
<link rel="next" href="random_access_range.html" title="Random Access Range">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="forward_range.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="random_access_range.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.concepts.bidirectional_range"></a><a class="link" href="bidirectional_range.html" title="Bidirectional Range">Bidirectional Range</a>
</h3></div></div></div>
<a name="range.concepts.bidirectional_range.notation"></a><h5>
<a name="id650256"></a>
<a class="link" href="bidirectional_range.html#range.concepts.bidirectional_range.notation">Notation</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">X</span></code>
</p>
</td>
<td>
<p>
A type that is a model of <a class="link" href="bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">a</span></code>
</p>
</td>
<td>
<p>
Object of type X.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.bidirectional_range.description"></a><h5>
<a name="id650345"></a>
<a class="link" href="bidirectional_range.html#range.concepts.bidirectional_range.description">Description</a>
</h5>
<p>
This concept provides access to iterators that traverse in both directions
(forward and reverse). The <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> iterator must meet all of the requirements
of <a href="../../../../../../libs/iterator/doc/new-iter-concepts.html#bidirectional-traversal-iterators-lib-bidirectional-traversal-iterators" target="_top">Bidirectional
Traversal Iterator</a>.
</p>
<a name="range.concepts.bidirectional_range.refinement_of"></a><h5>
<a name="id650403"></a>
<a class="link" href="bidirectional_range.html#range.concepts.bidirectional_range.refinement_of">Refinement
of</a>
</h5>
<p>
<a class="link" href="forward_range.html" title="Forward Range">Forward Range</a>
</p>
<a name="range.concepts.bidirectional_range.associated_types"></a><h5>
<a name="id650426"></a>
<a class="link" href="bidirectional_range.html#range.concepts.bidirectional_range.associated_types">Associated
types</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody>
<tr>
<td>
<p>
Reverse Iterator type
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_reverse_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
The type of iterator used to iterate through a Range's elements
in reverse order. The iterator's value type is expected to be the
Range's value type. A conversion from the reverse iterator type
to the const reverse iterator type must exist.
</p>
</td>
</tr>
<tr>
<td>
<p>
Const reverse iterator type
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_reverse_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
A type of reverse iterator that may be used to examine, but not
to modify, a Range's elements.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.bidirectional_range.valid_expressions"></a><h5>
<a name="id650581"></a>
<a class="link" href="bidirectional_range.html#range.concepts.bidirectional_range.valid_expressions">Valid
expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Return type
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Beginning of range
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rbegin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_reverse_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> if <code class="computeroutput"><span class="identifier">a</span></code>
is mutable <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_reverse_iterator</span><span class="special">&lt;</span><span class="keyword">const</span>
<span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> otherwise.
</p>
</td>
<td>
<p>
Equivalent to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_reverse_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
</p>
</td>
</tr>
<tr>
<td>
<p>
End of range
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rend</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_reverse_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> if <code class="computeroutput"><span class="identifier">a</span></code>
is mutable, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_reverse_iterator</span><span class="special">&lt;</span><span class="keyword">const</span>
<span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> otherwise.
</p>
</td>
<td>
<p>
Equivalent to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_reverse_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.bidirectional_range.complexity_guarantees"></a><h5>
<a name="id651042"></a>
<a class="link" href="bidirectional_range.html#range.concepts.bidirectional_range.complexity_guarantees">Complexity
guarantees</a>
</h5>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rbegin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> has
the same complexity as <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> and
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rend</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> has the same complexity as <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> from
<a class="link" href="forward_range.html" title="Forward Range">Forward Range</a>.
</p>
<a name="range.concepts.bidirectional_range.invariants"></a><h5>
<a name="id651182"></a>
<a class="link" href="bidirectional_range.html#range.concepts.bidirectional_range.invariants">Invariants</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody>
<tr>
<td>
<p>
Valid reverse range
</p>
</td>
<td>
<p>
For any Bidirectional Range a, <code class="computeroutput"><span class="special">[</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rbegin</span><span class="special">(</span><span class="identifier">a</span><span class="special">),</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rend</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
is a valid range, that is, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rend</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> is reachable from <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rbegin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
in a finite number of increments.
</p>
</td>
</tr>
<tr>
<td>
<p>
Completeness
</p>
</td>
<td>
<p>
An algorithm that iterates through the range <code class="computeroutput"><span class="special">[</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rbegin</span><span class="special">(</span><span class="identifier">a</span><span class="special">),</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">rend</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
will pass through every element of <code class="computeroutput"><span class="identifier">a</span></code>.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.bidirectional_range.see_also"></a><h5>
<a name="id651431"></a>
<a class="link" href="bidirectional_range.html#range.concepts.bidirectional_range.see_also">See also</a>
</h5>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions">Implementation
of metafunctions</a>
</p>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions">Implementation
of functions</a>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="forward_range.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="random_access_range.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,108 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Concept Checking</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../concepts.html" title="Range Concepts">
<link rel="prev" href="random_access_range.html" title="Random Access Range">
<link rel="next" href="../reference.html" title="Reference">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="random_access_range.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.concepts.concept_checking"></a><a class="link" href="concept_checking.html" title="Concept Checking">Concept Checking</a>
</h3></div></div></div>
<p>
Each of the range concepts has a corresponding concept checking class in
the file <a href="../../../../../../boost/range/concepts.hpp" target="_top"><code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">concepts</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code></a>.
These classes may be used in conjunction with the <a href="../../../../../../libs/concept_check/index.html" target="_top">Boost
Concept Check library</a> to ensure that the type of a template parameter
is compatible with a range concept. If not, a meaningful compile time error
is generated. Checks are provided for the range concepts related to iterator
traversal categories. For example, the following line checks that the type
<code class="computeroutput"><span class="identifier">T</span></code> models the <a class="link" href="forward_range.html" title="Forward Range">Forward
Range</a> concept.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">BOOST_CONCEPT_ASSERT</span><span class="special">((</span> <span class="identifier">ForwardRangeConcept</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">));</span>
</pre>
<p>
</p>
<p>
An additional concept check is required for the value access property of
the range based on the range's iterator type. For example to check for a
ForwardReadableRange, the following code is required.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">BOOST_CONCEPT_ASSERT</span><span class="special">((</span> <span class="identifier">ForwardRangeConcept</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">));</span>
<span class="identifier">BOOST_CONCEPT_ASSERT</span><span class="special">((</span> <span class="identifier">ReadableIteratorConcept</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;</span> <span class="special">));</span>
</pre>
<p>
</p>
<p>
The following range concept checking classes are provided.
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
Class SinglePassRangeConcept checks for <a class="link" href="single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>
</li>
<li class="listitem">
Class ForwardRangeConcept checks for <a class="link" href="forward_range.html" title="Forward Range">Forward
Range</a>
</li>
<li class="listitem">
Class BidirectionalRangeConcept checks for <a class="link" href="bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</li>
<li class="listitem">
Class RandomAccessRangeConcept checks for <a class="link" href="random_access_range.html" title="Random Access Range">Random
Access Range</a>
</li>
</ul></div>
<a name="range.concepts.concept_checking.see_also"></a><h5>
<a name="id652377"></a>
<a class="link" href="concept_checking.html#range.concepts.concept_checking.see_also">See also</a>
</h5>
<p>
<a class="link" href="../style_guide.html" title="Terminology and style guidelines">Range Terminology and style guidelines</a>
</p>
<p>
<a href="../../../../../../libs/iterator/doc/iterator_concepts.html" target="_top">Iterator concepts</a>
</p>
<p>
<a href="../../../../../../libs/concept_check/index.html" target="_top">Boost Concept Check library</a>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="random_access_range.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../reference.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,160 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Forward Range</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../concepts.html" title="Range Concepts">
<link rel="prev" href="single_pass_range.html" title="Single Pass Range">
<link rel="next" href="bidirectional_range.html" title="Bidirectional Range">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="single_pass_range.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="bidirectional_range.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.concepts.forward_range"></a><a class="link" href="forward_range.html" title="Forward Range">Forward Range</a>
</h3></div></div></div>
<a name="range.concepts.forward_range.notation"></a><h5>
<a name="id649886"></a>
<a class="link" href="forward_range.html#range.concepts.forward_range.notation">Notation</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">X</span></code>
</p>
</td>
<td>
<p>
A type that is a model of <a class="link" href="forward_range.html" title="Forward Range">Forward
Range</a>.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">a</span></code>
</p>
</td>
<td>
<p>
Object of type X.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.forward_range.description"></a><h5>
<a name="id649974"></a>
<a class="link" href="forward_range.html#range.concepts.forward_range.description">Description</a>
</h5>
<p>
A range <code class="computeroutput"><span class="identifier">X</span></code> where <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is a model of <a href="../../../../../../libs/iterator/doc/new-iter-concepts.html#forward-traversal-iterators-lib-forward-traversal-iterators" target="_top">Forward
Traversal Iterator</a>.
</p>
<a name="range.concepts.forward_range.refinement_of"></a><h5>
<a name="id650039"></a>
<a class="link" href="forward_range.html#range.concepts.forward_range.refinement_of">Refinement of</a>
</h5>
<p>
<a class="link" href="single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
<a name="range.concepts.forward_range.associated_types"></a><h5>
<a name="id650062"></a>
<a class="link" href="forward_range.html#range.concepts.forward_range.associated_types">Associated
types</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody>
<tr>
<td>
<p>
Distance type
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_difference</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
A signed integral type used to represent the distance between two
of the Range's iterators. This type must be the same as the iterator's
distance type.
</p>
</td>
</tr>
<tr>
<td>
<p>
Size type
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_size</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
An unsigned integral type that can represent any nonnegative value
of the Range's distance type.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.forward_range.see_also"></a><h5>
<a name="id650211"></a>
<a class="link" href="forward_range.html#range.concepts.forward_range.see_also">See also</a>
</h5>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions">Implementation
of metafunctions</a>
</p>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions">Implementation
of functions</a>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="single_pass_range.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="bidirectional_range.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,79 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Overview</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../concepts.html" title="Range Concepts">
<link rel="prev" href="../concepts.html" title="Range Concepts">
<link rel="next" href="single_pass_range.html" title="Single Pass Range">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../concepts.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="single_pass_range.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.concepts.overview"></a><a class="link" href="overview.html" title="Overview">Overview</a>
</h3></div></div></div>
<p>
A Range is a <span class="bold"><strong><span class="emphasis"><em>concept</em></span></strong></span>
similar to the STL <a href="http://www.sgi.com/Technology/STL/Container.html" target="_top">Container</a>
concept. A Range provides iterators for accessing a half-open range <code class="computeroutput"><span class="special">[</span><span class="identifier">first</span><span class="special">,</span><span class="identifier">one_past_last</span><span class="special">)</span></code> of elements and provides information about
the number of elements in the Range. However, a Range has fewer requirements
than a Container.
</p>
<p>
The motivation for the Range concept is that there are many useful Container-like
types that do not meet the full requirements of Container, and many algorithms
that can be written with this reduced set of requirements. In particular,
a Range does not necessarily
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
own the elements that can be accessed through it,
</li>
<li class="listitem">
have copy semantics,
</li>
</ul></div>
<p>
Because of the second requirement, a Range object must be passed by (const
or non-const) reference in generic code.
</p>
<p>
The operations that can be performed on a Range is dependent on the <a href="../../../../../../libs/iterator/doc/new-iter-concepts.html#iterator-traversal-concepts-lib-iterator-traversal" target="_top">traversal
category</a> of the underlying iterator type. Therefore the range concepts
are named to reflect which traversal category its iterators support. See
also terminology and style guidelines. for more information about naming
of ranges.
</p>
<p>
The concepts described below specifies associated types as <a href="../../../../../../libs/mpl/doc/refmanual/metafunction.html" target="_top">metafunctions</a>
and all functions as free-standing functions to allow for a layer of indirection.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../concepts.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="single_pass_range.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,187 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Random Access Range</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../concepts.html" title="Range Concepts">
<link rel="prev" href="bidirectional_range.html" title="Bidirectional Range">
<link rel="next" href="concept_checking.html" title="Concept Checking">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="bidirectional_range.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concept_checking.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.concepts.random_access_range"></a><a class="link" href="random_access_range.html" title="Random Access Range">Random Access Range</a>
</h3></div></div></div>
<a name="range.concepts.random_access_range.description"></a><h5>
<a name="id651477"></a>
<a class="link" href="random_access_range.html#range.concepts.random_access_range.description">Description</a>
</h5>
<p>
A range <code class="computeroutput"><span class="identifier">X</span></code> where <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is a model of <a href="../../../../../../libs/iterator/doc/new-iter-concepts.html#random-access-traversal-iterators-lib-random-access-traversal-iterators" target="_top">Random
Access Traversal Iterator</a>.
</p>
<a name="range.concepts.random_access_range.refinement_of"></a><h5>
<a name="id651543"></a>
<a class="link" href="random_access_range.html#range.concepts.random_access_range.refinement_of">Refinement
of</a>
</h5>
<p>
<a class="link" href="bidirectional_range.html" title="Bidirectional Range">Bidirectional Range</a>
</p>
<a name="range.concepts.random_access_range.valid_expressions"></a><h5>
<a name="id651566"></a>
<a class="link" href="random_access_range.html#range.concepts.random_access_range.valid_expressions">Valid
expressions</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Return type
</p>
</th>
</tr></thead>
<tbody><tr>
<td>
<p>
Size of range
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">size</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_size</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
</tr></tbody>
</table></div>
<a name="range.concepts.random_access_range.expression_semantics"></a><h5>
<a name="id651704"></a>
<a class="link" href="random_access_range.html#range.concepts.random_access_range.expression_semantics">Expression
semantics</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
<th>
<p>
Postcondition
</p>
</th>
</tr></thead>
<tbody><tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">size</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
Returns the size of the Range, that is, its number of elements.
Note <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">size</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span>
<span class="special">==</span> <span class="number">0u</span></code>
is equivalent to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">empty</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>.
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">size</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span>
<span class="special">&gt;=</span> <span class="number">0</span></code>
</p>
</td>
</tr></tbody>
</table></div>
<a name="range.concepts.random_access_range.complexity_guarantees"></a><h5>
<a name="id651919"></a>
<a class="link" href="random_access_range.html#range.concepts.random_access_range.complexity_guarantees">Complexity
guarantees</a>
</h5>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">size</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> completes in amortized constant time.
</p>
<a name="range.concepts.random_access_range.invariants"></a><h5>
<a name="id651967"></a>
<a class="link" href="random_access_range.html#range.concepts.random_access_range.invariants">Invariants</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody><tr>
<td>
<p>
Range size
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">size</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
is equal to the <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> - <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>.
</p>
</td>
</tr></tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="bidirectional_range.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concept_checking.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,350 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Single Pass Range</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../concepts.html" title="Range Concepts">
<link rel="prev" href="overview.html" title="Overview">
<link rel="next" href="forward_range.html" title="Forward Range">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="overview.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="forward_range.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.concepts.single_pass_range"></a><a class="link" href="single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</h3></div></div></div>
<a name="range.concepts.single_pass_range.notation"></a><h5>
<a name="id648593"></a>
<a class="link" href="single_pass_range.html#range.concepts.single_pass_range.notation">Notation</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">X</span></code>
</p>
</td>
<td>
<p>
A type that is a model of <a class="link" href="single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">a</span></code>
</p>
</td>
<td>
<p>
Object of type X.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.single_pass_range.description"></a><h5>
<a name="id648686"></a>
<a class="link" href="single_pass_range.html#range.concepts.single_pass_range.description">Description</a>
</h5>
<p>
A range <code class="computeroutput"><span class="identifier">X</span></code> where <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is a model of <a href="../../../../../../libs/iterator/doc/new-iter-concepts.html#singls-pass-iterators-lib-single-pass-iterators" target="_top">Single
Pass Iterator</a>.
</p>
<a name="range.concepts.single_pass_range.associated_types"></a><h5>
<a name="id648751"></a>
<a class="link" href="single_pass_range.html#range.concepts.single_pass_range.associated_types">Associated
types</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody>
<tr>
<td>
<p>
Iterator type
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
The type of iterator used to iterate through a Range's elements.
The iterator's value type is expected to be the Range's value type.
A conversion from the iterator type to the <code class="computeroutput"><span class="keyword">const</span></code>
iterator type must exist.
</p>
</td>
</tr>
<tr>
<td>
<p>
Const iterator type
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
A type of iterator that may be used to examine, but not to modify,
a Range's elements.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.single_pass_range.valid_expressions"></a><h5>
<a name="id648914"></a>
<a class="link" href="single_pass_range.html#range.concepts.single_pass_range.valid_expressions">Valid
expressions</a>
</h5>
<p>
The following expressions must be valid.
</p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Name
</p>
</th>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Return type
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Beginning of range
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> if <code class="computeroutput"><span class="identifier">a</span></code>
is mutable, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span>
<span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> otherwise
</p>
</td>
</tr>
<tr>
<td>
<p>
End of range
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> if <code class="computeroutput"><span class="identifier">a</span></code>
is mutable, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span>
<span class="identifier">X</span><span class="special">&gt;::</span><span class="identifier">type</span></code> otherwise
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.single_pass_range.expression_semantics"></a><h5>
<a name="id649233"></a>
<a class="link" href="single_pass_range.html#range.concepts.single_pass_range.expression_semantics">Expression
semantics</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Semantics
</p>
</th>
<th>
<p>
Postcondition
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
Returns an iterator pointing to the first element in the Range.
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
is either dereferenceable or past-the-end. It is past-the-end if
and only if <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span> <span class="special">==</span> <span class="number">0</span></code>.
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
Returns an iterator pointing one past the last element in the Range.
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
is past-the-end.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.single_pass_range.complexity_guarantees"></a><h5>
<a name="id649490"></a>
<a class="link" href="single_pass_range.html#range.concepts.single_pass_range.complexity_guarantees">Complexity
guarantees</a>
</h5>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> is at most amortized linear time, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> is amortized
constant time. For most practical purposes, one can expect both to be amortized
constant time.
</p>
<a name="range.concepts.single_pass_range.invariants"></a><h5>
<a name="id649567"></a>
<a class="link" href="single_pass_range.html#range.concepts.single_pass_range.invariants">Invariants</a>
</h5>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody>
<tr>
<td>
<p>
Valid range
</p>
</td>
<td>
<p>
For any Range <code class="computeroutput"><span class="identifier">a</span></code>,
<code class="computeroutput"><span class="special">[</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">),</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code> is a valid range, that is, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>
is reachable from <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code> in a finite number of increments.
</p>
</td>
</tr>
<tr>
<td>
<p>
Completeness
</p>
</td>
<td>
<p>
An algorithm that iterates through the range <code class="computeroutput"><span class="special">[</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">a</span><span class="special">),</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">a</span><span class="special">))</span></code>
will pass through every element of <code class="computeroutput"><span class="identifier">a</span></code>.
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.concepts.single_pass_range.see_also"></a><h5>
<a name="id649823"></a>
<a class="link" href="single_pass_range.html#range.concepts.single_pass_range.see_also">See also</a>
</h5>
<p>
<a class="link" href="../reference/extending.html" title="Extending the library">Extending the library for UDTs</a>
</p>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions">Implementation
of metafunctions</a>
</p>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions">Implementation
of functions</a>
</p>
<p>
<a href="http://www.sgi.com/Technology/STL/Container.html" target="_top">Container</a>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="overview.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../concepts.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="forward_range.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,74 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Examples</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="headers/algorithm_ext.html" title="Algorithm Extensions">
<link rel="next" href="mfc_atl.html" title="MFC/ATL (courtesy of Shunsuke Sogame)">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="headers/algorithm_ext.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mfc_atl.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.examples"></a><a class="link" href="examples.html" title="Examples">Examples</a>
</h2></div></div></div>
<p>
Some examples are given in the accompanying test files:
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<a href="http://www.boost.org/libs/range/test/string.cpp" target="_top">string.cpp</a>
shows how to implement a container version of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">find</span><span class="special">()</span></code> that works with <code class="computeroutput"><span class="keyword">char</span><span class="special">[]</span></code>,<code class="computeroutput"><span class="keyword">wchar_t</span><span class="special">[]</span></code>,<code class="computeroutput"><span class="keyword">char</span><span class="special">*</span></code>,<code class="computeroutput"><span class="keyword">wchar_t</span><span class="special">*</span></code>.
</li>
<li class="listitem">
<a href="http://www.boost.org/libs/range/test/algorithm_example.cpp" target="_top">algorithm_example.cpp</a>
shows the replace example from the introduction.
</li>
<li class="listitem">
<a href="http://www.boost.org/libs/range/test/iterator_range.cpp" target="_top">iterator_range.cpp</a>
</li>
<li class="listitem">
<a href="http://www.boost.org/libs/range/test/sub_range.cpp" target="_top">sub_range.cpp</a>
</li>
<li class="listitem">
<a href="http://www.boost.org/libs/range/test/iterator_pair.cpp" target="_top">iterator_pair.cpp</a>
</li>
<li class="listitem">
<a href="http://www.boost.org/libs/range/test/reversible_range.cpp" target="_top">reversible_range.cpp</a>
</li>
<li class="listitem">
<a href="http://www.boost.org/libs/range/test/std_container.cpp" target="_top">std_container.cpp</a>
</li>
<li class="listitem">
<a href="http://www.boost.org/libs/range/test/array.cpp" target="_top">array.cpp</a>
</li>
</ul></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="headers/algorithm_ext.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mfc_atl.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,89 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>FAQ</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="portability.html" title="Portability">
<link rel="next" href="history_ack.html" title="History and Acknowledgement">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="portability.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history_ack.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.faq"></a><a class="link" href="faq.html" title="FAQ">FAQ</a>
</h2></div></div></div>
<p>
1. <span class="emphasis"><em><span class="bold"><strong>Why is there no difference between <code class="computeroutput"><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
and <code class="computeroutput"><span class="identifier">range_const_iterator</span><span class="special">&lt;</span><span class="identifier">C</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
for <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">iterator</span><span class="special">,</span> <span class="identifier">iterator</span><span class="special">&gt;</span></code>?</strong></span></em></span>
</p>
<div class="blockquote"><blockquote class="blockquote"><p>
In general it is not possible nor desirable to find a corresponding <code class="computeroutput"><span class="identifier">const_iterator</span></code>. When it is possible to
come up with one, the client might choose to construct a <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">const_iterator</span><span class="special">,</span><span class="identifier">const_iterator</span><span class="special">&gt;</span></code> object.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
Note that an <a class="link" href="reference/utilities/iterator_range.html" title="Class iterator_range"><code class="computeroutput"><span class="identifier">iterator_range</span></code></a> is somewhat more
convenient than a <code class="computeroutput"><span class="identifier">pair</span></code> and
that a <a class="link" href="reference/utilities/sub_range.html" title="Class sub_range"><code class="computeroutput"><span class="identifier">sub_range</span></code></a> does propagate const-ness.
</p></blockquote></div>
<p>
2. <span class="emphasis"><em><span class="bold"><strong>Why is there not supplied more types or
more functions?</strong></span></em></span>
</p>
<div class="blockquote"><blockquote class="blockquote"><p>
The library has been kept small because its current interface will serve
most purposes. If and when a genuine need arises for more functionality,
it can be implemented.
</p></blockquote></div>
<p>
3. <span class="emphasis"><em><span class="bold"><strong>How should I implement generic algorithms
for ranges?</strong></span></em></span>
</p>
<div class="blockquote"><blockquote class="blockquote"><p>
One should always start with a generic algorithm that takes two iterators
(or more) as input. Then use Boost.Range to build handier versions on top
of the iterator based algorithm. Please notice that once the range version
of the algorithm is done, it makes sense not to expose the iterator version
in the public interface.
</p></blockquote></div>
<p>
4. <span class="emphasis"><em><span class="bold"><strong>Why is there no Incrementable Range concept?</strong></span></em></span>
</p>
<div class="blockquote"><blockquote class="blockquote"><p>
Even though we speak of incrementable iterators, it would not make much sense
for ranges; for example, we cannot determine the size and emptiness of a
range since we cannot even compare its iterators.
</p></blockquote></div>
<div class="blockquote"><blockquote class="blockquote"><p>
Note also that incrementable iterators are derived from output iterators
and so there exist no output range.
</p></blockquote></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="portability.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="history_ack.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,49 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Library Headers</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="style_guide.html" title="Terminology and style guidelines">
<link rel="next" href="headers/general.html" title="General">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="style_guide.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="headers/general.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.headers"></a><a class="link" href="headers.html" title="Library Headers">Library Headers</a>
</h2></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="headers/general.html">General</a></span></dt>
<dt><span class="section"><a href="headers/adaptors.html">Adaptors</a></span></dt>
<dt><span class="section"><a href="headers/algorithm.html">Algorithm</a></span></dt>
<dt><span class="section"><a href="headers/algorithm_ext.html">Algorithm Extensions</a></span></dt>
</dl></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="style_guide.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="headers/general.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,232 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Adaptors</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../headers.html" title="Library Headers">
<link rel="prev" href="general.html" title="General">
<link rel="next" href="algorithm.html" title="Algorithm">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="general.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithm.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.headers.adaptors"></a><a class="link" href="adaptors.html" title="Adaptors">Adaptors</a>
</h3></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Header
</p>
</th>
<th>
<p>
Includes
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">adjacent_filtered</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/adjacent_filtered.html" title="adjacent_filtered">adjacent_filtered</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">copied</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/copied.html" title="copied">copied</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">filtered</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/filtered.html" title="filtered">filtered</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">indexed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/indexed.html" title="indexed">indexed</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">indirected</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">.</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/indirected.html" title="indirected">indirected</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">map</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/map_keys.html" title="map_keys">map_keys</a>
<a class="link" href="../reference/adaptors/reference/map_values.html" title="map_values">map_values</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">replaced</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/replaced.html" title="replaced">replaced</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">replaced_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/replaced_if.html" title="replaced_if">replaced_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">reversed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/reversed.html" title="reversed">reversed</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">sliced</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/sliced.html" title="sliced">sliced</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">strided</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/strided.html" title="strided">strided</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">tokenized</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/tokenized.html" title="tokenized">tokenized</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">transformed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/transformed.html" title="transformed">transformed</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">uniqued</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/uniqued.html" title="uniqued">uniqued</a>
</p>
</td>
</tr>
</tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="general.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithm.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,683 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Algorithm</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../headers.html" title="Library Headers">
<link rel="prev" href="adaptors.html" title="Adaptors">
<link rel="next" href="algorithm_ext.html" title="Algorithm Extensions">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="adaptors.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithm_ext.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.headers.algorithm"></a><a class="link" href="algorithm.html" title="Algorithm">Algorithm</a>
</h3></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Header
</p>
</th>
<th>
<p>
Includes
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">adjacent_find</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/adjacent_find.html" title="adjacent_find">adjacent_find</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">binary_search</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/binary_search.html" title="binary_search">binary_search</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/copy.html" title="copy">copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy_backward</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/copy_backward.html" title="copy_backward">copy_backward</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">count</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/count.html" title="count">count</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">count_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/count_if.html" title="count_if">count_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/equal.html" title="equal">equal</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">equal_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/equal_range.html" title="equal_range">equal_range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">fill</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/fill.html" title="fill">fill</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">fill_n</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/fill_n.html" title="fill_n">fill_n</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">find</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/find.html" title="find">find</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">find_end</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/find_end.html" title="find_end">find_end</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">find_first_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/find_first_of.html" title="find_first_of">find_first_of</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">find_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/find_if.html" title="find_if">find_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">for_each</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/for_each.html" title="for_each">for_each</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">generate</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/generate.html" title="generate">generate</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">heap_algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/heap/push_heap.html" title="push_heap">push_heap</a>
<a class="link" href="../reference/algorithms/heap/pop_heap.html" title="pop_heap">pop_heap</a>
<a class="link" href="../reference/algorithms/heap/make_heap.html" title="make_heap">make_heap</a>
<a class="link" href="../reference/algorithms/heap/sort_heap.html" title="sort_heap">sort_heap</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">inplace_merge</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/inplace_merge.html" title="inplace_merge">inplace_merge</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">lexicographical_compare</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/lexicographical_compare.html" title="lexicographical_compare">lexicographical_compare</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">lower_bound</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/lower_bound.html" title="lower_bound">lower_bound</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">max_element</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/max_element.html" title="max_element">max_element</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">merge</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/merge.html" title="merge">merge</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">min_element</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/min_element.html" title="min_element">min_element</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">mismatch</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/mismatch.html" title="mismatch">mismatch</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">nth_element</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/nth_element.html" title="nth_element">nth_element</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">partial_sort</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/partial_sort.html" title="partial_sort">partial_sort</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">partition</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/partition.html" title="partition">partition</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">permutation</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/permutation/next_permutation.html" title="next_permutation">next_permutation</a>
<a class="link" href="../reference/algorithms/permutation/prev_permutation.html" title="prev_permutation">prev_permutation</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">random_shuffle</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/random_shuffle.html" title="random_shuffle">random_shuffle</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/remove.html" title="remove">remove</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/remove_copy.html" title="remove_copy">remove_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove_copy_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/remove_copy_if.html" title="remove_copy_if">remove_copy_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/remove_if.html" title="remove_if">remove_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/replace.html" title="replace">replace</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/replace_copy.html" title="replace_copy">replace_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace_copy_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/replace_copy_if.html" title="replace_copy_if">replace_copy_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/replace_if.html" title="replace_if">replace_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">reverse</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/reverse.html" title="reverse">reverse</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">reverse_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/reverse_copy.html" title="reverse_copy">reverse_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">rotate</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/rotate.html" title="rotate">rotate</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">rotate_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/rotate_copy.html" title="rotate_copy">rotate_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">search</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/search.html" title="search">search</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">search_n</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/search_n.html" title="search_n">search_n</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">set_algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/set/includes.html" title="includes">includes</a>
<a class="link" href="../reference/algorithms/set/set_union.html" title="set_union">set_union</a>
<a class="link" href="../reference/algorithms/set/set_intersection.html" title="set_intersection">set_intersection</a>
<a class="link" href="../reference/algorithms/set/set_difference.html" title="set_difference">set_difference</a>
<a class="link" href="../reference/algorithms/set/set_symmetric_difference.html" title="set_symmetric_difference">set_symmetric_difference</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">sort</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/sort.html" title="sort">sort</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">stable_partition</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/stable_partition.html" title="stable_partition">stable_partition</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">swap_ranges</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/swap_ranges.html" title="swap_ranges">swap_ranges</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">transform</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/transform.html" title="transform">transform</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">unique</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/unique.html" title="unique">unique</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">unique_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/unique_copy.html" title="unique_copy">unique_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">upper_bound</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/upper_bound.html" title="upper_bound">upper_bound</a>
</p>
</td>
</tr>
</tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="adaptors.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithm_ext.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,171 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Algorithm Extensions</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../headers.html" title="Library Headers">
<link rel="prev" href="algorithm.html" title="Algorithm">
<link rel="next" href="../examples.html" title="Examples">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="algorithm.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.headers.algorithm_ext"></a><a class="link" href="algorithm_ext.html" title="Algorithm Extensions">Algorithm Extensions</a>
</h3></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Header
</p>
</th>
<th>
<p>
Includes
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">copy_n</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/copy_n.html" title="copy_n">copy_n</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">erase</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/erase.html" title="erase">erase</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">for_each</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/for_each.html" title="for_each">for_each</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">insert</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/insert.html" title="insert">insert</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">iota</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/iota.html" title="iota">iota</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">is_sorted</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/is_sorted.html" title="is_sorted">is_sorted</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">overwrite</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/overwrite.html" title="overwrite">overwrite</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">push_back</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/push_back.html" title="push_back">push_back</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">push_front</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/push_front.html" title="push_front">push_front</a>
</p>
</td>
</tr>
</tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="algorithm.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,551 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>General</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../headers.html" title="Library Headers">
<link rel="prev" href="../headers.html" title="Library Headers">
<link rel="next" href="adaptors.html" title="Adaptors">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../headers.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="adaptors.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.headers.general"></a><a class="link" href="general.html" title="General">General</a>
</h3></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Header
</p>
</th>
<th>
<p>
Includes
</p>
</th>
<th>
<p>
Related Concept
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
everything from Boost.Range version 1 (Boost versions 1.42 and
below). Includes the core range functions and metafunctinos, but
excludes Range Adaptors and Range Algorithms.
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">metafunctions</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every metafunction
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">functions</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every function
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">value_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_value</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">iterator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_iterator</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">difference_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_difference</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_pointer</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">category</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_category</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">reverse_iterator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_reverse_iterator</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">begin</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">begin</span></code></a> and <a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_begin</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">end</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">end</span></code></a> and <a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_end</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">empty</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">empty</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">distance</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">distance</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">size</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">size</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">rbegin</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">rbegin</span></code></a> and <a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_rbegin</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">rend</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">rend</span></code></a> and <a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_rend</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">as_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">as_array</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">as_literal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">as_literal</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">iterator_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/utilities/iterator_range.html" title="Class iterator_range"><code class="computeroutput"><span class="identifier">iterator_range</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">sub_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/utilities/sub_range.html" title="Class sub_range"><code class="computeroutput"><span class="identifier">sub_range</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">concepts</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts.html" title="Range Concepts">Range concepts</a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptors</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every range adaptor
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every range equivalent of an STL algorithm
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every range algorithm that is an extension of the STL algorithms
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">counting_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/ranges/counting_range.html" title="counting_range"><code class="computeroutput"><span class="identifier">counting_range</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">istream_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/ranges/istream_range.html" title="istream_range"><code class="computeroutput"><span class="identifier">istream_range</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">irange</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/ranges/irange.html" title="irange"><code class="computeroutput"><span class="identifier">irange</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">join</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/utilities/join.html" title="Function join"><code class="computeroutput"><span class="identifier">join</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
</tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../headers.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="adaptors.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,156 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>History and Acknowledgement</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="faq.html" title="FAQ">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="faq.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.history_ack"></a><a class="link" href="history_ack.html" title="History and Acknowledgement">History and Acknowledgement</a>
</h2></div></div></div>
<a name="range.history_ack.version_1___before_boost_1_43"></a><h4>
<a name="id786758"></a>
<a class="link" href="history_ack.html#range.history_ack.version_1___before_boost_1_43">Version 1 -
before Boost 1.43</a>
</h4>
<p>
The library have been under way for a long time. Dietmar K&#252;hl originally intended
to submit an <code class="computeroutput"><span class="identifier">array_traits</span></code> class
template which had most of the functionality present now, but only for arrays
and standard containers.
</p>
<p>
Meanwhile work on algorithms for containers in various contexts showed the
need for handling pairs of iterators, and string libraries needed special treatment
of character arrays. In the end it made sense to formalize the minimal requirements
of these similar concepts. And the results are the Range concepts found in
this library.
</p>
<p>
The term Range was adopted because of paragraph 24.1/7 from the C++ standard:
</p>
<p>
Most of the library's algorithmic templates that operate on data structures
have interfaces that use ranges. A range is a pair of iterators that designate
the beginning and end of the computation. A range [i, i) is an empty range;
in general, a range [i, j) refers to the elements in the data structure starting
with the one pointed to by i and up to but not including the one pointed to
by j. Range [i, j) is valid if and only if j is reachable from i. The result
of the application of functions in the library to invalid ranges is undefined.
</p>
<p>
Special thanks goes to
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
Pavol Droba for help with documentation and implementation
</li>
<li class="listitem">
Pavel Vozenilek for help with porting the library
</li>
<li class="listitem">
Jonathan Turkanis and John Torjo for help with documentation
</li>
<li class="listitem">
Hartmut Kaiser for being review manager
</li>
<li class="listitem">
Jonathan Turkanis for porting the lib (as far sa possible) to vc6 and vc7.
</li>
</ul></div>
<p>
The concept checks and their documentation was provided by Daniel Walker.
</p>
<a name="range.history_ack.version_2___boost_1_43_and_beyond"></a><h4>
<a name="id786859"></a>
<a class="link" href="history_ack.html#range.history_ack.version_2___boost_1_43_and_beyond">Version
2 - Boost 1.43 and beyond</a>
</h4>
<p>
This version introduced Range Adaptors and Range Algorithms. This version 2
is the result of a merge of all of the RangeEx features into Boost.Range.
</p>
<p>
There were an enormous number of very significant contributors through all
stages of this library.
</p>
<p>
Prior to Boost.RangeEx there had been a number of Range library implementations,
these include library implementations by Eric Niebler, Adobe, Shunsuke Sogame
etc. Eric Niebler contributed the Range Adaptor idea which is arguably the
single biggest innovation in this library. Inevitably a great deal of commonality
evolved in each of these libraries, but a considerable amount of effort was
expended to learn from all of the divergent techniques.
</p>
<p>
The people in the following list all made contributions in the form of reviews,
user feedback, design suggestions, or defect detection:
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
Thorsten Ottosen: review management, design advice, documentation feedback
</li>
<li class="listitem">
Eric Niebler: early implementation, and review feedback
</li>
<li class="listitem">
Joel de Guzman: review
</li>
<li class="listitem">
Mathias Gaunard: review
</li>
<li class="listitem">
David Abrahams: implementation advice
</li>
<li class="listitem">
Robert Jones: defect reports, usage feedback
</li>
<li class="listitem">
Sean Parent: contributed experience from the Adobe range library
</li>
<li class="listitem">
Arno Schoedl: implementations, and review
</li>
<li class="listitem">
Rogier van Dalen: review
</li>
<li class="listitem">
Vincente Botet: review, documentation feedback
</li>
</ul></div>
<p>
Regardless of how I write this section it will never truly fairly capture the
gratitude that I feel to all who have contributed. Thank you everyone.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="faq.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a>
</div>
</body>
</html>

View File

@ -1,129 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Introduction</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="next" href="concepts.html" title="Range Concepts">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concepts.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.introduction"></a><a class="link" href="introduction.html" title="Introduction">Introduction</a>
</h2></div></div></div>
<p>
Generic algorithms have so far been specified in terms of two or more iterators.
Two iterators would together form a range of values that the algorithm could
work on. This leads to a very general interface, but also to a somewhat clumsy
use of the algorithms with redundant specification of container names. Therefore
we would like to raise the abstraction level for algorithms so they specify
their interface in terms of <a class="link" href="concepts.html" title="Range Concepts">Ranges</a> as
much as possible.
</p>
<p>
The most common form of ranges used throughout the C++ community are standard
library containers. When writing algorithms however, one often finds it desirable
for the algorithm to accept other types that offer enough functionality to
satisfy the needs of the generic code <span class="bold"><strong><span class="emphasis"><em>if a
suitable layer of indirection is applied</em></span></strong></span> . For example,
raw arrays are often suitable for use with generic code that works with containers,
provided a suitable adapter is used. Likewise, null terminated strings can
be treated as containers of characters, if suitably adapted.
</p>
<p>
This library therefore provides the means to adapt standard-like containers,
null terminated strings, <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pairs</span></code> of
iterators, and raw arrays (and more), such that the same generic code can work
with them all. The basic idea is to add another layer of indirection using
<a href="../../../../../libs/mpl/doc/refmanual/metafunction.html" target="_top">metafunctions</a>
and free-standing functions so syntactic and/or semantic differences can be
removed.
</p>
<p>
The main advantages are
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
simpler implementation and specification of generic range algorithms
</li>
<li class="listitem">
more flexible, compact and maintainable client code
</li>
<li class="listitem">
safe use of built-in arrays (for legacy code; why else would you use built-in
arrays?)
</li>
</ul></div>
<a name="range.introduction.example___iterate_over_the_values_in_a_map"></a><h4>
<a name="id607240"></a>
<a class="link" href="introduction.html#range.introduction.example___iterate_over_the_values_in_a_map">Example
- Iterate over the values in a map</a>
</h4>
<p>
</p>
<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">for_each</span><span class="special">(</span> <span class="identifier">my_map</span> <span class="special">|</span> <span class="identifier">map_values</span><span class="special">,</span> <span class="identifier">fn</span> <span class="special">);</span>
</pre>
<p>
</p>
<a name="range.introduction.example___iterate_over_the_keys_in_a_map"></a><h4>
<a name="id607360"></a>
<a class="link" href="introduction.html#range.introduction.example___iterate_over_the_keys_in_a_map">Example
- Iterate over the keys in a map</a>
</h4>
<p>
</p>
<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">for_each</span><span class="special">(</span> <span class="identifier">my_map</span> <span class="special">|</span> <span class="identifier">map_keys</span><span class="special">,</span> <span class="identifier">fn</span> <span class="special">);</span>
</pre>
<p>
</p>
<a name="range.introduction.example___push_the_even_values_from_a_map_in_reverse_order_into_the_container__code__phrase_role__identifier__target__phrase___code_"></a><h4>
<a name="id648314"></a>
<a class="link" href="introduction.html#range.introduction.example___push_the_even_values_from_a_map_in_reverse_order_into_the_container__code__phrase_role__identifier__target__phrase___code_">Example
- Push the even values from a map in reverse order into the container <code class="computeroutput"><span class="identifier">target</span></code></a>
</h4>
<p>
</p>
<pre class="programlisting"><span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="comment">// Assume that is_even is a predicate that has been implemented elsewhere...
</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">target</span><span class="special">,</span> <span class="identifier">my_map</span> <span class="special">|</span> <span class="identifier">map_values</span> <span class="special">|</span> <span class="identifier">filtered</span><span class="special">(</span><span class="identifier">is_even</span><span class="special">())</span> <span class="special">|</span> <span class="identifier">reversed</span><span class="special">);</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../index.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="concepts.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,50 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Library Headers</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="style_guide.html" title="Terminology and style guidelines">
<link rel="next" href="library_headers/general.html" title="General">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="style_guide.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="library_headers/general.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.library_headers"></a><a class="link" href="library_headers.html" title="Library Headers">Library Headers</a>
</h2></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="library_headers/general.html">General</a></span></dt>
<dt><span class="section"><a href="library_headers/adaptors.html">Adaptors</a></span></dt>
<dt><span class="section"><a href="library_headers/algorithm.html">Algorithm</a></span></dt>
<dt><span class="section"><a href="library_headers/algorithm_extensions.html">Algorithm
Extensions</a></span></dt>
</dl></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="style_guide.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="library_headers/general.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,232 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Adaptors</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../library_headers.html" title="Library Headers">
<link rel="prev" href="general.html" title="General">
<link rel="next" href="algorithm.html" title="Algorithm">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="general.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../library_headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithm.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.library_headers.adaptors"></a><a class="link" href="adaptors.html" title="Adaptors">Adaptors</a>
</h3></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Header
</p>
</th>
<th>
<p>
Includes
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">adjacent_filtered</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/adjacent_filtered.html" title="adjacent_filtered">adjacent_filtered</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">copied</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/copied.html" title="copied">copied</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">filtered</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/filtered.html" title="filtered">filtered</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">indexed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/indexed.html" title="indexed">indexed</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">indirected</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">.</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/indirected.html" title="indirected">indirected</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">map</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/map_keys.html" title="map_keys">map_keys</a>
<a class="link" href="../reference/adaptors/reference/map_values.html" title="map_values">map_values</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">replaced</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/replaced.html" title="replaced">replaced</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">replaced_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/replaced_if.html" title="replaced_if">replaced_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">reversed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/reversed.html" title="reversed">reversed</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">sliced</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/sliced.html" title="sliced">sliced</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">strided</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/strided.html" title="strided">strided</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">tokenized</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/tokenized.html" title="tokenized">tokenized</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">transformed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/transformed.html" title="transformed">transformed</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">uniqued</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/adaptors/reference/uniqued.html" title="uniqued">uniqued</a>
</p>
</td>
</tr>
</tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="general.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../library_headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithm.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,683 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Algorithm</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../library_headers.html" title="Library Headers">
<link rel="prev" href="adaptors.html" title="Adaptors">
<link rel="next" href="algorithm_extensions.html" title="Algorithm Extensions">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="adaptors.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../library_headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithm_extensions.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.library_headers.algorithm"></a><a class="link" href="algorithm.html" title="Algorithm">Algorithm</a>
</h3></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Header
</p>
</th>
<th>
<p>
Includes
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">adjacent_find</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/adjacent_find.html" title="adjacent_find">adjacent_find</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">binary_search</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/binary_search.html" title="binary_search">binary_search</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/copy.html" title="copy">copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy_backward</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/copy_backward.html" title="copy_backward">copy_backward</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">count</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/count.html" title="count">count</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">count_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/count_if.html" title="count_if">count_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">equal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/equal.html" title="equal">equal</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">equal_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/equal_range.html" title="equal_range">equal_range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">fill</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/fill.html" title="fill">fill</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">fill_n</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/fill_n.html" title="fill_n">fill_n</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">find</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/find.html" title="find">find</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">find_end</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/find_end.html" title="find_end">find_end</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">find_first_of</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/find_first_of.html" title="find_first_of">find_first_of</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">find_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/find_if.html" title="find_if">find_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">for_each</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/for_each.html" title="for_each">for_each</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">generate</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/generate.html" title="generate">generate</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">heap_algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/heap/push_heap.html" title="push_heap">push_heap</a>
<a class="link" href="../reference/algorithms/heap/pop_heap.html" title="pop_heap">pop_heap</a>
<a class="link" href="../reference/algorithms/heap/make_heap.html" title="make_heap">make_heap</a>
<a class="link" href="../reference/algorithms/heap/sort_heap.html" title="sort_heap">sort_heap</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">inplace_merge</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/inplace_merge.html" title="inplace_merge">inplace_merge</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">lexicographical_compare</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/lexicographical_compare.html" title="lexicographical_compare">lexicographical_compare</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">lower_bound</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/lower_bound.html" title="lower_bound">lower_bound</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">max_element</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/max_element.html" title="max_element">max_element</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">merge</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/merge.html" title="merge">merge</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">min_element</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/min_element.html" title="min_element">min_element</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">mismatch</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/mismatch.html" title="mismatch">mismatch</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">nth_element</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/nth_element.html" title="nth_element">nth_element</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">partial_sort</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/partial_sort.html" title="partial_sort">partial_sort</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">partition</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/partition.html" title="partition">partition</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">permutation</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/permutation/next_permutation.html" title="next_permutation">next_permutation</a>
<a class="link" href="../reference/algorithms/permutation/prev_permutation.html" title="prev_permutation">prev_permutation</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">random_shuffle</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/random_shuffle.html" title="random_shuffle">random_shuffle</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/remove.html" title="remove">remove</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/remove_copy.html" title="remove_copy">remove_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove_copy_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/remove_copy_if.html" title="remove_copy_if">remove_copy_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/remove_if.html" title="remove_if">remove_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/replace.html" title="replace">replace</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/replace_copy.html" title="replace_copy">replace_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace_copy_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/replace_copy_if.html" title="replace_copy_if">replace_copy_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/replace_if.html" title="replace_if">replace_if</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">reverse</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/reverse.html" title="reverse">reverse</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">reverse_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/reverse_copy.html" title="reverse_copy">reverse_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">rotate</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/rotate.html" title="rotate">rotate</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">rotate_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/rotate_copy.html" title="rotate_copy">rotate_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">search</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/search.html" title="search">search</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">search_n</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/search_n.html" title="search_n">search_n</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">set_algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/set/includes.html" title="includes">includes</a>
<a class="link" href="../reference/algorithms/set/set_union.html" title="set_union">set_union</a>
<a class="link" href="../reference/algorithms/set/set_intersection.html" title="set_intersection">set_intersection</a>
<a class="link" href="../reference/algorithms/set/set_difference.html" title="set_difference">set_difference</a>
<a class="link" href="../reference/algorithms/set/set_symmetric_difference.html" title="set_symmetric_difference">set_symmetric_difference</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">sort</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/sort.html" title="sort">sort</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">stable_partition</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/stable_partition.html" title="stable_partition">stable_partition</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">swap_ranges</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/swap_ranges.html" title="swap_ranges">swap_ranges</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">transform</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/transform.html" title="transform">transform</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">unique</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/unique.html" title="unique">unique</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">unique_copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/mutating/unique_copy.html" title="unique_copy">unique_copy</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">upper_bound</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/non_mutating/upper_bound.html" title="upper_bound">upper_bound</a>
</p>
</td>
</tr>
</tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="adaptors.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../library_headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithm_extensions.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,172 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Algorithm Extensions</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../library_headers.html" title="Library Headers">
<link rel="prev" href="algorithm.html" title="Algorithm">
<link rel="next" href="../examples.html" title="Examples">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="algorithm.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../library_headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.library_headers.algorithm_extensions"></a><a class="link" href="algorithm_extensions.html" title="Algorithm Extensions">Algorithm
Extensions</a>
</h3></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Header
</p>
</th>
<th>
<p>
Includes
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">copy_n</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/copy_n.html" title="copy_n">copy_n</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">erase</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/erase.html" title="erase">erase</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">for_each</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/for_each.html" title="for_each">for_each</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">insert</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/insert.html" title="insert">insert</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">iota</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/iota.html" title="iota">iota</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">is_sorted</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/is_sorted.html" title="is_sorted">is_sorted</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">overwrite</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/overwrite.html" title="overwrite">overwrite</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">push_back</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/push_back.html" title="push_back">push_back</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">/</span><span class="identifier">push_front</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/algorithms/new/push_front.html" title="push_front">push_front</a>
</p>
</td>
</tr>
</tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="algorithm.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../library_headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../examples.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,551 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>General</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../library_headers.html" title="Library Headers">
<link rel="prev" href="../library_headers.html" title="Library Headers">
<link rel="next" href="adaptors.html" title="Adaptors">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../library_headers.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../library_headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="adaptors.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.library_headers.general"></a><a class="link" href="general.html" title="General">General</a>
</h3></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Header
</p>
</th>
<th>
<p>
Includes
</p>
</th>
<th>
<p>
Related Concept
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
everything from Boost.Range version 1 (Boost versions 1.42 and
below). Includes the core range functions and metafunctinos, but
excludes Range Adaptors and Range Algorithms.
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">metafunctions</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every metafunction
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">functions</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every function
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">value_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_value</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">iterator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_iterator</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">difference_type</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_difference</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">pointer</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_pointer</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">category</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_category</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">reverse_iterator</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_reverse_iterator</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">begin</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">begin</span></code></a> and <a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_begin</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">end</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">end</span></code></a> and <a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_end</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">empty</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">empty</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">distance</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">distance</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">size</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">size</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">rbegin</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">rbegin</span></code></a> and <a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_rbegin</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">rend</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">rend</span></code></a> and <a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_rend</span></code></a>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">as_array</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">as_array</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">as_literal</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">as_literal</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">iterator_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/utilities/iterator_range.html" title="Class iterator_range"><code class="computeroutput"><span class="identifier">iterator_range</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">sub_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/utilities/sub_range.html" title="Class sub_range"><code class="computeroutput"><span class="identifier">sub_range</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">concepts</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts.html" title="Range Concepts">Range concepts</a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptors</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every range adaptor
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every range equivalent of an STL algorithm
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm_ext</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
every range algorithm that is an extension of the STL algorithms
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">counting_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/ranges/counting_range.html" title="counting_range"><code class="computeroutput"><span class="identifier">counting_range</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">istream_range</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/ranges/istream_range.html" title="istream_range"><code class="computeroutput"><span class="identifier">istream_range</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">irange</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/ranges/irange.html" title="irange"><code class="computeroutput"><span class="identifier">irange</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">join</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../reference/utilities/join.html" title="Function join"><code class="computeroutput"><span class="identifier">join</span></code></a>
</p>
</td>
<td>
<p>
-
</p>
</td>
</tr>
</tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../library_headers.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../library_headers.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="adaptors.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,141 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>MFC/ATL (courtesy of Shunsuke Sogame)</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="examples.html" title="Examples">
<link rel="next" href="mfc_atl/requirements.html" title="Requirements">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="examples.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mfc_atl/requirements.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.mfc_atl"></a><a class="link" href="mfc_atl.html" title="MFC/ATL (courtesy of Shunsuke Sogame)">MFC/ATL (courtesy of Shunsuke Sogame)</a>
</h2></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="mfc_atl/requirements.html">Requirements</a></span></dt>
<dt><span class="section"><a href="mfc_atl/mfc_ranges.html">MFC Ranges</a></span></dt>
<dt><span class="section"><a href="mfc_atl/atl_ranges.html">ATL Ranges</a></span></dt>
<dt><span class="section"><a href="mfc_atl/const_ranges.html">const Ranges</a></span></dt>
<dt><span class="section"><a href="mfc_atl/references.html">References</a></span></dt>
</dl></div>
<a name="range.mfc_atl.introduction"></a><h5>
<a name="id780286"></a>
<a class="link" href="mfc_atl.html#range.mfc_atl.introduction">Introduction</a>
</h5>
<p>
This implementation was kindly donated by Shunsuke Sogame. This header adapts
MFC and ATL containers to the appropriate Range concepts.
</p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr></tr></thead>
<tbody>
<tr>
<td>
<p>
<span class="bold"><strong>Author:</strong></span>
</p>
</td>
<td>
<p>
Shunsuke Sogame
</p>
</td>
</tr>
<tr>
<td>
<p>
<span class="bold"><strong>Contact:</strong></span>
</p>
</td>
<td>
<p>
mb2act@yahoo.co.jp
</p>
</td>
</tr>
<tr>
<td>
<p>
<span class="bold"><strong>Date:</strong></span>
</p>
</td>
<td>
<p>
26th of May 2006
</p>
</td>
</tr>
<tr>
<td>
<p>
<span class="bold"><strong>Copyright:</strong></span>
</p>
</td>
<td>
<p>
Shunsuke Sogame 2005-2006. Use, modification and distribution is
subject to the Boost Software License, Version 1.0
</p>
</td>
</tr>
</tbody>
</table></div>
<a name="range.mfc_atl.overview"></a><h5>
<a name="id780420"></a>
<a class="link" href="mfc_atl.html#range.mfc_atl.overview">Overview</a>
</h5>
<p>
Boost.Range MFC/ATL Extension provides Boost.Range support for MFC/ATL collection
and string types.
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">CTypedPtrArray</span><span class="special">&lt;</span><span class="identifier">CPtrArray</span><span class="special">,</span> <span class="identifier">CList</span><span class="special">&lt;</span><span class="identifier">CString</span><span class="special">&gt;</span> <span class="special">*&gt;</span> <span class="identifier">myArray</span><span class="special">;</span>
<span class="special">...</span>
<span class="identifier">BOOST_FOREACH</span> <span class="special">(</span><span class="identifier">CList</span><span class="special">&lt;</span><span class="identifier">CString</span><span class="special">&gt;</span> <span class="special">*</span><span class="identifier">theList</span><span class="special">,</span> <span class="identifier">myArray</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_FOREACH</span> <span class="special">(</span><span class="identifier">CString</span><span class="special">&amp;</span> <span class="identifier">str</span><span class="special">,</span> <span class="special">*</span><span class="identifier">theList</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">to_upper</span><span class="special">(</span><span class="identifier">str</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">sort</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">str</span><span class="special">),</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">str</span><span class="special">));</span>
<span class="special">...</span>
<span class="special">}</span>
<span class="special">}</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="examples.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mfc_atl/requirements.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,374 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>ATL Ranges</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mfc_atl.html" title="MFC/ATL (courtesy of Shunsuke Sogame)">
<link rel="prev" href="mfc_ranges.html" title="MFC Ranges">
<link rel="next" href="const_ranges.html" title="const Ranges">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mfc_ranges.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="const_ranges.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.mfc_atl.atl_ranges"></a><a class="link" href="atl_ranges.html" title="ATL Ranges">ATL Ranges</a>
</h3></div></div></div>
<p>
If the <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">atl</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span></code>
is included before or after Boost.Range headers, the ATL collections and
strings become models of Range. The table below lists the Traversal Category
and <code class="computeroutput"><span class="identifier">range_reference</span></code> of ATL
ranges.
</p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Range
</p>
</th>
<th>
<p>
Traversal Category
</p>
</th>
<th>
<p>
<code class="computeroutput"><span class="identifier">range_reference</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CAtlArray</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span><span class="identifier">ET</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">E</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CAutoPtrArray</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">E</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CInterfaceArray</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">,</span><span class="identifier">pi</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">CComQIPtr</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">,</span><span class="identifier">pi</span><span class="special">&gt;&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CAtlList</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span><span class="identifier">ET</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">E</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CAutoPtrList</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">E</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CHeapPtrList</span><span class="special">&lt;</span><span class="identifier">E</span><span class="special">,</span><span class="identifier">A</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">E</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CInterfaceList</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">,</span><span class="identifier">pi</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">CComQIPtr</span><span class="special">&lt;</span><span class="identifier">I</span><span class="special">,</span><span class="identifier">pi</span><span class="special">&gt;&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CAtlMap</span><span class="special">&lt;</span><span class="identifier">K</span><span class="special">,</span><span class="identifier">V</span><span class="special">,</span><span class="identifier">KT</span><span class="special">,</span><span class="identifier">VT</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Range</span><span class="special">::</span><span class="identifier">CPair</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CRBTree</span><span class="special">&lt;</span><span class="identifier">K</span><span class="special">,</span><span class="identifier">V</span><span class="special">,</span><span class="identifier">KT</span><span class="special">,</span><span class="identifier">VT</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Range</span><span class="special">::</span><span class="identifier">CPair</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CRBMap</span><span class="special">&lt;</span><span class="identifier">K</span><span class="special">,</span><span class="identifier">V</span><span class="special">,</span><span class="identifier">KT</span><span class="special">,</span><span class="identifier">VT</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Range</span><span class="special">::</span><span class="identifier">CPair</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CRBMultiMap</span><span class="special">&lt;</span><span class="identifier">K</span><span class="special">,</span><span class="identifier">V</span><span class="special">,</span><span class="identifier">KT</span><span class="special">,</span><span class="identifier">VT</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Range</span><span class="special">::</span><span class="identifier">CPair</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CSimpleStringT</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span><span class="identifier">b</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">B</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CStringT</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span><span class="identifier">ST</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">B</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CFixedStringT</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">,</span><span class="identifier">n</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">range_reference</span><span class="special">&lt;</span><span class="identifier">S</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CComBSTR</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">OLECHAR</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CSimpleArray</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">TE</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<p>
Other <a class="link" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">Boost.Range</a> metafunctions are defined
by the following. Let <code class="computeroutput"><span class="identifier">Range</span></code>
be any type listed above and <code class="computeroutput"><span class="identifier">Ref</span></code>
be the same as <code class="computeroutput"><span class="identifier">range_reference</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the same as <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">Ref</span><span class="special">&gt;::</span><span class="identifier">type</span></code>,
<code class="computeroutput"><span class="identifier">range_difference</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the same as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span></code>,
and <code class="computeroutput"><span class="identifier">range_pointer</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the same as <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">Ref</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
As for <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">Range</span></code>,
see below.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="mfc_ranges.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="const_ranges.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,125 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>const Ranges</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mfc_atl.html" title="MFC/ATL (courtesy of Shunsuke Sogame)">
<link rel="prev" href="atl_ranges.html" title="ATL Ranges">
<link rel="next" href="references.html" title="References">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="atl_ranges.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.mfc_atl.const_ranges"></a><a class="link" href="const_ranges.html" title="const Ranges">const Ranges</a>
</h3></div></div></div>
<p>
<code class="computeroutput"><span class="identifier">range_reference</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
is defined by the following algorithm. Let <code class="computeroutput"><span class="identifier">Range</span></code>
be any type listed above and <code class="computeroutput"><span class="identifier">Ref</span></code>
be the same as <code class="computeroutput"><span class="identifier">range_reference</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
</p>
<p>
</p>
<pre class="programlisting"><span class="keyword">if</span> <span class="special">(</span><span class="identifier">Range</span> <span class="identifier">is</span> <span class="identifier">CObArray</span> <span class="special">||</span> <span class="identifier">Range</span> <span class="identifier">is</span> <span class="identifier">CObList</span><span class="special">)</span>
<span class="keyword">return</span> <span class="identifier">CObject</span> <span class="keyword">const</span> <span class="special">*</span> <span class="special">&amp;</span>
<span class="keyword">else</span> <span class="keyword">if</span> <span class="special">(</span><span class="identifier">Range</span> <span class="identifier">is</span> <span class="identifier">CPtrArray</span> <span class="special">||</span> <span class="identifier">Range</span> <span class="identifier">is</span> <span class="identifier">CPtrList</span><span class="special">)</span>
<span class="keyword">return</span> <span class="keyword">void</span> <span class="keyword">const</span> <span class="special">*</span> <span class="special">&amp;</span>
<span class="keyword">else</span> <span class="keyword">if</span> <span class="special">(</span><span class="identifier">there</span> <span class="identifier">is</span> <span class="identifier">a</span> <span class="identifier">type</span> <span class="identifier">X</span> <span class="identifier">such</span> <span class="identifier">that</span> <span class="identifier">X</span><span class="special">&amp;</span> <span class="identifier">is</span> <span class="identifier">the</span> <span class="identifier">same</span> <span class="identifier">as</span> <span class="identifier">Ref</span><span class="special">)</span>
<span class="keyword">return</span> <span class="identifier">X</span> <span class="keyword">const</span> <span class="special">&amp;</span>
<span class="keyword">else</span> <span class="keyword">if</span> <span class="special">(</span><span class="identifier">there</span> <span class="identifier">is</span> <span class="identifier">a</span> <span class="identifier">type</span> <span class="identifier">X</span> <span class="identifier">such</span> <span class="identifier">that</span> <span class="identifier">X</span><span class="special">*</span> <span class="keyword">const</span> <span class="identifier">is</span> <span class="identifier">the</span> <span class="identifier">same</span> <span class="identifier">as</span> <span class="identifier">Ref</span><span class="special">)</span>
<span class="keyword">return</span> <span class="identifier">X</span> <span class="keyword">const</span> <span class="special">*</span> <span class="keyword">const</span>
<span class="keyword">else</span>
<span class="keyword">return</span> <span class="identifier">Ref</span>
</pre>
<p>
</p>
<p>
Other Boost.Range metafunctions are defined by the following.
</p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Range metafunction
</p>
</th>
<th>
<p>
Result
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">range_difference</span><span class="special">&lt;</span><span class="keyword">const</span>
<span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">range_pointer</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">range_reference</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="atl_ranges.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="references.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,480 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>MFC Ranges</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mfc_atl.html" title="MFC/ATL (courtesy of Shunsuke Sogame)">
<link rel="prev" href="requirements.html" title="Requirements">
<link rel="next" href="atl_ranges.html" title="ATL Ranges">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="requirements.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="atl_ranges.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.mfc_atl.mfc_ranges"></a><a class="link" href="mfc_ranges.html" title="MFC Ranges">MFC Ranges</a>
</h3></div></div></div>
<p>
If the <code class="computeroutput"><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</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>
is included before or after Boost.Range headers, the MFC collections and
strings become models of Range. The table below lists the Traversal Category
and <code class="computeroutput"><span class="identifier">range_reference</span></code> of MFC
ranges.
</p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Range
</p>
</th>
<th>
<p>
Traversal Category
</p>
</th>
<th>
<p>
<code class="computeroutput"><span class="identifier">range_reference</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CArray</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">A</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CList</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span><span class="identifier">A</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">T</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CMap</span><span class="special">&lt;</span><span class="identifier">K</span><span class="special">,</span><span class="identifier">AK</span><span class="special">,</span><span class="identifier">M</span><span class="special">,</span><span class="identifier">AM</span><span class="special">&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Range</span><span class="special">::</span><span class="identifier">CPair</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CTypedPtrArray</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span><span class="identifier">T</span><span class="special">*&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">T</span><span class="special">*</span>
<span class="keyword">const</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CTypedPtrList</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span><span class="identifier">T</span><span class="special">*&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">T</span><span class="special">*</span>
<span class="keyword">const</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CTypedPtrMap</span><span class="special">&lt;</span><span class="identifier">B</span><span class="special">,</span><span class="identifier">T</span><span class="special">*,</span><span class="identifier">V</span><span class="special">*&gt;</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">*,</span><span class="identifier">V</span><span class="special">*&gt;</span>
<span class="keyword">const</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CByteArray</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">BYTE</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CDWordArray</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">DWORD</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CObArray</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">CObject</span><span class="special">*&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CPtrArray</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span><span class="special">*&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CStringArray</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">CString</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CUIntArray</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">UINT</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CWordArray</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/random_access_range.html" title="Random Access Range">Random Access
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">WORD</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CObList</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">CObject</span><span class="special">*&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CPtrList</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="keyword">void</span><span class="special">*&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CStringList</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">CString</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CMapPtrToWord</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">*,</span><span class="identifier">WORD</span><span class="special">&gt;</span>
<span class="keyword">const</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CMapPtrToPtr</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="keyword">void</span><span class="special">*,</span><span class="keyword">void</span><span class="special">*&gt;</span>
<span class="keyword">const</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CMapStringToOb</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">String</span><span class="special">,</span><span class="identifier">CObject</span><span class="special">*&gt;</span>
<span class="keyword">const</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CMapStringToString</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">Range</span><span class="special">::</span><span class="identifier">CPair</span><span class="special">&amp;</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CMapWordToOb</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">WORD</span><span class="special">,</span><span class="identifier">CObject</span><span class="special">*&gt;</span>
<span class="keyword">const</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">CMapWordToPtr</span></code>
</p>
</td>
<td>
<p>
<a class="link" href="../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span><span class="special">&lt;</span><span class="identifier">WORD</span><span class="special">,</span><span class="keyword">void</span><span class="special">*&gt;</span>
<span class="keyword">const</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<p>
Other Boost.Range metafunctions are defined by the following. Let <code class="computeroutput"><span class="identifier">Range</span></code> be any type listed above and <code class="computeroutput"><span class="identifier">Ref</span></code> be the same as <code class="computeroutput"><span class="identifier">range_reference</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the same as <code class="computeroutput"><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">remove_const</span><span class="special">&lt;</span><span class="identifier">Ref</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span></code>,
<code class="computeroutput"><span class="identifier">range_difference</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the same as <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span></code>,
and <code class="computeroutput"><span class="identifier">range_pointer</span><span class="special">&lt;</span><span class="identifier">Range</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the same as <code class="computeroutput"><span class="identifier">add_pointer</span><span class="special">&lt;</span><span class="identifier">remove_reference</span><span class="special">&lt;</span><span class="identifier">Ref</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
As for <code class="computeroutput"><span class="keyword">const</span> <span class="identifier">Range</span></code>,
see below.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="requirements.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="atl_ranges.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,56 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>References</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mfc_atl.html" title="MFC/ATL (courtesy of Shunsuke Sogame)">
<link rel="prev" href="const_ranges.html" title="const Ranges">
<link rel="next" href="../upgrade.html" title="Upgrade version of Boost.Range">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="const_ranges.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../upgrade.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.mfc_atl.references"></a><a class="link" href="references.html" title="References">References</a>
</h3></div></div></div>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
<a class="link" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">Boost.Range</a>
</li>
<li class="listitem">
<a href="http://msdn.microsoft.com/en-us/library/942860sh.aspx" target="_top">MFC
Collection Classes</a>
</li>
<li class="listitem">
<a href="http://msdn.microsoft.com/en-us/library/15e672bd.aspx" target="_top">ATL
Collection Classes</a>
</li>
</ol></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="const_ranges.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../upgrade.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,51 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Requirements</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mfc_atl.html" title="MFC/ATL (courtesy of Shunsuke Sogame)">
<link rel="prev" href="../mfc_atl.html" title="MFC/ATL (courtesy of Shunsuke Sogame)">
<link rel="next" href="mfc_ranges.html" title="MFC Ranges">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mfc_ranges.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.mfc_atl.requirements"></a><a class="link" href="requirements.html" title="Requirements">Requirements</a>
</h3></div></div></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
Boost C++ Libraries Version 1.34.0 or later (no compilation required)
</li>
<li class="listitem">
Visual C++ 7.1 or later (for MFC and ATL)
</li>
</ul></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mfc_atl.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mfc_ranges.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,93 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Portability</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="upgrade/upgrade_from_1_34.html" title="Upgrade from version 1.34">
<link rel="next" href="faq.html" title="FAQ">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="upgrade/upgrade_from_1_34.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="faq.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.portability"></a><a class="link" href="portability.html" title="Portability">Portability</a>
</h2></div></div></div>
<p>
A huge effort has been made to port the library to as many compilers as possible.
</p>
<p>
Full support for built-in arrays require that the compiler supports class template
partial specialization. For non-conforming compilers there might be a chance
that it works anyway thanks to workarounds in the type traits library. Visual
C++ 6/7.0 has a limited support for arrays: as long as the arrays are of built-in
type it should work.
</p>
<p>
Notice also that some compilers cannot do function template ordering properly.
In that case one must rely of <a class="link" href="reference/concept_implementation/semantics/metafunctions.html" title="Metafunctions"><code class="computeroutput"><span class="identifier">range_iterator</span></code></a> and a single function
definition instead of overloaded versions for const and non-const arguments.
So if one cares about old compilers, one should not pass rvalues to the functions.
</p>
<p>
For maximum portability you should follow these guidelines:
</p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
do not use built-in arrays,
</li>
<li class="listitem">
do not pass rvalues to <a class="link" href="reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">begin</span></code></a><code class="computeroutput"><span class="special">()</span></code>,
<a class="link" href="reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">end</span></code></a><code class="computeroutput"><span class="special">()</span></code>
and <a class="link" href="reference/utilities/iterator_range.html" title="Class iterator_range"><code class="computeroutput"><span class="identifier">iterator_range</span></code></a> Range constructors
and assignment operators,
</li>
<li class="listitem">
use <a class="link" href="reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_begin</span></code></a><code class="computeroutput"><span class="special">()</span></code>
and <a class="link" href="reference/concept_implementation/semantics/functions.html" title="Functions"><code class="computeroutput"><span class="identifier">const_end</span></code></a><code class="computeroutput"><span class="special">()</span></code>
whenever your code by intention is read-only; this will also solve most
rvalue problems,
</li>
<li class="listitem">
<p class="simpara">
do not rely on ADL:
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
if you overload functions, include that header before the headers in
this library,
</li>
<li class="listitem">
put all overloads in namespace boost.
</li>
</ul></div>
</li>
</ol></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="upgrade/upgrade_from_1_34.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="faq.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,96 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Reference</title>
<link rel="stylesheet" href="../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="prev" href="concepts/concept_checking.html" title="Concept Checking">
<link rel="next" href="reference/overview.html" title="Overview">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../boost.png"></td>
<td align="center"><a href="../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="concepts/concept_checking.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference/overview.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h2 class="title" style="clear: both">
<a name="range.reference"></a><a class="link" href="reference.html" title="Reference">Reference</a>
</h2></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="reference/overview.html">Overview</a></span></dt>
<dt><span class="section"><a href="reference/concept_implementation.html">Range concept
implementation</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="reference/concept_implementation/synopsis.html">Synopsis</a></span></dt>
<dt><span class="section"><a href="reference/concept_implementation/semantics.html">Semantics</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="reference/adaptors.html">Range Adaptors</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="reference/adaptors/introduction.html">Introduction
and motivation</a></span></dt>
<dt><span class="section"><a href="reference/adaptors/general_requirements.html">General
Requirements</a></span></dt>
<dt><span class="section"><a href="reference/adaptors/reference.html">Reference</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="reference/algorithms.html">Range Algorithms</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="reference/algorithms/introduction.html">Introduction
and motivation</a></span></dt>
<dt><span class="section"><a href="reference/algorithms/mutating.html">Mutating algorithms</a></span></dt>
<dt><span class="section"><a href="reference/algorithms/non_mutating.html">Non-mutating
algorithms</a></span></dt>
<dt><span class="section"><a href="reference/algorithms/set.html">Set algorithms</a></span></dt>
<dt><span class="section"><a href="reference/algorithms/heap.html">Heap algorithms</a></span></dt>
<dt><span class="section"><a href="reference/algorithms/permutation.html">Permutation
algorithms</a></span></dt>
<dt><span class="section"><a href="reference/algorithms/new.html">New algorithms</a></span></dt>
<dt><span class="section"><a href="reference/algorithms/numeric.html">Numeric algorithms</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="reference/ranges.html">Provided Ranges</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="reference/ranges/any_range.html">any_range</a></span></dt>
<dt><span class="section"><a href="reference/ranges/counting_range.html">counting_range</a></span></dt>
<dt><span class="section"><a href="reference/ranges/istream_range.html">istream_range</a></span></dt>
<dt><span class="section"><a href="reference/ranges/irange.html">irange</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="reference/utilities.html">Utilities</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="reference/utilities/iterator_range.html">Class <code class="computeroutput"><span class="identifier">iterator_range</span></code></a></span></dt>
<dt><span class="section"><a href="reference/utilities/sub_range.html">Class <code class="computeroutput"><span class="identifier">sub_range</span></code></a></span></dt>
<dt><span class="section"><a href="reference/utilities/join.html">Function join</a></span></dt>
</dl></dd>
<dt><span class="section"><a href="reference/extending.html">Extending the library</a></span></dt>
<dd><dl>
<dt><span class="section"><a href="reference/extending/method_1.html">Method 1: provide
member functions and nested types</a></span></dt>
<dt><span class="section"><a href="reference/extending/method_2.html">Method 2: provide
free-standing functions and specialize metafunctions</a></span></dt>
<dt><span class="section"><a href="reference/extending/method_3.html">Method 3: provide
range adaptor implementations</a></span></dt>
</dl></dd>
</dl></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="concepts/concept_checking.html"><img src="../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../index.html"><img src="../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../index.html"><img src="../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference/overview.html"><img src="../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,50 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Range Adaptors</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="concept_implementation/semantics/functions.html" title="Functions">
<link rel="next" href="adaptors/introduction.html" title="Introduction and motivation">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="concept_implementation/semantics/functions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="adaptors/introduction.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.reference.adaptors"></a><a class="link" href="adaptors.html" title="Range Adaptors">Range Adaptors</a>
</h3></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="adaptors/introduction.html">Introduction
and motivation</a></span></dt>
<dt><span class="section"><a href="adaptors/general_requirements.html">General
Requirements</a></span></dt>
<dt><span class="section"><a href="adaptors/reference.html">Reference</a></span></dt>
</dl></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="concept_implementation/semantics/functions.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="adaptors/introduction.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,141 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>General Requirements</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../adaptors.html" title="Range Adaptors">
<link rel="prev" href="introduction.html" title="Introduction and motivation">
<link rel="next" href="reference.html" title="Reference">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="introduction.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../adaptors.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="range.reference.adaptors.general_requirements"></a><a class="link" href="general_requirements.html" title="General Requirements">General
Requirements</a>
</h4></div></div></div>
<p>
In the description of generator expressions, the following notation is
used:
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">fwdRng</span></code> is an expression
of a type <code class="computeroutput"><span class="identifier">R</span></code> that models
<code class="computeroutput"><span class="identifier">ForwardRange</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">biRng</span></code> is an expression
of a type <code class="computeroutput"><span class="identifier">R</span></code> that models
<code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">rndRng</span></code> is an expression
of a type <code class="computeroutput"><span class="identifier">R</span></code> that models
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">pred</span></code> is an expression
of a type that models <code class="computeroutput"><span class="identifier">UnaryPredicate</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">bi_pred</span></code> is an expression
of a type that models <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">fun</span></code> is an expression
of a type that models <code class="computeroutput"><span class="identifier">UnaryFunction</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">value</span></code>, <code class="computeroutput"><span class="identifier">new_value</span></code> and <code class="computeroutput"><span class="identifier">old_value</span></code>
are objects convertible to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">n</span><span class="special">,</span><span class="identifier">m</span></code> are integer expressions convertible
to <code class="computeroutput"><span class="identifier">range_difference</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</li>
</ul></div>
<p>
Also note that <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">R</span><span class="special">&gt;::</span><span class="identifier">type</span></code> must be implicitly convertible to
the type arguments to <code class="computeroutput"><span class="identifier">pred</span></code>,
<code class="computeroutput"><span class="identifier">bi_pred</span></code> and <code class="computeroutput"><span class="identifier">fun</span></code>.
</p>
<p>
Range Category in the following adaptor descriptions refers to the minimum
range concept required by the range passed to the adaptor. The resultant
range is a model of the same range concept as the input range unless specified
otherwise.
</p>
<p>
Returned Range Category is the concept of the returned range. In some cases
the returned range is of a lesser category than the range passed to the
adaptor. For example, the <code class="computeroutput"><span class="identifier">filtered</span></code>
adaptor returns only a <code class="computeroutput"><span class="identifier">ForwardRange</span></code>
regardless of the input.
</p>
<p>
Furthermore, the following rules apply to any expression of the form
</p>
<pre class="programlisting"><span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">adaptor_generator</span>
</pre>
<p>
</p>
<p>
1. Applying <code class="computeroutput"><span class="keyword">operator</span><span class="special">|()</span></code>
to a range <code class="computeroutput"><span class="identifier">R</span></code> (always left
argument) and a range adapter <code class="computeroutput"><span class="identifier">RA</span></code>
(always right argument) yields a new range type which may not conform to
the same range concept as <code class="computeroutput"><span class="identifier">R</span></code>.
</p>
<p>
2. The return-type of <code class="computeroutput"><span class="keyword">operator</span><span class="special">|()</span></code> is otherwise unspecified.
</p>
<p>
3. <code class="computeroutput"><span class="keyword">operator</span><span class="special">|()</span></code>
is found by Argument Dependent Lookup (ADL) because a range adaptor is
implemented in namespace <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span></code>.
</p>
<p>
4. <code class="computeroutput"><span class="keyword">operator</span><span class="special">|()</span></code>
is used to add new behaviour <span class="emphasis"><em><span class="bold"><strong>lazily</strong></span></em></span>
and never modifies its left argument.
</p>
<p>
5. All iterators extracted from the left argument are extracted using qualified
calls to <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">()</span></code>
and <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">()</span></code>.
</p>
<p>
6. In addition to the <code class="computeroutput"><span class="keyword">throw</span></code>-clauses
below, <code class="computeroutput"><span class="keyword">operator</span><span class="special">|()</span></code>
may throw exceptions as a result of copying iterators. If such copying
cannot throw an exception, then neither can the whole expression.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="introduction.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../adaptors.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,284 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Introduction and motivation</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../adaptors.html" title="Range Adaptors">
<link rel="prev" href="../adaptors.html" title="Range Adaptors">
<link rel="next" href="general_requirements.html" title="General Requirements">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../adaptors.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../adaptors.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="general_requirements.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="range.reference.adaptors.introduction"></a><a class="link" href="introduction.html" title="Introduction and motivation">Introduction
and motivation</a>
</h4></div></div></div>
<p>
A <span class="bold"><strong>Range Adaptor</strong></span> is a class that wraps
an existing Range to provide a new Range with different behaviour. Since
the behaviour of Ranges is determined by their associated iterators, a
Range Adaptor simply wraps the underlying iterators with new special iterators.
In this example
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptors</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">vec</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">vec</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reversed</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
the iterators from <code class="computeroutput"><span class="identifier">vec</span></code>
are wrapped <code class="computeroutput"><span class="identifier">reverse_iterator</span></code>s.
The type of the underlying Range Adapter is not documented because you
do not need to know it. All that is relevant is that the expression
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">vec</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reversed</span>
</pre>
<p>
</p>
<p>
returns a Range Adaptor where the iterator type is now the iterator type
of the range <code class="computeroutput"><span class="identifier">vec</span></code> wrapped
in <code class="computeroutput"><span class="identifier">reverse_iterator</span></code>. The
expression <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reversed</span></code> is called an <span class="bold"><strong>Adaptor
Generator</strong></span>.
</p>
<p>
There are two ways of constructing a range adaptor. The first is by using
<code class="computeroutput"><span class="keyword">operator</span><span class="special">|()</span></code>.
This is my preferred technique, however while discussing range adaptors
with others it became clear that some users of the library strongly prefer
a more familiar function syntax, so equivalent functions of the present
tense form have been added as an alternative syntax. The equivalent to
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">reversed</span></code> is <code class="computeroutput"><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reverse</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> for example.
</p>
<p>
Why do I prefer the <code class="computeroutput"><span class="keyword">operator</span><span class="special">|</span></code> syntax? The answer is readability:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">vec</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reverse</span><span class="special">(</span><span class="identifier">vec</span><span class="special">),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
This might not look so bad, but when we apply several adaptors, it becomes
much worse. Just compare
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">vec</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">unique</span><span class="special">(</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reverse</span><span class="special">(</span> <span class="identifier">vec</span> <span class="special">)</span> <span class="special">),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
to
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">vec</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">vec</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reversed</span>
<span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">uniqued</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">)</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
Furthermore, some of the adaptor generators take arguments themselves and
these arguments are expressed with function call notation too. In those
situations, you will really appreciate the succinctness of <code class="computeroutput"><span class="keyword">operator</span><span class="special">|()</span></code>.
</p>
<a name="range.reference.adaptors.introduction.composition_of_adaptors"></a><h6>
<a name="id659630"></a>
<a class="link" href="introduction.html#range.reference.adaptors.introduction.composition_of_adaptors">Composition
of Adaptors</a>
</h6>
<p>
Range Adaptors are a powerful complement to Range algorithms. The reason
is that adaptors are <span class="emphasis"><em><span class="bold"><strong>orthogonal</strong></span></em></span>
to algorithms. For example, consider these Range algorithms:
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">count</span><span class="special">(</span>
<span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">pred</span> <span class="special">)</span></code>
</li>
</ul></div>
<p>
What should we do if we only want to copy an element <code class="computeroutput"><span class="identifier">a</span></code>
if it satisfies some predicate, say <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">a</span><span class="special">)</span></code>?
And what if we only want to count the elements that satisfy the same predicate?
The naive answer would be to use these algorithms:
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy_if</span><span class="special">(</span>
<span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">pred</span><span class="special">,</span>
<span class="identifier">out</span> <span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">count_if</span><span class="special">(</span>
<span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">pred</span> <span class="special">)</span></code>
</li>
</ul></div>
<p>
These algorithms are only defined to maintain a one to one relationship
with the standard library algorithms. This approach of adding algorithm
suffers a combinatorial explosion. Inevitably many algorithms are missing
<code class="computeroutput"><span class="identifier">_if</span></code> variants and there
is redundant development overhead for each new algorithm. The Adaptor Generator
is the design solution to this problem.
</p>
<a name="range.reference.adaptors.introduction.range_adaptor_alternative_to_copy_if_algorithm"></a><h6>
<a name="id659939"></a>
<a class="link" href="introduction.html#range.reference.adaptors.introduction.range_adaptor_alternative_to_copy_if_algorithm">Range
Adaptor alternative to copy_if algorithm</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy_if</span><span class="special">(</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">pred</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">);</span>
</pre>
<p>
can be expressed as
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span> <span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">filtered</span><span class="special">(</span><span class="identifier">pred</span><span class="special">),</span> <span class="identifier">out</span> <span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.adaptors.introduction.range_adaptor_alternative_to_count_if_algorithm"></a><h6>
<a name="id660104"></a>
<a class="link" href="introduction.html#range.reference.adaptors.introduction.range_adaptor_alternative_to_count_if_algorithm">Range
Adaptor alternative to count_if algorithm</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">count_if</span><span class="special">(</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">pred</span> <span class="special">);</span>
</pre>
<p>
can be expressed as
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">count</span><span class="special">(</span> <span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">filtered</span><span class="special">(</span><span class="identifier">pred</span><span class="special">),</span> <span class="identifier">out</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
What this means is that <span class="emphasis"><em><span class="bold"><strong>no</strong></span></em></span>
algorithm with the <code class="computeroutput"><span class="identifier">_if</span></code>
suffix is needed. Furthermore, it turns out that algorithms with the <code class="computeroutput"><span class="identifier">_copy</span></code> suffix are not needed either. Consider
the somewhat misdesigned <code class="computeroutput"><span class="identifier">replace_copy_if</span><span class="special">()</span></code> which may be used as
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">vec</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">replace_copy_if</span><span class="special">(</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">back_inserter</span><span class="special">(</span><span class="identifier">vec</span><span class="special">),</span> <span class="identifier">pred</span> <span class="special">);</span>
</pre>
<p>
</p>
<p>
With adaptors and algorithms we can express this as
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">vec</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">vec</span><span class="special">,</span> <span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">replaced_if</span><span class="special">(</span><span class="identifier">pred</span><span class="special">,</span> <span class="identifier">new_value</span><span class="special">));</span>
</pre>
<p>
</p>
<p>
The latter code has several benefits:
</p>
<p>
1. it is more <span class="emphasis"><em><span class="bold"><strong>efficient</strong></span></em></span>
because we avoid extra allocations as might happen with <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">back_inserter</span></code>
</p>
<p>
2. it is <span class="emphasis"><em><span class="bold"><strong>flexible</strong></span></em></span>
as we can subsequently apply even more adaptors, for example:
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">vec</span><span class="special">,</span> <span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">replaced_if</span><span class="special">(</span><span class="identifier">pred</span><span class="special">,</span> <span class="identifier">new_value</span><span class="special">)</span>
<span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reversed</span><span class="special">);</span>
</pre>
<p>
</p>
<p>
3. it is <span class="emphasis"><em><span class="bold"><strong>safer</strong></span></em></span> because
there is no use of an unbounded output iterator.
</p>
<p>
In this manner, the <span class="emphasis"><em><span class="bold"><strong>composition</strong></span></em></span>
of Range Adaptors has the following consequences:
</p>
<p>
1. we no longer need <code class="computeroutput"><span class="identifier">_if</span></code>,
<code class="computeroutput"><span class="identifier">_copy</span></code>, <code class="computeroutput"><span class="identifier">_copy_if</span></code>
and <code class="computeroutput"><span class="identifier">_n</span></code> variants of algorithms.
</p>
<p>
2. we can generate a multitude of new algorithms on the fly, for example,
above we generated <code class="computeroutput"><span class="identifier">reverse_replace_copy_if</span><span class="special">()</span></code>
</p>
<p>
In other words:
</p>
<p>
<span class="bold"><strong>Range Adaptors are to algorithms what algorithms
are to containers</strong></span>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../adaptors.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../adaptors.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="general_requirements.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,61 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Reference</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../adaptors.html" title="Range Adaptors">
<link rel="prev" href="general_requirements.html" title="General Requirements">
<link rel="next" href="reference/adjacent_filtered.html" title="adjacent_filtered">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="general_requirements.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../adaptors.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference/adjacent_filtered.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="range.reference.adaptors.reference"></a><a class="link" href="reference.html" title="Reference">Reference</a>
</h4></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="reference/adjacent_filtered.html">adjacent_filtered</a></span></dt>
<dt><span class="section"><a href="reference/copied.html">copied</a></span></dt>
<dt><span class="section"><a href="reference/filtered.html">filtered</a></span></dt>
<dt><span class="section"><a href="reference/indexed.html">indexed</a></span></dt>
<dt><span class="section"><a href="reference/indirected.html">indirected</a></span></dt>
<dt><span class="section"><a href="reference/map_keys.html">map_keys</a></span></dt>
<dt><span class="section"><a href="reference/map_values.html">map_values</a></span></dt>
<dt><span class="section"><a href="reference/replaced.html">replaced</a></span></dt>
<dt><span class="section"><a href="reference/replaced_if.html">replaced_if</a></span></dt>
<dt><span class="section"><a href="reference/reversed.html">reversed</a></span></dt>
<dt><span class="section"><a href="reference/sliced.html">sliced</a></span></dt>
<dt><span class="section"><a href="reference/strided.html">strided</a></span></dt>
<dt><span class="section"><a href="reference/type_erased.html">type_erased</a></span></dt>
<dt><span class="section"><a href="reference/tokenized.html">tokenized</a></span></dt>
<dt><span class="section"><a href="reference/transformed.html">transformed</a></span></dt>
<dt><span class="section"><a href="reference/uniqued.html">uniqued</a></span></dt>
</dl></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="general_requirements.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../adaptors.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reference/adjacent_filtered.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,160 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>adjacent_filtered</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="../reference.html" title="Reference">
<link rel="next" href="copied.html" title="copied">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../reference.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="copied.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.adjacent_filtered"></a><a class="link" href="adjacent_filtered.html" title="adjacent_filtered">adjacent_filtered</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="adjacent_filtered.html#range.reference.adaptors.reference.adjacent_filtered.adjacent_filtered_example">adjacent_filtered
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">adjacent_filtered</span><span class="special">(</span><span class="identifier">bi_pred</span><span class="special">)</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">adjacent_filter</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">bi_pred</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> The <code class="computeroutput"><span class="identifier">value_type</span></code> of the range is convertible
to both argument types of <code class="computeroutput"><span class="identifier">bi_pred</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Postcondition:</strong></span> For all adjacent
elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code> in the returned range, <code class="computeroutput"><span class="identifier">bi_pred</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">)</span></code>
is <code class="computeroutput"><span class="keyword">true</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Throws:</strong></span> Whatever the copy constructor
of <code class="computeroutput"><span class="identifier">bi_pred</span></code> might
throw.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adjacent_filtered_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The minimum
of the range category of <code class="computeroutput"><span class="identifier">rng</span></code>
and <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward Range</a>
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.adjacent_filtered.adjacent_filtered_example"></a><a class="link" href="adjacent_filtered.html#range.reference.adaptors.reference.adjacent_filtered.adjacent_filtered_example" title="adjacent_filtered example">adjacent_filtered
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">adjacent_filtered</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">functional</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">adjacent_filtered</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">not_equal_to</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;()),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../reference.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="copied.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,156 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>copied</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="adjacent_filtered.html" title="adjacent_filtered">
<link rel="next" href="filtered.html" title="filtered">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="adjacent_filtered.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="filtered.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.copied"></a><a class="link" href="copied.html" title="copied">copied</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="copied.html#range.reference.adaptors.reference.copied.copied_example">copied
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">copied</span><span class="special">(</span><span class="identifier">n</span><span class="special">,</span>
<span class="identifier">m</span><span class="special">)</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">n</span><span class="special">,</span>
<span class="identifier">m</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> <code class="computeroutput"><span class="number">0</span>
<span class="special">&lt;=</span> <span class="identifier">n</span>
<span class="special">&amp;&amp;</span> <span class="identifier">n</span>
<span class="special">&lt;=</span> <span class="identifier">m</span>
<span class="special">&amp;&amp;</span> <span class="identifier">m</span>
<span class="special">&lt;</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returns:</strong></span> A new <code class="computeroutput"><span class="identifier">iterator_range</span></code>
that holds the sliced range <code class="computeroutput"><span class="special">[</span><span class="identifier">n</span><span class="special">,</span><span class="identifier">m</span><span class="special">)</span></code>
of the original range.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a>
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.copied.copied_example"></a><a class="link" href="copied.html#range.reference.adaptors.reference.copied.copied_example" title="copied example">copied
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">copied</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span><span class="special">,</span><span class="number">10</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">copied</span><span class="special">(</span><span class="number">1</span><span class="special">,</span> <span class="number">5</span><span class="special">),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="adjacent_filtered.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="filtered.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,162 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>filtered</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="copied.html" title="copied">
<link rel="next" href="indexed.html" title="indexed">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="copied.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="indexed.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.filtered"></a><a class="link" href="filtered.html" title="filtered">filtered</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="filtered.html#range.reference.adaptors.reference.filtered.filtered_example">filtered
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">filtered</span><span class="special">(</span><span class="identifier">pred</span><span class="special">)</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">filter</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">pred</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> The <code class="computeroutput"><span class="identifier">value_type</span></code> of the range is convertible
to the argument type of <code class="computeroutput"><span class="identifier">pred</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Postcondition:</strong></span> For all adjacent
elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">]</span></code> in the returned range, <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
is <code class="computeroutput"><span class="keyword">true</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Throws:</strong></span> Whatever the copy constructor
of <code class="computeroutput"><span class="identifier">pred</span></code> might throw.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">filtered_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The minimum
of the range category of <code class="computeroutput"><span class="identifier">rng</span></code>
and <a class="link" href="../../../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.filtered.filtered_example"></a><a class="link" href="filtered.html#range.reference.adaptors.reference.filtered.filtered_example" title="filtered example">filtered
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">filtered</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_even</span>
<span class="special">{</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">()(</span> <span class="keyword">int</span> <span class="identifier">x</span> <span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">x</span> <span class="special">%</span> <span class="number">2</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">filtered</span><span class="special">(</span><span class="identifier">is_even</span><span class="special">()),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">2</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">8</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="copied.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="indexed.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,193 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>indexed</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="filtered.html" title="filtered">
<link rel="next" href="indirected.html" title="indirected">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="filtered.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="indirected.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.indexed"></a><a class="link" href="indexed.html" title="indexed">indexed</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="indexed.html#range.reference.adaptors.reference.indexed.indexed_example">indexed
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">indexed</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">index</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Returns:</strong></span> A range adapted to return
both the element and the associated index. The returned range consists
of iterators that have in addition to the usual iterator member functions
an <code class="computeroutput"><span class="identifier">index</span><span class="special">()</span></code>
member function that returns the appropriate index for the element
in the sequence corresponding with the iterator.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">indexed_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The range
category of <code class="computeroutput"><span class="identifier">rng</span></code>
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.indexed.indexed_example"></a><a class="link" href="indexed.html#range.reference.adaptors.reference.indexed.indexed_example" title="indexed example">indexed
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">indexed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Iterator</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">display_element_and_index</span><span class="special">(</span><span class="identifier">Iterator</span> <span class="identifier">first</span><span class="special">,</span> <span class="identifier">Iterator</span> <span class="identifier">last</span><span class="special">)</span>
<span class="special">{</span>
<span class="keyword">for</span> <span class="special">(</span><span class="identifier">Iterator</span> <span class="identifier">it</span> <span class="special">=</span> <span class="identifier">first</span><span class="special">;</span> <span class="identifier">it</span> <span class="special">!=</span> <span class="identifier">last</span><span class="special">;</span> <span class="special">++</span><span class="identifier">it</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"Element = "</span> <span class="special">&lt;&lt;</span> <span class="special">*</span><span class="identifier">it</span> <span class="special">&lt;&lt;</span> <span class="string">" Index = "</span> <span class="special">&lt;&lt;</span> <span class="identifier">it</span><span class="special">.</span><span class="identifier">index</span><span class="special">()</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">SinglePassRange</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">display_element_and_index</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">SinglePassRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">display_element_and_index</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">));</span>
<span class="special">}</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Iterator1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Iterator2</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">check_element_and_index</span><span class="special">(</span>
<span class="identifier">Iterator1</span> <span class="identifier">test_first</span><span class="special">,</span>
<span class="identifier">Iterator1</span> <span class="identifier">test_last</span><span class="special">,</span>
<span class="identifier">Iterator2</span> <span class="identifier">reference_first</span><span class="special">,</span>
<span class="identifier">Iterator2</span> <span class="identifier">reference_last</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">test_first</span><span class="special">,</span> <span class="identifier">test_last</span><span class="special">),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">reference_first</span><span class="special">,</span> <span class="identifier">reference_last</span><span class="special">)</span> <span class="special">);</span>
<span class="keyword">int</span> <span class="identifier">reference_index</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span>
<span class="identifier">Iterator1</span> <span class="identifier">test_it</span> <span class="special">=</span> <span class="identifier">test_first</span><span class="special">;</span>
<span class="identifier">Iterator2</span> <span class="identifier">reference_it</span> <span class="special">=</span> <span class="identifier">reference_first</span><span class="special">;</span>
<span class="keyword">for</span> <span class="special">(;</span> <span class="identifier">test_it</span> <span class="special">!=</span> <span class="identifier">test_last</span><span class="special">;</span> <span class="special">++</span><span class="identifier">test_it</span><span class="special">,</span> <span class="special">++</span><span class="identifier">reference_it</span><span class="special">,</span> <span class="special">++</span><span class="identifier">reference_index</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span> <span class="special">*</span><span class="identifier">test_it</span><span class="special">,</span> <span class="special">*</span><span class="identifier">reference_it</span> <span class="special">);</span>
<span class="identifier">BOOST_CHECK_EQUAL</span><span class="special">(</span> <span class="identifier">test_it</span><span class="special">.</span><span class="identifier">index</span><span class="special">(),</span> <span class="identifier">reference_index</span> <span class="special">);</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">10</span><span class="special">,</span><span class="number">20</span><span class="special">,</span><span class="number">30</span><span class="special">,</span><span class="number">40</span><span class="special">,</span><span class="number">50</span><span class="special">,</span><span class="number">60</span><span class="special">,</span><span class="number">70</span><span class="special">,</span><span class="number">80</span><span class="special">,</span><span class="number">90</span><span class="special">;</span>
<span class="identifier">display_element_and_index</span><span class="special">(</span> <span class="identifier">input</span> <span class="special">|</span> <span class="identifier">indexed</span><span class="special">(</span><span class="number">0</span><span class="special">)</span> <span class="special">);</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="identifier">Element</span> <span class="special">=</span> <span class="number">10</span> <span class="identifier">Index</span> <span class="special">=</span> <span class="number">0</span>
<span class="identifier">Element</span> <span class="special">=</span> <span class="number">20</span> <span class="identifier">Index</span> <span class="special">=</span> <span class="number">1</span>
<span class="identifier">Element</span> <span class="special">=</span> <span class="number">30</span> <span class="identifier">Index</span> <span class="special">=</span> <span class="number">2</span>
<span class="identifier">Element</span> <span class="special">=</span> <span class="number">40</span> <span class="identifier">Index</span> <span class="special">=</span> <span class="number">3</span>
<span class="identifier">Element</span> <span class="special">=</span> <span class="number">50</span> <span class="identifier">Index</span> <span class="special">=</span> <span class="number">4</span>
<span class="identifier">Element</span> <span class="special">=</span> <span class="number">60</span> <span class="identifier">Index</span> <span class="special">=</span> <span class="number">5</span>
<span class="identifier">Element</span> <span class="special">=</span> <span class="number">70</span> <span class="identifier">Index</span> <span class="special">=</span> <span class="number">6</span>
<span class="identifier">Element</span> <span class="special">=</span> <span class="number">80</span> <span class="identifier">Index</span> <span class="special">=</span> <span class="number">7</span>
<span class="identifier">Element</span> <span class="special">=</span> <span class="number">90</span> <span class="identifier">Index</span> <span class="special">=</span> <span class="number">8</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="filtered.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="indirected.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,156 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>indirected</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="indexed.html" title="indexed">
<link rel="next" href="map_keys.html" title="map_keys">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="indexed.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="map_keys.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.indirected"></a><a class="link" href="indirected.html" title="indirected">indirected</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="indirected.html#range.reference.adaptors.reference.indirected.indirected_example">indirected
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">indirected</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">indirect</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> The <code class="computeroutput"><span class="identifier">value_type</span></code> of the range defines
unary <code class="computeroutput"><span class="keyword">operator</span><span class="special">*()</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Postcondition:</strong></span> For all elements
<code class="computeroutput"><span class="identifier">x</span></code> in the returned
range, <code class="computeroutput"><span class="identifier">x</span></code> is the result
of <code class="computeroutput"><span class="special">*</span><span class="identifier">y</span></code>
where <code class="computeroutput"><span class="identifier">y</span></code> is the corresponding
element in the original range.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">indirected_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The range
category of <code class="computeroutput"><span class="identifier">rng</span></code>
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.indirected.indirected_example"></a><a class="link" href="indirected.html#range.reference.adaptors.reference.indirected.indirected_example" title="indirected example">indirected
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">indirected</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">shared_ptr</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="keyword">for</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
<span class="identifier">input</span><span class="special">.</span><span class="identifier">push_back</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">shared_ptr</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="keyword">new</span> <span class="keyword">int</span><span class="special">(</span><span class="identifier">i</span><span class="special">)));</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">indirected</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">0</span><span class="special">,</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="indexed.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="map_keys.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,156 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>map_keys</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="indirected.html" title="indirected">
<link rel="next" href="map_values.html" title="map_values">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="indirected.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="map_values.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.map_keys"></a><a class="link" href="map_keys.html" title="map_keys">map_keys</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="map_keys.html#range.reference.adaptors.reference.map_keys.map_keys_example">map_keys
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">map_keys</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">keys</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> The <code class="computeroutput"><span class="identifier">value_type</span></code> of the range is an instantiation
of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Postcondition:</strong></span> For all elements
<code class="computeroutput"><span class="identifier">x</span></code> in the returned
range, <code class="computeroutput"><span class="identifier">x</span></code> is the result
of <code class="computeroutput"><span class="identifier">y</span><span class="special">.</span><span class="identifier">first</span></code> where <code class="computeroutput"><span class="identifier">y</span></code>
is the corresponding element in the original range.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">select_first_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The range
category of <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.map_keys.map_keys_example"></a><a class="link" href="map_keys.html#range.reference.adaptors.reference.map_keys.map_keys_example" title="map_keys example">map_keys
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">map</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">map</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="keyword">for</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
<span class="identifier">input</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">make_pair</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">i</span> <span class="special">*</span> <span class="number">10</span><span class="special">));</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">map_keys</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">0</span><span class="special">,</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="indirected.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="map_values.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,158 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>map_values</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="map_keys.html" title="map_keys">
<link rel="next" href="replaced.html" title="replaced">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="map_keys.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replaced.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.map_values"></a><a class="link" href="map_values.html" title="map_values">map_values</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="map_values.html#range.reference.adaptors.reference.map_values.map_values_example">map_values
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">map_values</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">values</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> The <code class="computeroutput"><span class="identifier">value_type</span></code> of the range is an instantiation
of <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">pair</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Postcondition:</strong></span> For all elements
<code class="computeroutput"><span class="identifier">x</span></code> in the returned
range, <code class="computeroutput"><span class="identifier">x</span></code> is the result
of <code class="computeroutput"><span class="identifier">y</span><span class="special">.</span><span class="identifier">second</span></code> where <code class="computeroutput"><span class="identifier">y</span></code>
is the corresponding element in the original range.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> for constant
ranges, <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">select_second_const</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
otherwise <code class="computeroutput"><span class="identifier">boost</span><span class="special">:</span><span class="identifier">select_second_mutable</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The range
category of <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.map_values.map_values_example"></a><a class="link" href="map_values.html#range.reference.adaptors.reference.map_values.map_values_example" title="map_values example">map_values
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">map</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">map</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="keyword">for</span> <span class="special">(</span><span class="keyword">int</span> <span class="identifier">i</span> <span class="special">=</span> <span class="number">0</span><span class="special">;</span> <span class="identifier">i</span> <span class="special">&lt;</span> <span class="number">10</span><span class="special">;</span> <span class="special">++</span><span class="identifier">i</span><span class="special">)</span>
<span class="identifier">input</span><span class="special">.</span><span class="identifier">insert</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">make_pair</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">i</span> <span class="special">*</span> <span class="number">10</span><span class="special">));</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">map_values</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">0</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">20</span><span class="special">,</span><span class="number">30</span><span class="special">,</span><span class="number">40</span><span class="special">,</span><span class="number">50</span><span class="special">,</span><span class="number">60</span><span class="special">,</span><span class="number">70</span><span class="special">,</span><span class="number">80</span><span class="special">,</span><span class="number">90</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="map_keys.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replaced.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,174 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>replaced</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="map_values.html" title="map_values">
<link rel="next" href="replaced_if.html" title="replaced_if">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="map_values.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replaced_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.replaced"></a><a class="link" href="replaced.html" title="replaced">replaced</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="replaced.html#range.reference.adaptors.reference.replaced.replaced_example">replaced
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">replaced</span><span class="special">(</span><span class="identifier">new_value</span><span class="special">,</span>
<span class="identifier">old_value</span><span class="special">)</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">replace</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">new_value</span><span class="special">,</span>
<span class="identifier">old_value</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<p class="simpara">
<span class="bold"><strong>Precondition:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="circle">
<li class="listitem">
<code class="computeroutput"><span class="identifier">new_value</span></code> is
convertible to the <code class="computeroutput"><span class="identifier">value_type</span></code>
of the range.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">old_value</span></code> is
convertible to the <code class="computeroutput"><span class="identifier">value_type</span></code>
of the range.
</li>
</ul></div>
</li>
<li class="listitem">
<span class="bold"><strong>Postcondition:</strong></span> For all elements
<code class="computeroutput"><span class="identifier">x</span></code> in the returned
range, the value <code class="computeroutput"><span class="identifier">x</span></code>
is equal to the value of <code class="computeroutput"><span class="special">(</span><span class="identifier">y</span> <span class="special">==</span>
<span class="identifier">old_value</span><span class="special">)</span>
<span class="special">?</span> <span class="identifier">new_value</span>
<span class="special">:</span> <span class="identifier">y</span></code>
where <code class="computeroutput"><span class="identifier">y</span></code> is the corresponding
element in the original range.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">replaced_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The range
category of <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.replaced.replaced_example"></a><a class="link" href="replaced.html#range.reference.adaptors.reference.replaced.replaced_example" title="replaced example">replaced
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">replaced</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">9</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">replaced</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">10</span><span class="special">),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">1</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">9</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="map_values.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replaced_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,175 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>replaced_if</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="replaced.html" title="replaced">
<link rel="next" href="reversed.html" title="reversed">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replaced.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reversed.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.replaced_if"></a><a class="link" href="replaced_if.html" title="replaced_if">replaced_if</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="replaced_if.html#range.reference.adaptors.reference.replaced_if.replaced_if_example">replaced_if
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">replaced_if</span><span class="special">(</span><span class="identifier">pred</span><span class="special">,</span>
<span class="identifier">new_value</span><span class="special">)</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">replace_if</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">pred</span><span class="special">,</span>
<span class="identifier">new_value</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<p class="simpara">
<span class="bold"><strong>Precondition:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="circle">
<li class="listitem">
The range <code class="computeroutput"><span class="identifier">value_type</span></code>
is convertible to the argument type of <code class="computeroutput"><span class="identifier">pred</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">new_value</span></code> is
convertible to the <code class="computeroutput"><span class="identifier">value_type</span></code>
of the range.
</li>
</ul></div>
</li>
<li class="listitem">
<span class="bold"><strong>Postconditions:</strong></span> For all elements
<code class="computeroutput"><span class="identifier">x</span></code> in the returned
range, the value <code class="computeroutput"><span class="identifier">x</span></code>
is equal to the value of <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">y</span><span class="special">)</span> <span class="special">?</span> <span class="identifier">new_value</span> <span class="special">:</span>
<span class="identifier">y</span></code> where <code class="computeroutput"><span class="identifier">y</span></code>
is the corresponding element in the original range.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">replaced_if_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The range
category of <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.replaced_if.replaced_if_example"></a><a class="link" href="replaced_if.html#range.reference.adaptors.reference.replaced_if.replaced_if_example" title="replaced_if example">replaced_if
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">replaced_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">is_even</span>
<span class="special">{</span>
<span class="keyword">bool</span> <span class="keyword">operator</span><span class="special">()(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">x</span> <span class="special">%</span> <span class="number">2</span> <span class="special">==</span> <span class="number">0</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">replaced_if</span><span class="special">(</span><span class="identifier">is_even</span><span class="special">(),</span> <span class="number">10</span><span class="special">),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">1</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">9</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replaced.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reversed.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,147 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>reversed</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="replaced_if.html" title="replaced_if">
<link rel="next" href="sliced.html" title="sliced">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replaced_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="sliced.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.reversed"></a><a class="link" href="reversed.html" title="reversed">reversed</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="reversed.html#range.reference.adaptors.reference.reversed.reversed_example">reversed
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reversed</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">reverse</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Returns:</strong></span> A range whose iterators
behave as if they were the original iterators wrapped in <code class="computeroutput"><span class="identifier">reverse_iterator</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">reversed_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The range
category of <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.reversed.reversed_example"></a><a class="link" href="reversed.html#range.reference.adaptors.reference.reversed.reversed_example" title="reversed example">reversed
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">reversed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">reversed_example_test</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">reversed</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">9</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">1</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replaced_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="sliced.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,157 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>sliced</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="reversed.html" title="reversed">
<link rel="next" href="strided.html" title="strided">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="reversed.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="strided.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.sliced"></a><a class="link" href="sliced.html" title="sliced">sliced</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="sliced.html#range.reference.adaptors.reference.sliced.sliced_example">sliced
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">sliced</span><span class="special">(</span><span class="identifier">n</span><span class="special">,</span>
<span class="identifier">m</span><span class="special">)</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">slice</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">n</span><span class="special">,</span>
<span class="identifier">m</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> <code class="computeroutput"><span class="number">0</span>
<span class="special">&lt;=</span> <span class="identifier">n</span>
<span class="special">&amp;&amp;</span> <span class="identifier">n</span>
<span class="special">&lt;=</span> <span class="identifier">m</span>
<span class="special">&amp;&amp;</span> <span class="identifier">m</span>
<span class="special">&lt;</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returns:</strong></span> <code class="computeroutput"><span class="identifier">make_range</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span> <span class="identifier">n</span><span class="special">,</span> <span class="identifier">m</span><span class="special">)</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">sliced_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a>
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.sliced.sliced_example"></a><a class="link" href="sliced.html#range.reference.adaptors.reference.sliced.sliced_example" title="sliced example">sliced
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">sliced</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">sliced</span><span class="special">(</span><span class="number">2</span><span class="special">,</span> <span class="number">5</span><span class="special">),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="reversed.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="strided.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,149 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>strided</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="sliced.html" title="sliced">
<link rel="next" href="type_erased.html" title="type_erased">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="sliced.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="type_erased.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.strided"></a><a class="link" href="strided.html" title="strided">strided</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="strided.html#range.reference.adaptors.reference.strided.strided_example">strided
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">strided</span><span class="special">(</span><span class="identifier">n</span><span class="special">)</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">stride</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">n</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> <code class="computeroutput"><span class="number">0</span>
<span class="special">&lt;=</span> <span class="identifier">n</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Returns:</strong></span> A new range based on <code class="computeroutput"><span class="identifier">rng</span></code> where traversal is performed
in steps of <code class="computeroutput"><span class="identifier">n</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The range
category of <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.strided.strided_example"></a><a class="link" href="strided.html#range.reference.adaptors.reference.strided.strided_example" title="strided example">strided
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">strided</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span><span class="special">,</span><span class="number">10</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">strided</span><span class="special">(</span><span class="number">2</span><span class="special">),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">1</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">9</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="sliced.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="type_erased.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,155 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>tokenized</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="type_erased.html" title="type_erased">
<link rel="next" href="transformed.html" title="transformed">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="type_erased.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="transformed.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.tokenized"></a><a class="link" href="tokenized.html" title="tokenized">tokenized</a>
</h5></div></div></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
</p>
<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenized</span><span class="special">(</span><span class="identifier">regex</span><span class="special">)</span>
<span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenized</span><span class="special">(</span><span class="identifier">regex</span><span class="special">,</span> <span class="identifier">i</span><span class="special">)</span>
<span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenized</span><span class="special">(</span><span class="identifier">regex</span><span class="special">,</span> <span class="identifier">rndRng</span><span class="special">)</span>
<span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenized</span><span class="special">(</span><span class="identifier">regex</span><span class="special">,</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">flags</span><span class="special">)</span>
<span class="identifier">rng</span> <span class="special">|</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenized</span><span class="special">(</span><span class="identifier">regex</span><span class="special">,</span> <span class="identifier">rndRng</span><span class="special">,</span> <span class="identifier">flags</span><span class="special">)</span>
</pre>
<p>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
</p>
<pre xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="table-programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenize</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span> <span class="identifier">regex</span><span class="special">)</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenize</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span> <span class="identifier">regex</span><span class="special">,</span> <span class="identifier">i</span><span class="special">)</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenize</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span> <span class="identifier">regex</span><span class="special">,</span> <span class="identifier">rndRng</span><span class="special">)</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenize</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span> <span class="identifier">regex</span><span class="special">,</span> <span class="identifier">i</span><span class="special">,</span> <span class="identifier">flags</span><span class="special">)</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">tokenize</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span> <span class="identifier">regex</span><span class="special">,</span> <span class="identifier">rndRng</span><span class="special">,</span> <span class="identifier">flags</span><span class="special">)</span>
</pre>
<p>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<p class="simpara">
<span class="bold"><strong>Precondition:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="circle">
<li class="listitem">
Let <code class="computeroutput"><span class="identifier">T</span></code> denote
<code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">decltype</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;::</span><span class="identifier">type</span></code>,
then <code class="computeroutput"><span class="identifier">regex</span></code> has
the type <code class="computeroutput"><span class="identifier">basic_regex</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span></code> or is implicitly convertible
to one of these types.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">i</span></code> has the type
<code class="computeroutput"><span class="keyword">int</span></code>.
</li>
<li class="listitem">
the <code class="computeroutput"><span class="identifier">value_type</span></code>
of <code class="computeroutput"><span class="identifier">rndRng</span></code> is
<code class="computeroutput"><span class="keyword">int</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">flags</span></code> has the
type <code class="computeroutput"><span class="identifier">regex_constants</span><span class="special">::</span><span class="identifier">syntax_option_type</span></code>.
</li>
</ul></div>
</li>
<li class="listitem">
<span class="bold"><strong>Returns:</strong></span> A range whose iterators
behave as if they were the original iterators wrapped in <code class="computeroutput"><span class="identifier">regex_token_iterator</span></code>. The first
iterator in the range would be constructed by forwarding all the
arguments of <code class="computeroutput"><span class="identifier">tokenized</span><span class="special">()</span></code> to the <code class="computeroutput"><span class="identifier">regex_token_iterator</span></code>
constructor.
</li>
<li class="listitem">
<span class="bold"><strong>Throws:</strong></span> Whatever constructing and
copying equivalent <code class="computeroutput"><span class="identifier">regex_token_iterator</span></code>s
might throw.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">tokenized_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a>
</li>
</ul></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="type_erased.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="transformed.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,166 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>transformed</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="tokenized.html" title="tokenized">
<link rel="next" href="uniqued.html" title="uniqued">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tokenized.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="uniqued.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.transformed"></a><a class="link" href="transformed.html" title="transformed">transformed</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="transformed.html#range.reference.adaptors.reference.transformed.transformed_example">transformed
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">transformed</span><span class="special">(</span><span class="identifier">fun</span><span class="special">)</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">transform</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">fun</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> The <code class="computeroutput"><span class="identifier">value_type</span></code> of the range is convertible
to the argument type of <code class="computeroutput"><span class="identifier">fun</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Postcondition:</strong></span> For all elements
<code class="computeroutput"><span class="identifier">x</span></code> in the returned
range, <code class="computeroutput"><span class="identifier">x</span></code> is the result
of <code class="computeroutput"><span class="identifier">fun</span><span class="special">(</span><span class="identifier">y</span><span class="special">)</span></code>
where <code class="computeroutput"><span class="identifier">y</span></code> is the corresponding
element in the original range.
</li>
<li class="listitem">
<span class="bold"><strong>Throws:</strong></span> Whatever the copy-constructor
of <code class="computeroutput"><span class="identifier">fun</span></code> might throw.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">transformed_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The range
category of <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.transformed.transformed_example"></a><a class="link" href="transformed.html#range.reference.adaptors.reference.transformed.transformed_example" title="transformed example">transformed
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">transformed</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">struct</span> <span class="identifier">double_int</span>
<span class="special">{</span>
<span class="keyword">typedef</span> <span class="keyword">int</span> <span class="identifier">result_type</span><span class="special">;</span>
<span class="keyword">int</span> <span class="keyword">operator</span><span class="special">()(</span><span class="keyword">int</span> <span class="identifier">x</span><span class="special">)</span> <span class="keyword">const</span> <span class="special">{</span> <span class="keyword">return</span> <span class="identifier">x</span> <span class="special">*</span> <span class="number">2</span><span class="special">;</span> <span class="special">}</span>
<span class="special">};</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span><span class="special">,</span><span class="number">10</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">transformed</span><span class="special">(</span><span class="identifier">double_int</span><span class="special">()),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">2</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">6</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">10</span><span class="special">,</span><span class="number">12</span><span class="special">,</span><span class="number">14</span><span class="special">,</span><span class="number">16</span><span class="special">,</span><span class="number">18</span><span class="special">,</span><span class="number">20</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="tokenized.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="uniqued.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,305 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>type_erased</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="strided.html" title="strided">
<link rel="next" href="tokenized.html" title="tokenized">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="strided.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tokenized.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.type_erased"></a><a class="link" href="type_erased.html" title="type_erased">type_erased</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="type_erased.html#range.reference.adaptors.reference.type_erased.type_erased_example">type-erased
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">type_erased</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span>
<span class="identifier">Traversal</span><span class="special">,</span>
<span class="identifier">Reference</span><span class="special">,</span>
<span class="identifier">Difference</span><span class="special">,</span>
<span class="identifier">Buffer</span><span class="special">&gt;()</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">type_erase</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">type_erased</span><span class="special">&lt;</span><span class="identifier">Value</span><span class="special">,</span>
<span class="identifier">Traversal</span><span class="special">,</span>
<span class="identifier">Reference</span><span class="special">,</span>
<span class="identifier">Difference</span><span class="special">,</span>
<span class="identifier">Buffer</span><span class="special">&gt;)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<p>
Please note that it is frequently unnecessary to use the <code class="computeroutput"><span class="identifier">type_erased</span></code> adaptor. It is often better
to use the implicit conversion to <code class="computeroutput"><span class="identifier">any_range</span></code>.
</p>
<p>
Let <code class="computeroutput"><span class="identifier">Rng</span></code> be the type of
<code class="computeroutput"><span class="identifier">rng</span></code>.
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<p class="simpara">
<span class="bold"><strong>Template parameters:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="circle">
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is the
<code class="computeroutput"><span class="identifier">value_type</span></code> for
the <code class="computeroutput"><span class="identifier">any_range</span></code>.
If this is set to boost::use_default, <code class="computeroutput"><span class="identifier">Value</span></code>
will be calculated from the range type when the adaptor is applied.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Traversal</span></code> is
the tag used to identify the traversal of the resultant range.
Frequently it is desireable to set a traversal category lower
than the source container or range to maximize the number of
ranges that can convert to the <code class="computeroutput"><span class="identifier">any_range</span></code>.
If this is left as boost::use_default then <code class="computeroutput"><span class="identifier">Traversal</span></code>
will be <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">iterator_traversal</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">Rng</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Reference</span></code> is
the <code class="computeroutput"><span class="identifier">reference</span></code>
for the <code class="computeroutput"><span class="identifier">any_range</span></code>.
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">use_default</span></code> will equate to
<code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">range_reference</span><span class="special">&lt;</span><span class="identifier">Rng</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Difference</span></code> is
the <code class="computeroutput"><span class="identifier">difference_type</span></code>
for the any_range. <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">use_default</span></code>
will equate to <code class="computeroutput"><span class="keyword">typename</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_difference</span><span class="special">&lt;</span><span class="identifier">Rng</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Buffer</span></code> is the
storage used to allocate the underlying iterator wrappers. This
can typically be ignored, but is available as a template parameter
for customization. Buffer must be a model of the <code class="computeroutput"><span class="identifier">AnyIteratorBufferConcept</span></code>.
</li>
</ul></div>
</li>
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> <code class="computeroutput"><span class="identifier">Traversal</span></code>
is one of <code class="computeroutput"><span class="special">{</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">use_default</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">single_pass_traversal_tag</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward_traversal_tag</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">bidirectional_traversal_tag</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">random_access_traversal_tag</span>
<span class="special">}</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returns:</strong></span> The returned value is the
same as <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">any_range_type_generator</span><span class="special">&lt;</span> <span class="identifier">Rng</span><span class="special">,</span> <span class="identifier">Value</span><span class="special">,</span> <span class="identifier">Traversal</span><span class="special">,</span> <span class="identifier">Reference</span><span class="special">,</span> <span class="identifier">Difference</span><span class="special">,</span> <span class="identifier">Buffer</span>
<span class="special">&gt;</span></code> that represents <code class="computeroutput"><span class="identifier">rng</span></code> in a type-erased manner.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> if <code class="computeroutput"><span class="identifier">Traversal</span></code> was specified as <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">use_default</span></code> then <code class="computeroutput"><span class="keyword">typename</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">iterator_traversal</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">Rng</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">&gt;::</span><span class="identifier">type</span></code>,
otherwise <code class="computeroutput"><span class="identifier">Traversal</span></code>.
</li>
</ul></div>
<a name="range.reference.adaptors.reference.type_erased.anyiteratorbufferconcept"></a><h6>
<a name="id677095"></a>
<a class="link" href="type_erased.html#range.reference.adaptors.reference.type_erased.anyiteratorbufferconcept">AnyIteratorBufferConcept</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">class</span> <span class="identifier">AnyIteratorBufferConcept</span>
<span class="special">{</span>
<span class="keyword">public</span><span class="special">:</span>
<span class="identifier">AnyIteratorBufferConcept</span><span class="special">();</span>
<span class="special">~</span><span class="identifier">AnyIteratorBufferConcept</span><span class="special">();</span>
<span class="comment">// bytes is the requested size to allocate. This function
</span> <span class="comment">// must return a pointer to an adequate area of memory.
</span> <span class="comment">// throws: bad_alloc
</span> <span class="comment">//
</span> <span class="comment">// The buffer will only ever have zero or one
</span> <span class="comment">// outstanding memory allocations.
</span> <span class="keyword">void</span><span class="special">*</span> <span class="identifier">allocate</span><span class="special">(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> <span class="identifier">bytes</span><span class="special">);</span>
<span class="comment">// deallocate this buffer
</span> <span class="keyword">void</span> <span class="identifier">deallocate</span><span class="special">();</span>
<span class="special">};</span>
</pre>
<p>
</p>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.type_erased.type_erased_example"></a><a class="link" href="type_erased.html#range.reference.adaptors.reference.type_erased.type_erased_example" title="type-erased example">type-erased
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">type_erased</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">foreach</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">list</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="comment">// The client interface from an OO perspective merely requires a sequence
</span><span class="comment">// of integers that can be forward traversed
</span><span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">any_range</span><span class="special">&lt;</span>
<span class="keyword">int</span>
<span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward_traversal_tag</span>
<span class="special">,</span> <span class="keyword">int</span>
<span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">ptrdiff_t</span>
<span class="special">&gt;</span> <span class="identifier">integer_range</span><span class="special">;</span>
<span class="keyword">namespace</span> <span class="identifier">server</span>
<span class="special">{</span>
<span class="keyword">void</span> <span class="identifier">display_integers</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">integer_range</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">)</span>
<span class="special">{</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span><span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">endl</span><span class="special">;</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">namespace</span> <span class="identifier">client</span>
<span class="special">{</span>
<span class="keyword">void</span> <span class="identifier">run</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="comment">// Under most conditions one would simply use an appropriate
</span> <span class="comment">// any_range as a function parameter. The type_erased adaptor
</span> <span class="comment">// is often superfluous. However because the type_erased
</span> <span class="comment">// adaptor is applied to a range, we can use default template
</span> <span class="comment">// arguments that are generated in conjunction with the
</span> <span class="comment">// range type to which we are applying the adaptor.
</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">;</span>
<span class="comment">// Note that this call is to a non-template function
</span> <span class="identifier">server</span><span class="special">::</span><span class="identifier">display_integers</span><span class="special">(</span><span class="identifier">input</span><span class="special">);</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">list</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input2</span><span class="special">;</span>
<span class="identifier">input2</span> <span class="special">+=</span> <span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span><span class="special">,</span><span class="number">10</span><span class="special">;</span>
<span class="comment">// Note that this call is to the same non-tempate function
</span> <span class="identifier">server</span><span class="special">::</span><span class="identifier">display_integers</span><span class="special">(</span><span class="identifier">input2</span><span class="special">);</span>
<span class="identifier">input2</span><span class="special">.</span><span class="identifier">clear</span><span class="special">();</span>
<span class="identifier">input2</span> <span class="special">+=</span> <span class="number">11</span><span class="special">,</span><span class="number">12</span><span class="special">,</span><span class="number">13</span><span class="special">,</span><span class="number">14</span><span class="special">,</span><span class="number">15</span><span class="special">;</span>
<span class="comment">// Calling using the adaptor looks like this:
</span> <span class="comment">// Notice that here I have a type_erased that would be a
</span> <span class="comment">// bidirectional_traversal_tag, but this is convertible
</span> <span class="comment">// to the forward_traversal_tag equivalent hence this
</span> <span class="comment">// works.
</span> <span class="identifier">server</span><span class="special">::</span><span class="identifier">display_integers</span><span class="special">(</span><span class="identifier">input2</span> <span class="special">|</span> <span class="identifier">type_erased</span><span class="special">&lt;&gt;());</span>
<span class="comment">// However we may simply wish to define an adaptor that
</span> <span class="comment">// takes a range and makes it into an appropriate
</span> <span class="comment">// forward_traversal any_range...
</span> <span class="keyword">typedef</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">type_erased</span><span class="special">&lt;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">use_default</span>
<span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">forward_traversal_tag</span>
<span class="special">&gt;</span> <span class="identifier">type_erased_forward</span><span class="special">;</span>
<span class="comment">// This adaptor can turn other containers with different
</span> <span class="comment">// value_types and reference_types into the appropriate
</span> <span class="comment">// any_range.
</span>
<span class="identifier">server</span><span class="special">::</span><span class="identifier">display_integers</span><span class="special">(</span><span class="identifier">input2</span> <span class="special">|</span> <span class="identifier">type_erased_forward</span><span class="special">());</span>
<span class="special">}</span>
<span class="special">}</span>
<span class="keyword">int</span> <span class="identifier">main</span><span class="special">(</span><span class="keyword">int</span> <span class="identifier">argc</span><span class="special">,</span> <span class="keyword">const</span> <span class="keyword">char</span><span class="special">*</span> <span class="identifier">argv</span><span class="special">[])</span>
<span class="special">{</span>
<span class="identifier">client</span><span class="special">::</span><span class="identifier">run</span><span class="special">();</span>
<span class="keyword">return</span> <span class="number">0</span><span class="special">;</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span>
<span class="number">6</span><span class="special">,</span><span class="number">7</span><span class="special">,</span><span class="number">8</span><span class="special">,</span><span class="number">9</span><span class="special">,</span><span class="number">10</span>
<span class="number">11</span><span class="special">,</span><span class="number">12</span><span class="special">,</span><span class="number">13</span><span class="special">,</span><span class="number">14</span><span class="special">,</span><span class="number">15</span>
<span class="number">11</span><span class="special">,</span><span class="number">12</span><span class="special">,</span><span class="number">13</span><span class="special">,</span><span class="number">14</span><span class="special">,</span><span class="number">15</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="strided.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="tokenized.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,150 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>uniqued</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="transformed.html" title="transformed">
<link rel="next" href="../../algorithms.html" title="Range Algorithms">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="transformed.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../algorithms.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.adaptors.reference.uniqued"></a><a class="link" href="uniqued.html" title="uniqued">uniqued</a>
</h5></div></div></div>
<div class="toc"><dl><dt><span class="section"><a href="uniqued.html#range.reference.adaptors.reference.uniqued.uniqued_example">uniqued
example</a></span></dt></dl></div>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Syntax
</p>
</th>
<th>
<p>
Code
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
Pipe
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">rng</span> <span class="special">|</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">uniqued</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
Function
</p>
</td>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">::</span><span class="identifier">unique</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
</tr>
</tbody>
</table></div>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<span class="bold"><strong>Precondition:</strong></span> The <code class="computeroutput"><span class="identifier">value_type</span></code> of the range is comparable
with <code class="computeroutput"><span class="keyword">operator</span><span class="special">==()</span></code>.
</li>
<li class="listitem">
<span class="bold"><strong>Postcondition:</strong></span> For all adjacent
elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code> in the returned range, <code class="computeroutput"><span class="identifier">x</span><span class="special">==</span><span class="identifier">y</span></code> is false.
</li>
<li class="listitem">
<span class="bold"><strong>Range Category:</strong></span> <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a>
</li>
<li class="listitem">
<span class="bold"><strong>Range Return Type:</strong></span> <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">uniqued_range</span><span class="special">&lt;</span><span class="identifier">typeof</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)&gt;</span></code>
</li>
<li class="listitem">
<span class="bold"><strong>Returned Range Category:</strong></span> The minimum
of the range concept of <code class="computeroutput"><span class="identifier">rng</span></code>
and <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward Range</a>.
</li>
</ul></div>
<div class="section">
<div class="titlepage"><div><div><h6 class="title">
<a name="range.reference.adaptors.reference.uniqued.uniqued_example"></a><a class="link" href="uniqued.html#range.reference.adaptors.reference.uniqued.uniqued_example" title="uniqued example">uniqued
example</a>
</h6></div></div></div>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">adaptor</span><span class="special">/</span><span class="identifier">uniqued</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">assign</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">algorithm</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">iostream</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="keyword">void</span> <span class="identifier">uniqued_example_test</span><span class="special">()</span>
<span class="special">{</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">assign</span><span class="special">;</span>
<span class="keyword">using</span> <span class="keyword">namespace</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">adaptors</span><span class="special">;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">input</span><span class="special">;</span>
<span class="identifier">input</span> <span class="special">+=</span> <span class="number">1</span><span class="special">,</span><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span><span class="special">;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span>
<span class="identifier">input</span> <span class="special">|</span> <span class="identifier">uniqued</span><span class="special">,</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">,</span> <span class="string">","</span><span class="special">));</span>
<span class="special">}</span>
</pre>
<p>
</p>
</div>
<p>
This would produce the output:
</p>
<pre class="programlisting"><span class="number">1</span><span class="special">,</span><span class="number">2</span><span class="special">,</span><span class="number">3</span><span class="special">,</span><span class="number">4</span><span class="special">,</span><span class="number">5</span><span class="special">,</span><span class="number">6</span>
</pre>
<p>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="transformed.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../../algorithms.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,56 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Range Algorithms</title>
<link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../reference.html" title="Reference">
<link rel="prev" href="adaptors/reference/uniqued.html" title="uniqued">
<link rel="next" href="algorithms/introduction.html" title="Introduction and motivation">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="adaptors/reference/uniqued.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithms/introduction.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h3 class="title">
<a name="range.reference.algorithms"></a><a class="link" href="algorithms.html" title="Range Algorithms">Range Algorithms</a>
</h3></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="algorithms/introduction.html">Introduction
and motivation</a></span></dt>
<dt><span class="section"><a href="algorithms/mutating.html">Mutating algorithms</a></span></dt>
<dt><span class="section"><a href="algorithms/non_mutating.html">Non-mutating
algorithms</a></span></dt>
<dt><span class="section"><a href="algorithms/set.html">Set algorithms</a></span></dt>
<dt><span class="section"><a href="algorithms/heap.html">Heap algorithms</a></span></dt>
<dt><span class="section"><a href="algorithms/permutation.html">Permutation
algorithms</a></span></dt>
<dt><span class="section"><a href="algorithms/new.html">New algorithms</a></span></dt>
<dt><span class="section"><a href="algorithms/numeric.html">Numeric algorithms</a></span></dt>
</dl></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="adaptors/reference/uniqued.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../reference.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="algorithms/introduction.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,49 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Heap algorithms</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../algorithms.html" title="Range Algorithms">
<link rel="prev" href="set/set_symmetric_difference.html" title="set_symmetric_difference">
<link rel="next" href="heap/push_heap.html" title="push_heap">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="set/set_symmetric_difference.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithms.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="heap/push_heap.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="range.reference.algorithms.heap"></a><a class="link" href="heap.html" title="Heap algorithms">Heap algorithms</a>
</h4></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="heap/push_heap.html">push_heap</a></span></dt>
<dt><span class="section"><a href="heap/pop_heap.html">pop_heap</a></span></dt>
<dt><span class="section"><a href="heap/make_heap.html">make_heap</a></span></dt>
<dt><span class="section"><a href="heap/sort_heap.html">sort_heap</a></span></dt>
</dl></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="set/set_symmetric_difference.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithms.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="heap/push_heap.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,143 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>make_heap</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../heap.html" title="Heap algorithms">
<link rel="prev" href="pop_heap.html" title="pop_heap">
<link rel="next" href="sort_heap.html" title="sort_heap">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="pop_heap.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../heap.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="sort_heap.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.heap.make_heap"></a><a class="link" href="make_heap.html" title="make_heap">make_heap</a>
</h5></div></div></div>
<a name="range.reference.algorithms.heap.make_heap.prototype"></a><h6>
<a name="id741272"></a>
<a class="link" href="make_heap.html#range.reference.algorithms.heap.make_heap.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">make_heap</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">make_heap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Compare</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">make_heap</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Compare</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Compare</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">make_heap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Compare</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.heap.make_heap.description"></a><h6>
<a name="id741648"></a>
<a class="link" href="make_heap.html#range.reference.algorithms.heap.make_heap.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">make_heap</span></code> turns <code class="computeroutput"><span class="identifier">rng</span></code> into a heap.
</p>
<p>
The ordering relationship is determined by using <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> in the non-predicate versions, and
by evaluating <code class="computeroutput"><span class="identifier">pred</span></code> in
the predicate versions.
</p>
<a name="range.reference.algorithms.heap.make_heap.definition"></a><h6>
<a name="id741722"></a>
<a class="link" href="make_heap.html#range.reference.algorithms.heap.make_heap.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">heap_algorithm</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.heap.make_heap.requirements"></a><h6>
<a name="id741791"></a>
<a class="link" href="make_heap.html#range.reference.algorithms.heap.make_heap.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the non-predicate versions:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a model of the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>.
</li>
<li class="listitem">
The ordering of objects of type <code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a <span class="bold"><strong><span class="emphasis"><em>strict weak ordering</em></span></strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the predicate versions:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Compare</span></code> is a model
of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is convertible to both of <code class="computeroutput"><span class="identifier">Compare</span></code>'s
argument types.
</li>
</ul></div>
<a name="range.reference.algorithms.heap.make_heap.complexity"></a><h6>
<a name="id742039"></a>
<a class="link" href="make_heap.html#range.reference.algorithms.heap.make_heap.complexity">Complexity</a>
</h6>
<p>
Linear. At most <code class="computeroutput"><span class="number">3</span> <span class="special">*</span>
<span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
comparisons.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="pop_heap.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../heap.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="sort_heap.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,157 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>pop_heap</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../heap.html" title="Heap algorithms">
<link rel="prev" href="push_heap.html" title="push_heap">
<link rel="next" href="make_heap.html" title="make_heap">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="push_heap.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../heap.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="make_heap.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.heap.pop_heap"></a><a class="link" href="pop_heap.html" title="pop_heap">pop_heap</a>
</h5></div></div></div>
<a name="range.reference.algorithms.heap.pop_heap.prototype"></a><h6>
<a name="id740266"></a>
<a class="link" href="pop_heap.html#range.reference.algorithms.heap.pop_heap.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">pop_heap</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">pop_heap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Compare</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">pop_heap</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Compare</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Compare</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">pop_heap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Compare</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.heap.pop_heap.description"></a><h6>
<a name="id740642"></a>
<a class="link" href="pop_heap.html#range.reference.algorithms.heap.pop_heap.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">pop_heap</span></code> removes the
largest element from the heap. It is assumed that <code class="computeroutput"><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">prior</span><span class="special">(</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> is already a heap and that the element
to be added is <code class="computeroutput"><span class="special">*</span><span class="identifier">prior</span><span class="special">(</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>.
</p>
<p>
The ordering relationship is determined by using <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> in the non-predicate versions, and
by evaluating <code class="computeroutput"><span class="identifier">pred</span></code> in
the predicate versions.
</p>
<a name="range.reference.algorithms.heap.pop_heap.definition"></a><h6>
<a name="id740796"></a>
<a class="link" href="pop_heap.html#range.reference.algorithms.heap.pop_heap.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">heap_algorithm</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.heap.pop_heap.requirements"></a><h6>
<a name="id740866"></a>
<a class="link" href="pop_heap.html#range.reference.algorithms.heap.pop_heap.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the non-predicate versions:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a model of the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>.
</li>
<li class="listitem">
The ordering of objects of type <code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a <span class="bold"><strong><span class="emphasis"><em>strict weak ordering</em></span></strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the predicate versions:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Compare</span></code> is a model
of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is convertible to both of <code class="computeroutput"><span class="identifier">Compare</span></code>'s
argument types.
</li>
</ul></div>
<a name="range.reference.algorithms.heap.pop_heap.precondition_"></a><h6>
<a name="id741114"></a>
<a class="link" href="pop_heap.html#range.reference.algorithms.heap.pop_heap.precondition_">Precondition:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="special">!</span><span class="identifier">empty</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">rng</span></code> is a heap.
</li>
</ul></div>
<a name="range.reference.algorithms.heap.pop_heap.complexity"></a><h6>
<a name="id741189"></a>
<a class="link" href="pop_heap.html#range.reference.algorithms.heap.pop_heap.complexity">Complexity</a>
</h6>
<p>
Logarithmic. At most <code class="computeroutput"><span class="number">2</span> <span class="special">*</span>
<span class="identifier">log</span><span class="special">(</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>
comparisons.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="push_heap.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../heap.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="make_heap.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,155 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>push_heap</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../heap.html" title="Heap algorithms">
<link rel="prev" href="../heap.html" title="Heap algorithms">
<link rel="next" href="pop_heap.html" title="pop_heap">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../heap.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../heap.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="pop_heap.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.heap.push_heap"></a><a class="link" href="push_heap.html" title="push_heap">push_heap</a>
</h5></div></div></div>
<a name="range.reference.algorithms.heap.push_heap.prototype"></a><h6>
<a name="id739222"></a>
<a class="link" href="push_heap.html#range.reference.algorithms.heap.push_heap.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">push_heap</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">push_heap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Compare</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">push_heap</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Compare</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Compare</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">push_heap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Compare</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.heap.push_heap.description"></a><h6>
<a name="id739596"></a>
<a class="link" href="push_heap.html#range.reference.algorithms.heap.push_heap.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">push_heap</span></code> adds an element
to a heap. It is assumed that <code class="computeroutput"><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>, <code class="computeroutput"><span class="identifier">prior</span><span class="special">(</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> is already a heap and that the element
to be added is <code class="computeroutput"><span class="special">*</span><span class="identifier">prior</span><span class="special">(</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>.
</p>
<p>
The ordering relationship is determined by using <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> in the non-predicate versions, and
by evaluating <code class="computeroutput"><span class="identifier">pred</span></code> in
the predicate versions.
</p>
<a name="range.reference.algorithms.heap.push_heap.definition"></a><h6>
<a name="id739755"></a>
<a class="link" href="push_heap.html#range.reference.algorithms.heap.push_heap.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">heap_algorithm</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.heap.push_heap.requirements"></a><h6>
<a name="id739825"></a>
<a class="link" href="push_heap.html#range.reference.algorithms.heap.push_heap.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the non-predicate versions:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a model of the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>.
</li>
<li class="listitem">
The ordering of objects of type <code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a <span class="bold"><strong><span class="emphasis"><em>strict weak ordering</em></span></strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the predicate versions:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Compare</span></code> is a model
of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is convertible to both of <code class="computeroutput"><span class="identifier">Compare</span></code>'s
argument types.
</li>
</ul></div>
<a name="range.reference.algorithms.heap.push_heap.precondition_"></a><h6>
<a name="id740073"></a>
<a class="link" href="push_heap.html#range.reference.algorithms.heap.push_heap.precondition_">Precondition:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="special">!</span><span class="identifier">empty</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">prior</span><span class="special">(</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)))</span></code> is a heap.
</li>
</ul></div>
<a name="range.reference.algorithms.heap.push_heap.complexity"></a><h6>
<a name="id740193"></a>
<a class="link" href="push_heap.html#range.reference.algorithms.heap.push_heap.complexity">Complexity</a>
</h6>
<p>
Logarithmic. At most <code class="computeroutput"><span class="identifier">log</span><span class="special">(</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> comparisons.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../heap.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../heap.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="pop_heap.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,152 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>sort_heap</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../heap.html" title="Heap algorithms">
<link rel="prev" href="make_heap.html" title="make_heap">
<link rel="next" href="../permutation.html" title="Permutation algorithms">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="make_heap.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../heap.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../permutation.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.heap.sort_heap"></a><a class="link" href="sort_heap.html" title="sort_heap">sort_heap</a>
</h5></div></div></div>
<a name="range.reference.algorithms.heap.sort_heap.prototype"></a><h6>
<a name="id742115"></a>
<a class="link" href="sort_heap.html#range.reference.algorithms.heap.sort_heap.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">sort_heap</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">sort_heap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Compare</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">sort_heap</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Compare</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Compare</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">sort_heap</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Compare</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.heap.sort_heap.description"></a><h6>
<a name="id742491"></a>
<a class="link" href="sort_heap.html#range.reference.algorithms.heap.sort_heap.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">sort_heap</span></code> turns a heap
into a sorted range.
</p>
<p>
The ordering relationship is determined by using <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;</span></code> in the non-predicate versions, and
by evaluating <code class="computeroutput"><span class="identifier">pred</span></code> in
the predicate versions.
</p>
<a name="range.reference.algorithms.heap.sort_heap.definition"></a><h6>
<a name="id742555"></a>
<a class="link" href="sort_heap.html#range.reference.algorithms.heap.sort_heap.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">heap_algorithm</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.heap.sort_heap.requirements"></a><h6>
<a name="id742626"></a>
<a class="link" href="sort_heap.html#range.reference.algorithms.heap.sort_heap.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the non-predicate versions:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a model of the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>.
</li>
<li class="listitem">
The ordering of objects of type <code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a <span class="bold"><strong><span class="emphasis"><em>strict weak ordering</em></span></strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the predicate versions:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Compare</span></code> is a model
of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is convertible to both of <code class="computeroutput"><span class="identifier">Compare</span></code>'s
argument types.
</li>
</ul></div>
<a name="range.reference.algorithms.heap.sort_heap.precondition_"></a><h6>
<a name="id742873"></a>
<a class="link" href="sort_heap.html#range.reference.algorithms.heap.sort_heap.precondition_">Precondition:</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">rng</span></code> is a heap.
</p>
<a name="range.reference.algorithms.heap.sort_heap.complexity"></a><h6>
<a name="id742906"></a>
<a class="link" href="sort_heap.html#range.reference.algorithms.heap.sort_heap.complexity">Complexity</a>
</h6>
<p>
At most <code class="computeroutput"><span class="identifier">N</span> <span class="special">*</span>
<span class="identifier">log</span><span class="special">(</span><span class="identifier">N</span><span class="special">)</span></code>
comparisons, where <code class="computeroutput"><span class="identifier">N</span></code>
is <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="make_heap.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../heap.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="../permutation.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,257 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Introduction and motivation</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../algorithms.html" title="Range Algorithms">
<link rel="prev" href="../algorithms.html" title="Range Algorithms">
<link rel="next" href="mutating.html" title="Mutating algorithms">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../algorithms.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithms.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mutating.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="range.reference.algorithms.introduction"></a><a class="link" href="introduction.html" title="Introduction and motivation">Introduction
and motivation</a>
</h4></div></div></div>
<p>
In its most simple form a <span class="bold"><strong>Range Algorithm</strong></span>
(or range-based algorithm) is simply an iterator-based algorithm where
the <span class="emphasis"><em>two</em></span> iterator arguments have been replaced by
<span class="emphasis"><em>one</em></span> range argument. For example, we may write
</p>
<p>
</p>
<pre class="programlisting"><span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">vector</span><span class="special">&gt;</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">vec</span> <span class="special">=</span> <span class="special">...;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">sort</span><span class="special">(</span><span class="identifier">vec</span><span class="special">);</span>
</pre>
<p>
</p>
<p>
instead of
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">sort</span><span class="special">(</span><span class="identifier">vec</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">vec</span><span class="special">.</span><span class="identifier">end</span><span class="special">());</span>
</pre>
<p>
</p>
<p>
However, the return type of range algorithms is almost always different
from that of existing iterator-based algorithms.
</p>
<p>
One group of algorithms, like <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">sort</span><span class="special">()</span></code>, will simply return the same range so
that we can continue to pass the range around and/or further modify it.
Because of this we may write
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">:</span><span class="identifier">unique</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">sort</span><span class="special">(</span><span class="identifier">vec</span><span class="special">));</span>
</pre>
<p>
to first sort the range and then run <code class="computeroutput"><span class="identifier">unique</span><span class="special">()</span></code> on the sorted range.
</p>
<p>
Algorithms like <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">()</span></code>
fall into another group of algorithms that return (potentially) narrowed
views of the original range. By default <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> returns the range <code class="computeroutput"><span class="special">[</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">found</span><span class="special">)</span></code>
where <code class="computeroutput"><span class="identifier">found</span></code> denotes the
iterator returned by <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">unique</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>
</p>
<p>
Therefore exactly the unique values can be copied by writing
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">copy</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">sort</span><span class="special">(</span><span class="identifier">vec</span><span class="special">)),</span>
<span class="identifier">std</span><span class="special">::</span><span class="identifier">ostream_iterator</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;(</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">cout</span><span class="special">));</span>
</pre>
<p>
</p>
<p>
Algorithms like <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span></code> usually return the same range:
<code class="computeroutput"><span class="special">[</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">found</span><span class="special">)</span></code>. However, this behaviour may be changed
by supplying the algorithms with a template argument:
</p>
<div class="informaltable"><table class="table">
<colgroup>
<col>
<col>
</colgroup>
<thead><tr>
<th>
<p>
Expression
</p>
</th>
<th>
<p>
Return
</p>
</th>
</tr></thead>
<tbody>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">return_found</span><span class="special">&gt;(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
returns a single iterator like <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">unique</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">return_begin_found</span><span class="special">&gt;(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
returns the range <code class="computeroutput"><span class="special">[</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span>
<span class="identifier">found</span><span class="special">)</span></code>
(this is the default)
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">return_begin_next</span><span class="special">&gt;(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
returns the range <code class="computeroutput"><span class="special">[</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">next</span><span class="special">(</span><span class="identifier">found</span><span class="special">))</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">return_found_end</span><span class="special">&gt;(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
returns the range <code class="computeroutput"><span class="special">[</span><span class="identifier">found</span><span class="special">,</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">return_next_end</span><span class="special">&gt;(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
returns the range <code class="computeroutput"><span class="special">[</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">next</span><span class="special">(</span><span class="identifier">found</span><span class="special">),</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>
</p>
</td>
</tr>
<tr>
<td>
<p>
<code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">return_begin_end</span><span class="special">&gt;(</span><span class="identifier">rng</span><span class="special">)</span></code>
</p>
</td>
<td>
<p>
returns the entire original range.
</p>
</td>
</tr>
</tbody>
</table></div>
<p>
This functionality has the following advantages:
</p>
<div class="orderedlist"><ol class="orderedlist" type="1">
<li class="listitem">
it allows for <span class="emphasis"><em><span class="bold"><strong>seamless functional-style
programming</strong></span></em></span> where you do not need to use named
local variables to store intermediate results
</li>
<li class="listitem">
it is very <span class="emphasis"><em><span class="bold"><strong>safe</strong></span></em></span>
because the algorithm can verify out-of-bounds conditions and handle
tricky conditions that lead to empty ranges
</li>
</ol></div>
<p>
For example, consider how easy we may erase the duplicates in a sorted
container:
</p>
<p>
</p>
<pre class="programlisting"><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;</span> <span class="identifier">vec</span> <span class="special">=</span> <span class="special">...;</span>
<span class="identifier">boost</span><span class="special">::</span><span class="identifier">erase</span><span class="special">(</span><span class="identifier">vec</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">return_found_end</span><span class="special">&gt;(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">sort</span><span class="special">(</span><span class="identifier">vec</span><span class="special">)));</span>
</pre>
<p>
</p>
<p>
Notice the use of <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">return_found_end</span></code>.
What if we wanted to erase all the duplicates except one of them? In old-fashined
STL-programming we might write
</p>
<p>
</p>
<pre class="programlisting"><span class="comment">// assume 'vec' is already sorted
</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">vector</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">iterator</span> <span class="identifier">i</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">unique</span><span class="special">(</span><span class="identifier">vec</span><span class="special">.</span><span class="identifier">begin</span><span class="special">(),</span> <span class="identifier">vec</span><span class="special">.</span><span class="identifier">end</span><span class="special">());</span>
<span class="comment">// remember this check or you get into problems
</span><span class="keyword">if</span> <span class="special">(</span><span class="identifier">i</span> <span class="special">!=</span> <span class="identifier">vec</span><span class="special">.</span><span class="identifier">end</span><span class="special">())</span>
<span class="special">++</span><span class="identifier">i</span><span class="special">;</span>
<span class="identifier">vec</span><span class="special">.</span><span class="identifier">erase</span><span class="special">(</span><span class="identifier">i</span><span class="special">,</span> <span class="identifier">vec</span><span class="special">.</span><span class="identifier">end</span><span class="special">());</span>
</pre>
<p>
</p>
<p>
The same task may be accomplished simply with
</p>
<pre class="programlisting"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">erase</span><span class="special">(</span><span class="identifier">vec</span><span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">unique</span><span class="special">&lt;</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">return_next_end</span><span class="special">&gt;(</span><span class="identifier">vec</span><span class="special">));</span>
</pre>
<p>
and there is no need to worry about generating an invalid range. Furthermore,
if the container is complex, calling <code class="computeroutput"><span class="identifier">vec</span><span class="special">.</span><span class="identifier">end</span><span class="special">()</span></code> several times will be more expensive
than using a range algorithm.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../algorithms.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithms.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mutating.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,75 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>Mutating algorithms</title>
<link rel="stylesheet" href="../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../algorithms.html" title="Range Algorithms">
<link rel="prev" href="introduction.html" title="Introduction and motivation">
<link rel="next" href="mutating/copy.html" title="copy">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="introduction.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithms.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mutating/copy.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h4 class="title">
<a name="range.reference.algorithms.mutating"></a><a class="link" href="mutating.html" title="Mutating algorithms">Mutating algorithms</a>
</h4></div></div></div>
<div class="toc"><dl>
<dt><span class="section"><a href="mutating/copy.html">copy</a></span></dt>
<dt><span class="section"><a href="mutating/copy_backward.html">copy_backward</a></span></dt>
<dt><span class="section"><a href="mutating/fill.html">fill</a></span></dt>
<dt><span class="section"><a href="mutating/fill_n.html">fill_n</a></span></dt>
<dt><span class="section"><a href="mutating/generate.html">generate</a></span></dt>
<dt><span class="section"><a href="mutating/inplace_merge.html">inplace_merge</a></span></dt>
<dt><span class="section"><a href="mutating/merge.html">merge</a></span></dt>
<dt><span class="section"><a href="mutating/nth_element.html">nth_element</a></span></dt>
<dt><span class="section"><a href="mutating/partial_sort.html">partial_sort</a></span></dt>
<dt><span class="section"><a href="mutating/partition.html">partition</a></span></dt>
<dt><span class="section"><a href="mutating/random_shuffle.html">random_shuffle</a></span></dt>
<dt><span class="section"><a href="mutating/remove.html">remove</a></span></dt>
<dt><span class="section"><a href="mutating/remove_copy.html">remove_copy</a></span></dt>
<dt><span class="section"><a href="mutating/remove_copy_if.html">remove_copy_if</a></span></dt>
<dt><span class="section"><a href="mutating/remove_if.html">remove_if</a></span></dt>
<dt><span class="section"><a href="mutating/replace.html">replace</a></span></dt>
<dt><span class="section"><a href="mutating/replace_copy.html">replace_copy</a></span></dt>
<dt><span class="section"><a href="mutating/replace_copy_if.html">replace_copy_if</a></span></dt>
<dt><span class="section"><a href="mutating/replace_if.html">replace_if</a></span></dt>
<dt><span class="section"><a href="mutating/reverse.html">reverse</a></span></dt>
<dt><span class="section"><a href="mutating/reverse_copy.html">reverse_copy</a></span></dt>
<dt><span class="section"><a href="mutating/rotate.html">rotate</a></span></dt>
<dt><span class="section"><a href="mutating/rotate_copy.html">rotate_copy</a></span></dt>
<dt><span class="section"><a href="mutating/sort.html">sort</a></span></dt>
<dt><span class="section"><a href="mutating/stable_partition.html">stable_partition</a></span></dt>
<dt><span class="section"><a href="mutating/stable_sort.html">stable_sort</a></span></dt>
<dt><span class="section"><a href="mutating/swap_ranges.html">swap_ranges</a></span></dt>
<dt><span class="section"><a href="mutating/transform.html">transform</a></span></dt>
<dt><span class="section"><a href="mutating/unique.html">unique</a></span></dt>
<dt><span class="section"><a href="mutating/unique_copy.html">unique_copy</a></span></dt>
</dl></div>
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="introduction.html"><img src="../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../algorithms.html"><img src="../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../index.html"><img src="../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="mutating/copy.html"><img src="../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,115 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>copy</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="../mutating.html" title="Mutating algorithms">
<link rel="next" href="copy_backward.html" title="copy_backward">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../mutating.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="copy_backward.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.copy"></a><a class="link" href="copy.html" title="copy">copy</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.copy.prototype"></a><h6>
<a name="id684203"></a>
<a class="link" href="copy.html#range.reference.algorithms.mutating.copy.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">SinglePassRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">copy</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">SinglePassRange</span><span class="special">&amp;</span> <span class="identifier">source_rng</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out_it</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.copy.description"></a><h6>
<a name="id684330"></a>
<a class="link" href="copy.html#range.reference.algorithms.mutating.copy.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">copy</span></code> copies all elements
from <code class="computeroutput"><span class="identifier">source_rng</span></code> to the
range <code class="computeroutput"><span class="special">[</span><span class="identifier">out_it</span><span class="special">,</span> <span class="identifier">out_it</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">source_rng</span><span class="special">))</span></code>. The return value is <code class="computeroutput"><span class="identifier">out_it</span> <span class="special">+</span>
<span class="identifier">distance</span><span class="special">(</span><span class="identifier">source_rng</span><span class="special">)</span></code>
</p>
<a name="range.reference.algorithms.mutating.copy.definition"></a><h6>
<a name="id684459"></a>
<a class="link" href="copy.html#range.reference.algorithms.mutating.copy.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.copy.requirements"></a><h6>
<a name="id684528"></a>
<a class="link" href="copy.html#range.reference.algorithms.mutating.copy.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange</span></code> is
a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">OutputIterator</span></code> is
a model of the <code class="computeroutput"><span class="identifier">OutputIteratorConcept</span></code>.
</li>
<li class="listitem">
The <code class="computeroutput"><span class="identifier">value_type</span></code> of
<a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single Pass Range</a>
Concept is convertible to a type in <code class="computeroutput"><span class="identifier">OutputIterator</span></code>'s
set of value types.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.copy.precondition_"></a><h6>
<a name="id684638"></a>
<a class="link" href="copy.html#range.reference.algorithms.mutating.copy.precondition_">Precondition:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">out_it</span></code> is not an
iterator within the <code class="computeroutput"><span class="identifier">source_rng</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">out_it</span><span class="special">,</span> <span class="identifier">out_it</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">source_rng</span><span class="special">))</span></code> is a valid range.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.copy.complexity"></a><h6>
<a name="id684744"></a>
<a class="link" href="copy.html#range.reference.algorithms.mutating.copy.complexity">Complexity</a>
</h6>
<p>
Linear. Exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">source_rng</span><span class="special">)</span></code> assignments are performed.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="../mutating.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="copy_backward.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,124 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>copy_backward</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="copy.html" title="copy">
<link rel="next" href="fill.html" title="fill">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fill.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.copy_backward"></a><a class="link" href="copy_backward.html" title="copy_backward">copy_backward</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.copy_backward.prototype"></a><h6>
<a name="id684808"></a>
<a class="link" href="copy_backward.html#range.reference.algorithms.mutating.copy_backward.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BidirectionalOutputIterator</span><span class="special">&gt;</span>
<span class="identifier">BidirectionalOutputIterator</span>
<span class="identifier">copy_backward</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">source_rng</span><span class="special">,</span>
<span class="identifier">BidirectionalOutputIterator</span> <span class="identifier">out_it</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.copy_backward.description"></a><h6>
<a name="id684936"></a>
<a class="link" href="copy_backward.html#range.reference.algorithms.mutating.copy_backward.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">copy_backward</span></code> copies
all elements from <code class="computeroutput"><span class="identifier">source_rng</span></code>
to the range <code class="computeroutput"><span class="special">[</span><span class="identifier">out_it</span>
<span class="special">-</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">source_rng</span><span class="special">),</span> <span class="identifier">out_it</span><span class="special">)</span></code>.
</p>
<p>
The values are copied in reverse order. The return value is <code class="computeroutput"><span class="identifier">out_it</span> <span class="special">-</span>
<span class="identifier">distance</span><span class="special">(</span><span class="identifier">source_rng</span><span class="special">)</span></code>.
</p>
<p>
Note well that unlike all other standard algorithms <code class="computeroutput"><span class="identifier">out_it</span></code>
denotes the <span class="bold"><strong>end</strong></span> of the output sequence.
</p>
<a name="range.reference.algorithms.mutating.copy_backward.definition"></a><h6>
<a name="id685090"></a>
<a class="link" href="copy_backward.html#range.reference.algorithms.mutating.copy_backward.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">copy_backward</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.copy_backward.requirements"></a><h6>
<a name="id685160"></a>
<a class="link" href="copy_backward.html#range.reference.algorithms.mutating.copy_backward.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>
is a model of <a class="link" href="../../../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">OutputIterator</span></code> is
a model of the <code class="computeroutput"><span class="identifier">OutputIteratorConcept</span></code>.
</li>
<li class="listitem">
The <code class="computeroutput"><span class="identifier">value_type</span></code> of
<a class="link" href="../../../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a> Concept is convertible to a type in <code class="computeroutput"><span class="identifier">OutputIterator</span></code>'s
set of value types.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.copy_backward.precondition_"></a><h6>
<a name="id685270"></a>
<a class="link" href="copy_backward.html#range.reference.algorithms.mutating.copy_backward.precondition_">Precondition:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">out_it</span></code> is not an
iterator within the <code class="computeroutput"><span class="identifier">source_rng</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">out_it</span><span class="special">,</span> <span class="identifier">out_it</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">source_rng</span><span class="special">))</span></code> is a valid range.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.copy_backward.complexity"></a><h6>
<a name="id685378"></a>
<a class="link" href="copy_backward.html#range.reference.algorithms.mutating.copy_backward.complexity">Complexity</a>
</h6>
<p>
Linear. Exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">source_rng</span><span class="special">)</span></code> assignments are performed.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fill.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,101 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>fill</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="copy_backward.html" title="copy_backward">
<link rel="next" href="fill_n.html" title="fill_n">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="copy_backward.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fill_n.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.fill"></a><a class="link" href="fill.html" title="fill">fill</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.fill.prototype"></a><h6>
<a name="id685443"></a>
<a class="link" href="fill.html#range.reference.algorithms.mutating.fill.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span><span class="special">&gt;</span>
<span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">fill</span><span class="special">(</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">val</span> <span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.fill.description"></a><h6>
<a name="id685579"></a>
<a class="link" href="fill.html#range.reference.algorithms.mutating.fill.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">fill</span></code> assigns the value
<code class="computeroutput"><span class="identifier">val</span></code> to every element
in the range <code class="computeroutput"><span class="identifier">rng</span></code>.
</p>
<a name="range.reference.algorithms.mutating.fill.definition"></a><h6>
<a name="id685634"></a>
<a class="link" href="fill.html#range.reference.algorithms.mutating.fill.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">fill</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.fill.requirements"></a><h6>
<a name="id685703"></a>
<a class="link" href="fill.html#range.reference.algorithms.mutating.fill.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is a model
of the <code class="computeroutput"><span class="identifier">AssignableConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is convertible
to <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s
value type.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.fill.complexity"></a><h6>
<a name="id685823"></a>
<a class="link" href="fill.html#range.reference.algorithms.mutating.fill.complexity">Complexity</a>
</h6>
<p>
Linear. Exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> assignments are performed.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="copy_backward.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="fill_n.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,101 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>fill_n</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="fill.html" title="fill">
<link rel="next" href="generate.html" title="generate">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="fill.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="generate.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.fill_n"></a><a class="link" href="fill_n.html" title="fill_n">fill_n</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.fill_n.prototype"></a><h6>
<a name="id685887"></a>
<a class="link" href="fill_n.html#range.reference.algorithms.mutating.fill_n.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Size</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span><span class="special">&gt;</span>
<span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">fill</span><span class="special">(</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Size</span> <span class="identifier">n</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">val</span> <span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.fill_n.description"></a><h6>
<a name="id686056"></a>
<a class="link" href="fill_n.html#range.reference.algorithms.mutating.fill_n.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">fill_n</span></code> assigns the value
<code class="computeroutput"><span class="identifier">val</span></code> to <code class="computeroutput"><span class="identifier">n</span></code> elements in the range <code class="computeroutput"><span class="identifier">rng</span></code> begining with <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>.
</p>
<a name="range.reference.algorithms.mutating.fill_n.definition"></a><h6>
<a name="id686152"></a>
<a class="link" href="fill_n.html#range.reference.algorithms.mutating.fill_n.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">fill_n</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.fill_n.requirements"></a><h6>
<a name="id686222"></a>
<a class="link" href="fill_n.html#range.reference.algorithms.mutating.fill_n.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is a model
of the <code class="computeroutput"><span class="identifier">AssignableConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is convertible
to <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s
value type.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.fill_n.complexity"></a><h6>
<a name="id686341"></a>
<a class="link" href="fill_n.html#range.reference.algorithms.mutating.fill_n.complexity">Complexity</a>
</h6>
<p>
Linear. Exactly <code class="computeroutput"><span class="identifier">n</span></code> assignments
are performed.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="fill.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="generate.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,120 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>generate</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="fill_n.html" title="fill_n">
<link rel="next" href="inplace_merge.html" title="inplace_merge">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="fill_n.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="inplace_merge.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.generate"></a><a class="link" href="generate.html" title="generate">generate</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.generate.prototype"></a><h6>
<a name="id686391"></a>
<a class="link" href="generate.html#range.reference.algorithms.mutating.generate.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Generator</span><span class="special">&gt;</span>
<span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">generate</span><span class="special">(</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Generator</span> <span class="identifier">gen</span> <span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Generator</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">generate</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Generator</span> <span class="identifier">gen</span> <span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.generate.description"></a><h6>
<a name="id686629"></a>
<a class="link" href="generate.html#range.reference.algorithms.mutating.generate.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">generate</span></code> assigns the
result of <code class="computeroutput"><span class="identifier">gen</span><span class="special">()</span></code>
to each element in range <code class="computeroutput"><span class="identifier">rng</span></code>.
Returns the resultant range.
</p>
<a name="range.reference.algorithms.mutating.generate.definition"></a><h6>
<a name="id686689"></a>
<a class="link" href="generate.html#range.reference.algorithms.mutating.generate.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">generate</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.generate.requirements"></a><h6>
<a name="id686758"></a>
<a class="link" href="generate.html#range.reference.algorithms.mutating.generate.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Generator</span></code> is a model
of the <code class="computeroutput"><span class="identifier">GeneratorConcept</span></code>.
</li>
<li class="listitem">
The <code class="computeroutput"><span class="identifier">value_type</span></code> of
<code class="computeroutput"><span class="identifier">SinglePassRange</span></code> is
convertible to a type in <code class="computeroutput"><span class="identifier">OutputIterator</span></code>'s
set of value types.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.generate.precondition_"></a><h6>
<a name="id686889"></a>
<a class="link" href="generate.html#range.reference.algorithms.mutating.generate.precondition_">Precondition:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">out_it</span></code> is not an
iterator within <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">out_it</span><span class="special">,</span> <span class="identifier">out_it</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> is a valid range.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.generate.complexity"></a><h6>
<a name="id686995"></a>
<a class="link" href="generate.html#range.reference.algorithms.mutating.generate.complexity">Complexity</a>
</h6>
<p>
Linear. Exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> assignments are performed.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="fill_n.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="inplace_merge.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,186 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>inplace_merge</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="generate.html" title="generate">
<link rel="next" href="merge.html" title="merge">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="generate.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="merge.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.inplace_merge"></a><a class="link" href="inplace_merge.html" title="inplace_merge">inplace_merge</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.inplace_merge.prototype"></a><h6>
<a name="id687058"></a>
<a class="link" href="inplace_merge.html#range.reference.algorithms.mutating.inplace_merge.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalRange</span><span class="special">&gt;</span>
<span class="identifier">BidirectionalRange</span><span class="special">&amp;</span>
<span class="identifier">inplace_merge</span><span class="special">(</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">BidirectionalRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span> <span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span>
<span class="identifier">inplace_merge</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span> <span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="identifier">BidirectionalRange</span><span class="special">&amp;</span>
<span class="identifier">inplace_merge</span><span class="special">(</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">BidirectionalRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span><span class="special">,</span>
<span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span> <span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span>
<span class="identifier">inplace_merge</span><span class="special">(</span> <span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span><span class="special">,</span>
<span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span> <span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.inplace_merge.description"></a><h6>
<a name="id687615"></a>
<a class="link" href="inplace_merge.html#range.reference.algorithms.mutating.inplace_merge.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">inplace_merge</span></code> combines
two consecutive sorted ranges <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">)</span></code>
and <code class="computeroutput"><span class="special">[</span><span class="identifier">middle</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> into a single sorted range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>. That is, it starts with a range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> that consists of two pieces each of
which is in ascending order, and rearranges it so that the entire range
is in ascending order. <code class="computeroutput"><span class="identifier">inplace_merge</span></code>
is stable, meaning both that the relative order of elements within each
input range is preserved.
</p>
<a name="range.reference.algorithms.mutating.inplace_merge.definition"></a><h6>
<a name="id687833"></a>
<a class="link" href="inplace_merge.html#range.reference.algorithms.mutating.inplace_merge.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">inplace_merge</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.inplace_merge.requirements"></a><h6>
<a name="id687903"></a>
<a class="link" href="inplace_merge.html#range.reference.algorithms.mutating.inplace_merge.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the non-predicate version:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>
is a model of the <a class="link" href="../../../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">BidirectionalRange</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is a model of <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
</li>
<li class="listitem">
The ordering on objects of <code class="computeroutput"><span class="identifier">range_type</span><span class="special">&lt;</span><span class="identifier">BidirectionalRange</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
is a <span class="bold"><strong><span class="emphasis"><em>strict weak ordering</em></span></strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the predicate version:</strong></span> * <code class="computeroutput"><span class="identifier">BidirectionalRange</span></code> is a model of the
<a class="link" href="../../../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional Range</a>
Concept. * <code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>
is mutable. * <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>
is a model of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
* <code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>'s
value type is convertible to both <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>'s
argument types.
</p>
<a name="range.reference.algorithms.mutating.inplace_merge.precondition_"></a><h6>
<a name="id688158"></a>
<a class="link" href="inplace_merge.html#range.reference.algorithms.mutating.inplace_merge.precondition_">Precondition:</a>
</h6>
<a name="range.reference.algorithms.mutating.inplace_merge.for_the_non_predicate_version_"></a><h6>
<a name="id688178"></a>
<a class="link" href="inplace_merge.html#range.reference.algorithms.mutating.inplace_merge.for_the_non_predicate_version_">For
the non-predicate version:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">middle</span></code> is in the
range <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">)</span></code> is in ascending order. That is for
each pair of adjacent elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>,
<code class="computeroutput"><span class="identifier">y</span> <span class="special">&lt;</span>
<span class="identifier">x</span></code> is <code class="computeroutput"><span class="keyword">false</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">middle</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> is in ascending order. That is
for each pair of adjacent elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>,
<code class="computeroutput"><span class="identifier">y</span> <span class="special">&lt;</span>
<span class="identifier">x</span></code> is <code class="computeroutput"><span class="keyword">false</span></code>.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.inplace_merge.for_the_predicate_version_"></a><h6>
<a name="id688439"></a>
<a class="link" href="inplace_merge.html#range.reference.algorithms.mutating.inplace_merge.for_the_predicate_version_">For
the predicate version:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">middle</span></code> is in the
range <code class="computeroutput"><span class="identifier">rng</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">)</span></code> is in ascending order. That is for
each pair of adjacent elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>,
<code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span><span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">middle</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> is in ascending order. That is
for each pair of adjacent elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>,
<code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span><span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span></code>.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.inplace_merge.complexity"></a><h6>
<a name="id688724"></a>
<a class="link" href="inplace_merge.html#range.reference.algorithms.mutating.inplace_merge.complexity">Complexity</a>
</h6>
<p>
Worst case: <code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">N</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">N</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="generate.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="merge.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,256 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>merge</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="inplace_merge.html" title="inplace_merge">
<link rel="next" href="nth_element.html" title="nth_element">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="inplace_merge.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="nth_element.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.merge"></a><a class="link" href="merge.html" title="merge">merge</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.merge.prototype"></a><h6>
<a name="id688803"></a>
<a class="link" href="merge.html#range.reference.algorithms.mutating.merge.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">SinglePassRange1</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">SinglePassRange2</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">OutputIterator</span>
<span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">merge</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">SinglePassRange1</span><span class="special">&amp;</span> <span class="identifier">rng1</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">SinglePassRange2</span><span class="special">&amp;</span> <span class="identifier">rng2</span><span class="special">,</span>
<span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">SinglePassRange1</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">SinglePassRange2</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">BinaryPredicate</span>
<span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">merge</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">SinglePassRange1</span><span class="special">&amp;</span> <span class="identifier">rng1</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">SinglePassRange2</span><span class="special">&amp;</span> <span class="identifier">rng2</span><span class="special">,</span>
<span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
<span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.merge.description"></a><h6>
<a name="id689149"></a>
<a class="link" href="merge.html#range.reference.algorithms.mutating.merge.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">merge</span></code> combines two sorted
ranges <code class="computeroutput"><span class="identifier">rng1</span></code> and <code class="computeroutput"><span class="identifier">rng2</span></code> into a single sorted range by
copying elements. <code class="computeroutput"><span class="identifier">merge</span></code>
is stable. The return value is <code class="computeroutput"><span class="identifier">out</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">)</span></code>.
</p>
<p>
The two versions of <code class="computeroutput"><span class="identifier">merge</span></code>
differ by how they compare the elements.
</p>
<p>
The non-predicate version uses the <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;()</span></code> for the range value type. The predicate
version uses the predicate instead of <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;()</span></code>.
</p>
<a name="range.reference.algorithms.mutating.merge.definition"></a><h6>
<a name="id689324"></a>
<a class="link" href="merge.html#range.reference.algorithms.mutating.merge.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">merge</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.merge.requirements"></a><h6>
<a name="id689393"></a>
<a class="link" href="merge.html#range.reference.algorithms.mutating.merge.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the non-predicate version:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange1</span></code>
is a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange2</span></code>
is a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">SinglePassRange1</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the same as <code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">SinglePassRange2</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">SinglePassRange1</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is a model of the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>.
</li>
<li class="listitem">
The ordering on objects of <code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">SinglePassRange1</span><span class="special">&gt;::</span><span class="identifier">type</span></code>
is a <span class="bold"><strong><span class="emphasis"><em>strict weak ordering</em></span></strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">SinglePassRange1</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is convertible to a type in
<code class="computeroutput"><span class="identifier">OutputIterator</span></code>'s
set of value types.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the predicate version:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange1</span></code>
is a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange2</span></code>
is a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">SinglePassRange1</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is the same as <code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">SinglePassRange2</span><span class="special">&gt;::</span><span class="identifier">type</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BinaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange1</span></code>'s
value type is convertible to both <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>'s
argument types.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">range_value</span><span class="special">&lt;</span><span class="identifier">SinglePassRange1</span><span class="special">&gt;::</span><span class="identifier">type</span></code> is convertible to a type in
<code class="computeroutput"><span class="identifier">OutputIterator</span></code>'s
set of value types.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.merge.precondition_"></a><h6>
<a name="id689915"></a>
<a class="link" href="merge.html#range.reference.algorithms.mutating.merge.precondition_">Precondition:</a>
</h6>
<a name="range.reference.algorithms.mutating.merge.for_the_non_predicate_version_"></a><h6>
<a name="id689935"></a>
<a class="link" href="merge.html#range.reference.algorithms.mutating.merge.for_the_non_predicate_version_">For
the non-predicate version:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
The elements of <code class="computeroutput"><span class="identifier">rng1</span></code>
are in ascending order. That is, for each adjacent element pair
<code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code> of <code class="computeroutput"><span class="identifier">rng1</span></code>,
<code class="computeroutput"><span class="identifier">y</span> <span class="special">&lt;</span>
<span class="identifier">x</span> <span class="special">==</span>
<span class="keyword">false</span></code>.
</li>
<li class="listitem">
The elements of <code class="computeroutput"><span class="identifier">rng2</span></code>
are in ascending order. That is, for each adjacent element pair
<code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code> of <code class="computeroutput"><span class="identifier">rng2</span></code>,
<code class="computeroutput"><span class="identifier">y</span> <span class="special">&lt;</span>
<span class="identifier">x</span> <span class="special">==</span>
<span class="keyword">false</span></code>.
</li>
<li class="listitem">
The ranges <code class="computeroutput"><span class="identifier">rng1</span></code> and
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))</span></code>
do not overlap.
</li>
<li class="listitem">
The ranges <code class="computeroutput"><span class="identifier">rng2</span></code> and
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))</span></code>
do not overlap.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))</span></code>
is a valid range.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.merge.for_the_predicate_version_"></a><h6>
<a name="id690400"></a>
<a class="link" href="merge.html#range.reference.algorithms.mutating.merge.for_the_predicate_version_">For
the predicate version:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
The elements of <code class="computeroutput"><span class="identifier">rng1</span></code>
are in ascending order. That is, for each adjacent element pair
<code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>, of <code class="computeroutput"><span class="identifier">rng1</span></code>,
<code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span></code>.
</li>
<li class="listitem">
The elements of <code class="computeroutput"><span class="identifier">rng2</span></code>
are in ascending order. That is, for each adjacent element pair
<code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>, of <code class="computeroutput"><span class="identifier">rng2</span></code>,
<code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span></code>.
</li>
<li class="listitem">
The ranges <code class="computeroutput"><span class="identifier">rng1</span></code> and
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))</span></code>
do not overlap.
</li>
<li class="listitem">
The ranges <code class="computeroutput"><span class="identifier">rng2</span></code> and
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))</span></code>
do not overlap.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))</span></code>
is a valid range.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.merge.complexity"></a><h6>
<a name="id690889"></a>
<a class="link" href="merge.html#range.reference.algorithms.mutating.merge.complexity">Complexity</a>
</h6>
<p>
Linear. There are no comparisons if both <code class="computeroutput"><span class="identifier">rng1</span></code>
and <code class="computeroutput"><span class="identifier">rng2</span></code> are empty, otherwise
at most <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span></code>
comparisons.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="inplace_merge.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="nth_element.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,150 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>nth_element</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="merge.html" title="merge">
<link rel="next" href="partial_sort.html" title="partial_sort">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="merge.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="partial_sort.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.nth_element"></a><a class="link" href="nth_element.html" title="nth_element">nth_element</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.nth_element.prototype"></a><h6>
<a name="id691010"></a>
<a class="link" href="nth_element.html#range.reference.algorithms.mutating.nth_element.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">nth_element</span><span class="special">(</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">RandomAccessRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">nth</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">nth_element</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">nth</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">nth_element</span><span class="special">(</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">RandomAccessRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">nth</span><span class="special">,</span>
<span class="identifier">BinaryPredicate</span> <span class="identifier">sort_pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">nth_element</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">nth</span><span class="special">,</span>
<span class="identifier">BinaryPredicate</span> <span class="identifier">sort_pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.nth_element.description"></a><h6>
<a name="id691529"></a>
<a class="link" href="nth_element.html#range.reference.algorithms.mutating.nth_element.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">nth_element</span></code> partially
orders a range of elements. <code class="computeroutput"><span class="identifier">nth_element</span></code>
arranges the range <code class="computeroutput"><span class="identifier">rng</span></code>
such that the element corresponding with the iterator <code class="computeroutput"><span class="identifier">nth</span></code>
is the same as the element that would be in that position if <code class="computeroutput"><span class="identifier">rng</span></code> has been sorted.
</p>
<a name="range.reference.algorithms.mutating.nth_element.definition"></a><h6>
<a name="id691606"></a>
<a class="link" href="nth_element.html#range.reference.algorithms.mutating.nth_element.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">nth_element</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.nth_element.requirements"></a><h6>
<a name="id691676"></a>
<a class="link" href="nth_element.html#range.reference.algorithms.mutating.nth_element.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the non-predicate version:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a model of the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>.
</li>
<li class="listitem">
The ordering relation on <code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a <span class="bold"><strong><span class="emphasis"><em>strict weak ordering</em></span></strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the predicate version:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BinaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is convertible to both of <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>'s
argument types.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.nth_element.complexity"></a><h6>
<a name="id691923"></a>
<a class="link" href="nth_element.html#range.reference.algorithms.mutating.nth_element.complexity">Complexity</a>
</h6>
<p>
On average, linear in <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="merge.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="partial_sort.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,155 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>partial_sort</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="nth_element.html" title="nth_element">
<link rel="next" href="partition.html" title="partition">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="nth_element.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="partition.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.partial_sort"></a><a class="link" href="partial_sort.html" title="partial_sort">partial_sort</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.partial_sort.prototype"></a><h6>
<a name="id691988"></a>
<a class="link" href="partial_sort.html#range.reference.algorithms.mutating.partial_sort.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">partial_sort</span><span class="special">(</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">RandomAccessRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">partial_sort</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">partial_sort</span><span class="special">(</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">RandomAccessRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span><span class="special">,</span>
<span class="identifier">BinaryPredicate</span> <span class="identifier">sort_pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">partial_sort</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span><span class="special">,</span>
<span class="identifier">BinaryPredicate</span> <span class="identifier">sort_pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.partial_sort.description"></a><h6>
<a name="id692508"></a>
<a class="link" href="partial_sort.html#range.reference.algorithms.mutating.partial_sort.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">partial_sort</span></code> rearranges
the elements in <code class="computeroutput"><span class="identifier">rng</span></code>.
It places the smallest <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">)</span></code> elements, sorted in ascending order,
into the range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">)</span></code>. The remaining elements are placed in
an unspecified order into <code class="computeroutput"><span class="special">[</span><span class="identifier">middle</span><span class="special">,</span> <span class="identifier">last</span><span class="special">)</span></code>.
</p>
<p>
The non-predicative versions of this function specify that one element
is less than another by using <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;()</span></code>. The predicate versions use the
predicate instead.
</p>
<a name="range.reference.algorithms.mutating.partial_sort.definition"></a><h6>
<a name="id692685"></a>
<a class="link" href="partial_sort.html#range.reference.algorithms.mutating.partial_sort.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">partial_sort</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.partial_sort.requirements"></a><h6>
<a name="id692756"></a>
<a class="link" href="partial_sort.html#range.reference.algorithms.mutating.partial_sort.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the non-predicate version:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a model of the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>.
</li>
<li class="listitem">
The ordering relation on <code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a <span class="bold"><strong><span class="emphasis"><em>strict weak ordering</em></span></strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the predicate version:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BinaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is convertible to both of <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>'s
argument types.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.partial_sort.complexity"></a><h6>
<a name="id693003"></a>
<a class="link" href="partial_sort.html#range.reference.algorithms.mutating.partial_sort.complexity">Complexity</a>
</h6>
<p>
Approximately <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span> <span class="special">*</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">))</span></code> comparisons.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="nth_element.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="partition.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,132 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>partition</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="partial_sort.html" title="partial_sort">
<link rel="next" href="random_shuffle.html" title="random_shuffle">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="partial_sort.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="random_shuffle.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.partition"></a><a class="link" href="partition.html" title="partition">partition</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.partition.prototype"></a><h6>
<a name="id693119"></a>
<a class="link" href="partition.html#range.reference.algorithms.mutating.partition.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">partition</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">partition</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">partition</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">partition</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.partition.description"></a><h6>
<a name="id693695"></a>
<a class="link" href="partition.html#range.reference.algorithms.mutating.partition.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">partition</span></code> orders the
elements in <code class="computeroutput"><span class="identifier">rng</span></code> based
on <code class="computeroutput"><span class="identifier">pred</span></code>, such that the
elements that satisfy <code class="computeroutput"><span class="identifier">pred</span></code>
precede the elements that do not. In the versions that return a single
iterator, the return value is the middle iterator. In the versions that
have a configurable range_return, <code class="computeroutput"><span class="identifier">found</span></code>
corresponds to the middle iterator.
</p>
<a name="range.reference.algorithms.mutating.partition.definition"></a><h6>
<a name="id693774"></a>
<a class="link" href="partition.html#range.reference.algorithms.mutating.partition.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">partition</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.partition.requirements"></a><h6>
<a name="id693845"></a>
<a class="link" href="partition.html#range.reference.algorithms.mutating.partition.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">UnaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">PredicateConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s value
type is convertible to <code class="computeroutput"><span class="identifier">UnaryPredicate</span></code>'s
argument type.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.partition.complexity"></a><h6>
<a name="id693947"></a>
<a class="link" href="partition.html#range.reference.algorithms.mutating.partition.complexity">Complexity</a>
</h6>
<p>
Linear. Exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> applications of <code class="computeroutput"><span class="identifier">pred</span></code>,
and at most <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span> <span class="special">/</span> <span class="number">2</span></code>
swaps.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="partial_sort.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="random_shuffle.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,131 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>random_shuffle</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="partition.html" title="partition">
<link rel="next" href="remove.html" title="remove">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="partition.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.random_shuffle"></a><a class="link" href="random_shuffle.html" title="random_shuffle">random_shuffle</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.random_shuffle.prototype"></a><h6>
<a name="id694058"></a>
<a class="link" href="random_shuffle.html#range.reference.algorithms.mutating.random_shuffle.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">random_shuffle</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">random_shuffle</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Generator</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">random_shuffle</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Generator</span><span class="special">&amp;</span> <span class="identifier">gen</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Generator</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">random_shuffle</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">Generator</span><span class="special">&amp;</span> <span class="identifier">gen</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.random_shuffle.description"></a><h6>
<a name="id694442"></a>
<a class="link" href="random_shuffle.html#range.reference.algorithms.mutating.random_shuffle.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">random_shuffle</span></code> randomly
rearranges the elements in <code class="computeroutput"><span class="identifier">rng</span></code>.
The versions of <code class="computeroutput"><span class="identifier">random_shuffle</span></code>
that do not specify a <code class="computeroutput"><span class="identifier">Generator</span></code>
use an internal random number generator. The versions of <code class="computeroutput"><span class="identifier">random_shuffle</span></code> that do specify a <code class="computeroutput"><span class="identifier">Generator</span></code> use this instead. Returns
the shuffles range.
</p>
<a name="range.reference.algorithms.mutating.random_shuffle.definition"></a><h6>
<a name="id694530"></a>
<a class="link" href="random_shuffle.html#range.reference.algorithms.mutating.random_shuffle.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">random_shuffle</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.random_shuffle.requirements"></a><h6>
<a name="id694601"></a>
<a class="link" href="random_shuffle.html#range.reference.algorithms.mutating.random_shuffle.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the version without a Generator:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li></ul></div>
<p>
<span class="bold"><strong>For the version with a Generator:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Generator</span></code> is a model
of the <code class="computeroutput"><span class="identifier">RandomNumberGeneratorConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
distance type is convertible to <code class="computeroutput"><span class="identifier">Generator</span></code>'s
argument type.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.random_shuffle.precondition_"></a><h6>
<a name="id694751"></a>
<a class="link" href="random_shuffle.html#range.reference.algorithms.mutating.random_shuffle.precondition_">Precondition:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc"><li class="listitem">
<code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
is less than <code class="computeroutput"><span class="identifier">gen</span></code>'s
maximum value.
</li></ul></div>
<a name="range.reference.algorithms.mutating.random_shuffle.complexity"></a><h6>
<a name="id694815"></a>
<a class="link" href="random_shuffle.html#range.reference.algorithms.mutating.random_shuffle.complexity">Complexity</a>
</h6>
<p>
Linear. If <code class="computeroutput"><span class="special">!</span><span class="identifier">empty</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>, exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span> <span class="special">-</span> <span class="number">1</span></code>
swaps are performed.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="partition.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,138 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>remove</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="random_shuffle.html" title="random_shuffle">
<link rel="next" href="remove_copy.html" title="remove_copy">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="random_shuffle.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.remove"></a><a class="link" href="remove.html" title="remove">remove</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.remove.prototype"></a><h6>
<a name="id694919"></a>
<a class="link" href="remove.html#range.reference.algorithms.mutating.remove.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">Value</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">remove</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">Value</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">remove</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">Value</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">,</span><span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">remove</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">Value</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">,</span><span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">remove</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.remove.description"></a><h6>
<a name="id695536"></a>
<a class="link" href="remove.html#range.reference.algorithms.mutating.remove.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">remove</span></code> removes from
<code class="computeroutput"><span class="identifier">rng</span></code> all of the elements
<code class="computeroutput"><span class="identifier">x</span></code> for which <code class="computeroutput"><span class="identifier">x</span> <span class="special">==</span> <span class="identifier">val</span></code> is <code class="computeroutput"><span class="keyword">true</span></code>.
The versions of <code class="computeroutput"><span class="identifier">remove</span></code>
that return an iterator, return an iterator <code class="computeroutput"><span class="identifier">new_last</span></code>
such that the range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">new_last</span><span class="special">)</span></code> contains no elements equal to <code class="computeroutput"><span class="identifier">val</span></code>. The <code class="computeroutput"><span class="identifier">range_return</span></code>
versions of <code class="computeroutput"><span class="identifier">remove</span></code> defines
<code class="computeroutput"><span class="identifier">found</span></code> as the new last
element. The iterators in the range <code class="computeroutput"><span class="special">[</span><span class="identifier">new_last</span><span class="special">,</span>
<span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>
are dereferenceable, but the elements are unspecified.
</p>
<a name="range.reference.algorithms.mutating.remove.definition"></a><h6>
<a name="id695762"></a>
<a class="link" href="remove.html#range.reference.algorithms.mutating.remove.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.remove.requirements"></a><h6>
<a name="id695833"></a>
<a class="link" href="remove.html#range.reference.algorithms.mutating.remove.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is a model
of the <code class="computeroutput"><span class="identifier">EqualityComparableConcept</span></code>.
</li>
<li class="listitem">
Objects of type <code class="computeroutput"><span class="identifier">Value</span></code>
can be compared for equality with objects of <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s
value type.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.remove.complexity"></a><h6>
<a name="id695954"></a>
<a class="link" href="remove.html#range.reference.algorithms.mutating.remove.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">remove</span></code> performs
exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
comparisons for equality.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="random_shuffle.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,108 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>remove_copy</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="remove.html" title="remove">
<link rel="next" href="remove_copy_if.html" title="remove_copy_if">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="remove.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_copy_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.remove_copy"></a><a class="link" href="remove_copy.html" title="remove_copy">remove_copy</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.remove_copy.prototype"></a><h6>
<a name="id696029"></a>
<a class="link" href="remove_copy.html#range.reference.algorithms.mutating.remove_copy.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Outputiterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span>
<span class="identifier">remove_copy</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span>
<span class="identifier">remove_copy</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">val</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.remove_copy.description"></a><h6>
<a name="id696332"></a>
<a class="link" href="remove_copy.html#range.reference.algorithms.mutating.remove_copy.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">remove_copy</span></code> copied all
of the elements <code class="computeroutput"><span class="identifier">x</span></code> from
<code class="computeroutput"><span class="identifier">rng</span></code> for which <code class="computeroutput"><span class="identifier">x</span> <span class="special">==</span> <span class="identifier">val</span></code> is <code class="computeroutput"><span class="keyword">false</span></code>.
</p>
<a name="range.reference.algorithms.mutating.remove_copy.definition"></a><h6>
<a name="id696418"></a>
<a class="link" href="remove_copy.html#range.reference.algorithms.mutating.remove_copy.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove_copy</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.remove_copy.requirements"></a><h6>
<a name="id696488"></a>
<a class="link" href="remove_copy.html#range.reference.algorithms.mutating.remove_copy.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is a model
of the <code class="computeroutput"><span class="identifier">EqualityComparableConcept</span></code>.
</li>
<li class="listitem">
Objects of type <code class="computeroutput"><span class="identifier">Value</span></code>
can be compared for equality with objects of <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s
value type.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.remove_copy.complexity"></a><h6>
<a name="id696609"></a>
<a class="link" href="remove_copy.html#range.reference.algorithms.mutating.remove_copy.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">remove_copy</span></code> performs
exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
comparisons for equality.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="remove.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_copy_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,103 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>remove_copy_if</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="remove_copy.html" title="remove_copy">
<link rel="next" href="remove_if.html" title="remove_if">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="remove_copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.remove_copy_if"></a><a class="link" href="remove_copy_if.html" title="remove_copy_if">remove_copy_if</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.remove_copy_if.prototype"></a><h6>
<a name="id696683"></a>
<a class="link" href="remove_copy_if.html#range.reference.algorithms.mutating.remove_copy_if.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Outputiterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">UnaryPred</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span>
<span class="identifier">remove_copy_if</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span> <span class="identifier">UnaryPred</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">UnaryPred</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span>
<span class="identifier">remove_copy_if</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span> <span class="identifier">UnaryPred</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.remove_copy_if.description"></a><h6>
<a name="id696964"></a>
<a class="link" href="remove_copy_if.html#range.reference.algorithms.mutating.remove_copy_if.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">remove_copy_if</span></code> copied
all of the elements <code class="computeroutput"><span class="identifier">x</span></code>
from <code class="computeroutput"><span class="identifier">rng</span></code> for which <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
is <code class="computeroutput"><span class="keyword">false</span></code>.
</p>
<a name="range.reference.algorithms.mutating.remove_copy_if.definition"></a><h6>
<a name="id697054"></a>
<a class="link" href="remove_copy_if.html#range.reference.algorithms.mutating.remove_copy_if.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove_copy_if</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.remove_copy_if.requirements"></a><h6>
<a name="id697124"></a>
<a class="link" href="remove_copy_if.html#range.reference.algorithms.mutating.remove_copy_if.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">UnaryPred</span></code> is a model
of the <code class="computeroutput"><span class="identifier">UnaryPredicateConcept</span></code>.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.remove_copy_if.complexity"></a><h6>
<a name="id697217"></a>
<a class="link" href="remove_copy_if.html#range.reference.algorithms.mutating.remove_copy_if.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">remove_copy_if</span></code>
performs exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> comparisons with UnaryPred.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="remove_copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="remove_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,137 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>remove_if</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="remove_copy_if.html" title="remove_copy_if">
<link rel="next" href="replace.html" title="replace">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="remove_copy_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replace.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.remove_if"></a><a class="link" href="remove_if.html" title="remove_if">remove_if</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.remove_if.prototype"></a><h6>
<a name="id697291"></a>
<a class="link" href="remove_if.html#range.reference.algorithms.mutating.remove_if.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">remove</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">remove</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">,</span><span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">remove</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">,</span><span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">remove</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.remove_if.description"></a><h6>
<a name="id697867"></a>
<a class="link" href="remove_if.html#range.reference.algorithms.mutating.remove_if.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">remove_if</span></code> removes from
<code class="computeroutput"><span class="identifier">rng</span></code> all of the elements
<code class="computeroutput"><span class="identifier">x</span></code> for which <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
is <code class="computeroutput"><span class="keyword">true</span></code>. The versions of
<code class="computeroutput"><span class="identifier">remove_if</span></code> that return
an iterator, return an iterator <code class="computeroutput"><span class="identifier">new_last</span></code>
such that the range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">new_last</span><span class="special">)</span></code> contains no elements where <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code>
is <code class="computeroutput"><span class="keyword">true</span></code>. The iterators in
the range <code class="computeroutput"><span class="special">[</span><span class="identifier">new_last</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> are dereferenceable, but the elements
are unspecified.
</p>
<a name="range.reference.algorithms.mutating.remove_if.definition"></a><h6>
<a name="id698089"></a>
<a class="link" href="remove_if.html#range.reference.algorithms.mutating.remove_if.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">remove_if</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.remove_if.requirements"></a><h6>
<a name="id698160"></a>
<a class="link" href="remove_if.html#range.reference.algorithms.mutating.remove_if.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">UnaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">PredicateConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s value
type is convertible to <code class="computeroutput"><span class="identifier">UnaryPredicate</span></code>'s
argument type.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.remove_if.complexity"></a><h6>
<a name="id698282"></a>
<a class="link" href="remove_if.html#range.reference.algorithms.mutating.remove_if.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">remove_if</span></code> performs
exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
applications of <code class="computeroutput"><span class="identifier">pred</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="remove_copy_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replace.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,118 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>replace</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="remove_if.html" title="remove_if">
<link rel="next" href="replace_copy.html" title="replace_copy">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="remove_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replace_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.replace"></a><a class="link" href="replace.html" title="replace">replace</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.replace.prototype"></a><h6>
<a name="id698368"></a>
<a class="link" href="replace.html#range.reference.algorithms.mutating.replace.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">Value</span>
<span class="special">&gt;</span>
<span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">replace</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">what</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">with_what</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">replace</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">what</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">with_what</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.replace.description"></a><h6>
<a name="id698680"></a>
<a class="link" href="replace.html#range.reference.algorithms.mutating.replace.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">replace</span></code> every element
in <code class="computeroutput"><span class="identifier">rng</span></code> equal to <code class="computeroutput"><span class="identifier">what</span></code> with <code class="computeroutput"><span class="identifier">with_what</span></code>.
Return a reference to <code class="computeroutput"><span class="identifier">rng</span></code>.
</p>
<a name="range.reference.algorithms.mutating.replace.definition"></a><h6>
<a name="id698755"></a>
<a class="link" href="replace.html#range.reference.algorithms.mutating.replace.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.replace.requirements"></a><h6>
<a name="id698825"></a>
<a class="link" href="replace.html#range.reference.algorithms.mutating.replace.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is convertible
to <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s
value type.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is a model
of the <code class="computeroutput"><span class="identifier">AssignableConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is a model
of the <code class="computeroutput"><span class="identifier">EqualityComparableConcept</span></code>,
and may be compared for equality with objects of <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s
value type.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.replace.complexity"></a><h6>
<a name="id698985"></a>
<a class="link" href="replace.html#range.reference.algorithms.mutating.replace.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">replace</span></code> performs
exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
comparisons for equality and at most <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> assignments.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="remove_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replace_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,111 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>replace_copy</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="replace.html" title="replace">
<link rel="next" href="replace_copy_if.html" title="replace_copy_if">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replace.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replace_copy_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.replace_copy"></a><a class="link" href="replace_copy.html" title="replace_copy">replace_copy</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.replace_copy.prototype"></a><h6>
<a name="id699084"></a>
<a class="link" href="replace_copy.html#range.reference.algorithms.mutating.replace_copy.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">replace_copy</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">what</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">with_what</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.replace_copy.description"></a><h6>
<a name="id699279"></a>
<a class="link" href="replace_copy.html#range.reference.algorithms.mutating.replace_copy.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">replace_copy</span></code> copy every
element <code class="computeroutput"><span class="identifier">x</span></code> in <code class="computeroutput"><span class="identifier">rng</span></code> such that the corresponding element
in the output range <code class="computeroutput"><span class="identifier">y</span></code>
is <code class="computeroutput"><span class="identifier">x</span> <span class="special">==</span>
<span class="identifier">what</span> <span class="special">?</span>
<span class="identifier">with_what</span> <span class="special">:</span>
<span class="identifier">x</span></code>.
</p>
<a name="range.reference.algorithms.mutating.replace_copy.definition"></a><h6>
<a name="id699388"></a>
<a class="link" href="replace_copy.html#range.reference.algorithms.mutating.replace_copy.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace_copy</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.replace_copy.requirements"></a><h6>
<a name="id699458"></a>
<a class="link" href="replace_copy.html#range.reference.algorithms.mutating.replace_copy.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is convertible
to <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s
value type.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is a model
of the <code class="computeroutput"><span class="identifier">AssignableConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">OutputIterator</span></code> is
a model of the <code class="computeroutput"><span class="identifier">OutputIteratorConcept</span></code>.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.replace_copy.complexity"></a><h6>
<a name="id699606"></a>
<a class="link" href="replace_copy.html#range.reference.algorithms.mutating.replace_copy.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">replace_copy</span></code>
performs exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replace.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replace_copy_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,113 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>replace_copy_if</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="replace_copy.html" title="replace_copy">
<link rel="next" href="replace_if.html" title="replace_if">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replace_copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replace_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.replace_copy_if"></a><a class="link" href="replace_copy_if.html" title="replace_copy_if">replace_copy_if</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.replace_copy_if.prototype"></a><h6>
<a name="id699680"></a>
<a class="link" href="replace_copy_if.html#range.reference.algorithms.mutating.replace_copy_if.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">UnaryPredicate</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">replace_copy_if</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
<span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">with_what</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.replace_copy_if.description"></a><h6>
<a name="id699881"></a>
<a class="link" href="replace_copy_if.html#range.reference.algorithms.mutating.replace_copy_if.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">replace_copy_if</span></code> copy
every element <code class="computeroutput"><span class="identifier">x</span></code> in <code class="computeroutput"><span class="identifier">rng</span></code> such that the corresponding element
in the output range <code class="computeroutput"><span class="identifier">y</span></code>
is <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">?</span> <span class="identifier">with_what</span>
<span class="special">:</span> <span class="identifier">x</span></code>.
</p>
<a name="range.reference.algorithms.mutating.replace_copy_if.definition"></a><h6>
<a name="id699992"></a>
<a class="link" href="replace_copy_if.html#range.reference.algorithms.mutating.replace_copy_if.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace_copy_if</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.replace_copy_if.requirements"></a><h6>
<a name="id700063"></a>
<a class="link" href="replace_copy_if.html#range.reference.algorithms.mutating.replace_copy_if.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is convertible
to <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s
value type.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is a model
of the <code class="computeroutput"><span class="identifier">AssignableConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">OutputIterator</span></code> is
a model of the <code class="computeroutput"><span class="identifier">OutputIteratorConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">UnaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">UnaryPredicateConcept</span></code>.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.replace_copy_if.complexity"></a><h6>
<a name="id700239"></a>
<a class="link" href="replace_copy_if.html#range.reference.algorithms.mutating.replace_copy_if.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">replace_copy_if</span></code>
performs exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> evaluations of <code class="computeroutput"><span class="identifier">pred</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replace_copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="replace_if.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,116 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>replace_if</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="replace_copy_if.html" title="replace_copy_if">
<link rel="next" href="reverse.html" title="reverse">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replace_copy_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reverse.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.replace_if"></a><a class="link" href="replace_if.html" title="replace_if">replace_if</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.replace_if.prototype"></a><h6>
<a name="id700324"></a>
<a class="link" href="replace_if.html#range.reference.algorithms.mutating.replace_if.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">UnaryPredicate</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span><span class="special">&gt;</span>
<span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">replace_if</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">with_what</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">UnaryPredicate</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Value</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">replace_if</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Value</span><span class="special">&amp;</span> <span class="identifier">with_what</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.replace_if.description"></a><h6>
<a name="id700643"></a>
<a class="link" href="replace_if.html#range.reference.algorithms.mutating.replace_if.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">replace_if</span></code> replaces every
element <code class="computeroutput"><span class="identifier">x</span></code> in <code class="computeroutput"><span class="identifier">rng</span></code> for which <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">true</span></code> with <code class="computeroutput"><span class="identifier">with_what</span></code>.
Returns a reference to <code class="computeroutput"><span class="identifier">rng</span></code>.
</p>
<a name="range.reference.algorithms.mutating.replace_if.definition"></a><h6>
<a name="id700754"></a>
<a class="link" href="replace_if.html#range.reference.algorithms.mutating.replace_if.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">replace_if</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.replace_if.requirements"></a><h6>
<a name="id700825"></a>
<a class="link" href="replace_if.html#range.reference.algorithms.mutating.replace_if.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">UnaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">PredicateConcept</span></code>
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s value
type is convertible to <code class="computeroutput"><span class="identifier">UnaryPredicate</span></code>'s
argument type.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is convertible
to <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s
value type.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">Value</span></code> is a model
of the <code class="computeroutput"><span class="identifier">AssignableConcept</span></code>.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.replace_if.complexity"></a><h6>
<a name="id701001"></a>
<a class="link" href="replace_if.html#range.reference.algorithms.mutating.replace_if.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">replace_if</span></code> performs
exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
applications of <code class="computeroutput"><span class="identifier">pred</span></code>,
and at most <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> assignments.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replace_copy_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reverse.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,96 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>reverse</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="replace_if.html" title="replace_if">
<link rel="next" href="reverse_copy.html" title="reverse_copy">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replace_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reverse_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.reverse"></a><a class="link" href="reverse.html" title="reverse">reverse</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.reverse.prototype"></a><h6>
<a name="id701111"></a>
<a class="link" href="reverse.html#range.reference.algorithms.mutating.reverse.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalRange</span><span class="special">&gt;</span>
<span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">reverse</span><span class="special">(</span><span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">reverse</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.reverse.description"></a><h6>
<a name="id701281"></a>
<a class="link" href="reverse.html#range.reference.algorithms.mutating.reverse.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">reverse</span></code> reverses a range.
Returns a reference to the reversed range.
</p>
<a name="range.reference.algorithms.mutating.reverse.definition"></a><h6>
<a name="id701314"></a>
<a class="link" href="reverse.html#range.reference.algorithms.mutating.reverse.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">reverse</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.reverse.requirements"></a><h6>
<a name="id701385"></a>
<a class="link" href="reverse.html#range.reference.algorithms.mutating.reverse.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>
is a model of the <a class="link" href="../../../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>
is mutable.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.reverse.complexity"></a><h6>
<a name="id701451"></a>
<a class="link" href="reverse.html#range.reference.algorithms.mutating.reverse.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">reverse</span></code> makes
<code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)/</span><span class="number">2</span></code> calls to <code class="computeroutput"><span class="identifier">iter_swap</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="replace_if.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="reverse_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,100 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>reverse_copy</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="reverse.html" title="reverse">
<link rel="next" href="rotate.html" title="rotate">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="reverse.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rotate.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.reverse_copy"></a><a class="link" href="reverse_copy.html" title="reverse_copy">reverse_copy</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.reverse_copy.prototype"></a><h6>
<a name="id701540"></a>
<a class="link" href="reverse_copy.html#range.reference.algorithms.mutating.reverse_copy.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">BidirectionalRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">reverse_copy</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">BidirectionalRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.reverse_copy.description"></a><h6>
<a name="id701667"></a>
<a class="link" href="reverse_copy.html#range.reference.algorithms.mutating.reverse_copy.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">reverse_copy</span></code> copies the
elements from <code class="computeroutput"><span class="identifier">rng</span></code> in
reverse order to <code class="computeroutput"><span class="identifier">out</span></code>.
Returns the output iterator one passed the last copied element.
</p>
<a name="range.reference.algorithms.mutating.reverse_copy.definition"></a><h6>
<a name="id701723"></a>
<a class="link" href="reverse_copy.html#range.reference.algorithms.mutating.reverse_copy.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">reverse_copy</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.reverse_copy.requirements"></a><h6>
<a name="id701792"></a>
<a class="link" href="reverse_copy.html#range.reference.algorithms.mutating.reverse_copy.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>
is a model of the <a class="link" href="../../../concepts/bidirectional_range.html" title="Bidirectional Range">Bidirectional
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BidirectionalRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">OutputIterator</span></code> is
a model of the <code class="computeroutput"><span class="identifier">OutputIteratorConcept</span></code>.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.reverse_copy.complexity"></a><h6>
<a name="id701885"></a>
<a class="link" href="reverse_copy.html#range.reference.algorithms.mutating.reverse_copy.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">reverse_copy</span></code>
makes <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
copies.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="reverse.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rotate.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,109 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>rotate</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="reverse_copy.html" title="reverse_copy">
<link rel="next" href="rotate_copy.html" title="rotate_copy">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="reverse_copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rotate_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.rotate"></a><a class="link" href="rotate.html" title="rotate">rotate</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.rotate.prototype"></a><h6>
<a name="id701961"></a>
<a class="link" href="rotate.html#range.reference.algorithms.mutating.rotate.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">&gt;</span>
<span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rotate</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rotate</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.rotate.description"></a><h6>
<a name="id702217"></a>
<a class="link" href="rotate.html#range.reference.algorithms.mutating.rotate.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">rotate</span></code> rotates the elements
in a range. It exchanges the two ranges <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">)</span></code>
and <code class="computeroutput"><span class="special">[</span><span class="identifier">middle</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>. Returns a reference to <code class="computeroutput"><span class="identifier">rng</span></code>.
</p>
<a name="range.reference.algorithms.mutating.rotate.definition"></a><h6>
<a name="id702338"></a>
<a class="link" href="rotate.html#range.reference.algorithms.mutating.rotate.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">rotate</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.rotate.requirements"></a><h6>
<a name="id702407"></a>
<a class="link" href="rotate.html#range.reference.algorithms.mutating.rotate.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.rotate.precondition_"></a><h6>
<a name="id702473"></a>
<a class="link" href="rotate.html#range.reference.algorithms.mutating.rotate.precondition_">Precondition:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">)</span></code> is a valid range.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">middle</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> is a valid range.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.rotate.complexity"></a><h6>
<a name="id702586"></a>
<a class="link" href="rotate.html#range.reference.algorithms.mutating.rotate.complexity">Complexity</a>
</h6>
<p>
Linear. At most <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> swaps are performed.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="reverse_copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="rotate_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,111 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>rotate_copy</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="rotate.html" title="rotate">
<link rel="next" href="sort.html" title="sort">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rotate.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="sort.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.rotate_copy"></a><a class="link" href="rotate_copy.html" title="rotate_copy">rotate_copy</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.rotate_copy.prototype"></a><h6>
<a name="id702649"></a>
<a class="link" href="rotate_copy.html#range.reference.algorithms.mutating.rotate_copy.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">rotate_copy</span><span class="special">(</span>
<span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span> <span class="identifier">middle</span><span class="special">,</span>
<span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.rotate_copy.description"></a><h6>
<a name="id702817"></a>
<a class="link" href="rotate_copy.html#range.reference.algorithms.mutating.rotate_copy.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">rotate_copy</span></code> rotates the
elements in a range. It copies the two ranges <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">)</span></code>
and <code class="computeroutput"><span class="special">[</span><span class="identifier">middle</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> to <code class="computeroutput"><span class="identifier">out</span></code>.
</p>
<a name="range.reference.algorithms.mutating.rotate_copy.definition"></a><h6>
<a name="id702938"></a>
<a class="link" href="rotate_copy.html#range.reference.algorithms.mutating.rotate_copy.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">rotate_copy</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.rotate_copy.requirements"></a><h6>
<a name="id703007"></a>
<a class="link" href="rotate_copy.html#range.reference.algorithms.mutating.rotate_copy.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">OutputIterator</span></code> is
a model of the <code class="computeroutput"><span class="identifier">OutputIteratorConcept</span></code>.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.rotate_copy.precondition_"></a><h6>
<a name="id703100"></a>
<a class="link" href="rotate_copy.html#range.reference.algorithms.mutating.rotate_copy.precondition_">Precondition:</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng</span><span class="special">),</span> <span class="identifier">middle</span><span class="special">)</span></code> is a valid range.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">middle</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code> is a valid range.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.rotate_copy.complexity"></a><h6>
<a name="id703212"></a>
<a class="link" href="rotate_copy.html#range.reference.algorithms.mutating.rotate_copy.complexity">Complexity</a>
</h6>
<p>
Linear. Exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code> elements are copied.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rotate.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="sort.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,153 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>sort</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="rotate_copy.html" title="rotate_copy">
<link rel="next" href="stable_partition.html" title="stable_partition">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rotate_copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="stable_partition.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.sort"></a><a class="link" href="sort.html" title="sort">sort</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.sort.prototype"></a><h6>
<a name="id703276"></a>
<a class="link" href="sort.html#range.reference.algorithms.mutating.sort.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">sort</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">sort</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">sort</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">sort</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.sort.description"></a><h6>
<a name="id703652"></a>
<a class="link" href="sort.html#range.reference.algorithms.mutating.sort.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">sort</span></code> sorts the elements
in <code class="computeroutput"><span class="identifier">rng</span></code> into ascending
order. <code class="computeroutput"><span class="identifier">sort</span></code> is not guaranteed
to be stable. Returns the sorted range.
</p>
<p>
For versions of the <code class="computeroutput"><span class="identifier">sort</span></code>
function without a predicate, ascending order is defined by <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;()</span></code>
such that for all adjacent elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>,
<code class="computeroutput"><span class="identifier">y</span> <span class="special">&lt;</span>
<span class="identifier">x</span> <span class="special">==</span>
<span class="keyword">false</span></code>.
</p>
<p>
For versions of the <code class="computeroutput"><span class="identifier">sort</span></code>
function with a predicate, ascending order is defined by <code class="computeroutput"><span class="identifier">pred</span></code> such that for all adjacent elements
<code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>, <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span> <span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span></code>.
</p>
<a name="range.reference.algorithms.mutating.sort.definition"></a><h6>
<a name="id703896"></a>
<a class="link" href="sort.html#range.reference.algorithms.mutating.sort.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">sort</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.sort.requirements"></a><h6>
<a name="id703965"></a>
<a class="link" href="sort.html#range.reference.algorithms.mutating.sort.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For versions of sort without a predicate:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a model of the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>.
</li>
<li class="listitem">
The ordering relation on <code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a <span class="bold"><strong>strict weak ordering</strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
</ul></div>
<p>
<span class="bold"><strong>For versions of sort with a predicate</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BinaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is convertible to both of <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>'s
argument types.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.sort.complexity"></a><h6>
<a name="id704212"></a>
<a class="link" href="sort.html#range.reference.algorithms.mutating.sort.complexity">Complexity</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">N</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">N</span><span class="special">))</span></code> comparisons (both average and worst-case),
where <code class="computeroutput"><span class="identifier">N</span></code> is <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="rotate_copy.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="stable_partition.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,134 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>stable_partition</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="sort.html" title="sort">
<link rel="next" href="stable_sort.html" title="stable_sort">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="sort.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="stable_sort.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.stable_partition"></a><a class="link" href="stable_partition.html" title="stable_partition">stable_partition</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.stable_partition.prototype"></a><h6>
<a name="id704324"></a>
<a class="link" href="stable_partition.html#range.reference.algorithms.mutating.stable_partition.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">UnaryPredicate</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">stable_partition</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">UnaryPredicate</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_iterator</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">stable_partition</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">stable_partition</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryPredicate</span>
<span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">stable_partition</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">UnaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.stable_partition.description"></a><h6>
<a name="id704898"></a>
<a class="link" href="stable_partition.html#range.reference.algorithms.mutating.stable_partition.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">stable_partition</span></code> reorders
the elements in the range <code class="computeroutput"><span class="identifier">rng</span></code>
base on the function object <code class="computeroutput"><span class="identifier">pred</span></code>.
Once this function has completed all of the elements that satisfy <code class="computeroutput"><span class="identifier">pred</span></code> appear before all of the elements
that fail to satisfy it. <code class="computeroutput"><span class="identifier">stable_partition</span></code>
differs from <code class="computeroutput"><span class="identifier">partition</span></code>
because it preserves relative order. It is stable.
</p>
<p>
For the versions that return an iterator, the return value is the iterator
to the first element that fails to satisfy <code class="computeroutput"><span class="identifier">pred</span></code>.
</p>
<p>
For versions that return a <code class="computeroutput"><span class="identifier">range_return</span></code>,
the <code class="computeroutput"><span class="identifier">found</span></code> iterator is
the iterator to the first element that fails to satisfy <code class="computeroutput"><span class="identifier">pred</span></code>.
</p>
<a name="range.reference.algorithms.mutating.stable_partition.definition"></a><h6>
<a name="id705039"></a>
<a class="link" href="stable_partition.html#range.reference.algorithms.mutating.stable_partition.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">stable_partition</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.stable_partition.requirements"></a><h6>
<a name="id705110"></a>
<a class="link" href="stable_partition.html#range.reference.algorithms.mutating.stable_partition.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">UnaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">PredicateConcept</span></code>.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.stable_partition.complexity"></a><h6>
<a name="id705203"></a>
<a class="link" href="stable_partition.html#range.reference.algorithms.mutating.stable_partition.complexity">Complexity</a>
</h6>
<p>
Best case: <code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">N</span><span class="special">)</span></code>
where <code class="computeroutput"><span class="identifier">N</span></code> is <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>.
Worst case: <code class="computeroutput"><span class="identifier">N</span> <span class="special">*</span>
<span class="identifier">log</span><span class="special">(</span><span class="identifier">N</span><span class="special">)</span></code>
swaps, where <code class="computeroutput"><span class="identifier">N</span></code> is <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="sort.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="stable_sort.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,156 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>stable_sort</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="stable_partition.html" title="stable_partition">
<link rel="next" href="swap_ranges.html" title="swap_ranges">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="stable_partition.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="swap_ranges.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.stable_sort"></a><a class="link" href="stable_sort.html" title="stable_sort">stable_sort</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.stable_sort.prototype"></a><h6>
<a name="id705369"></a>
<a class="link" href="stable_sort.html#range.reference.algorithms.mutating.stable_sort.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">stable_sort</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">stable_sort</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">stable_sort</span><span class="special">(</span><span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">RandomAccessRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">stable_sort</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">RandomAccessRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.stable_sort.description"></a><h6>
<a name="id705745"></a>
<a class="link" href="stable_sort.html#range.reference.algorithms.mutating.stable_sort.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">stable_sort</span></code> sorts the
elements in <code class="computeroutput"><span class="identifier">rng</span></code> into
ascending order. <code class="computeroutput"><span class="identifier">stable_sort</span></code>
is guaranteed to be stable. The order is preserved for equivalent elements.
</p>
<p>
For versions of the <code class="computeroutput"><span class="identifier">stable_sort</span></code>
function without a predicate ascending order is defined by <code class="computeroutput"><span class="keyword">operator</span><span class="special">&lt;()</span></code>
such that for all adjacent elements <code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>,
<code class="computeroutput"><span class="identifier">y</span> <span class="special">&lt;</span>
<span class="identifier">x</span> <span class="special">==</span>
<span class="keyword">false</span></code>.
</p>
<p>
For versions of the <code class="computeroutput"><span class="identifier">stable_sort</span></code>
function with a predicate, ascending order is designed by <code class="computeroutput"><span class="identifier">pred</span></code> such that for all adjacent elements
<code class="computeroutput"><span class="special">[</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">]</span></code>, <code class="computeroutput"><span class="identifier">pred</span><span class="special">(</span><span class="identifier">y</span><span class="special">,</span><span class="identifier">x</span><span class="special">)</span> <span class="special">==</span> <span class="keyword">false</span></code>.
</p>
<a name="range.reference.algorithms.mutating.stable_sort.definition"></a><h6>
<a name="id705989"></a>
<a class="link" href="stable_sort.html#range.reference.algorithms.mutating.stable_sort.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">stable_sort</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.stable_sort.requirements"></a><h6>
<a name="id706060"></a>
<a class="link" href="stable_sort.html#range.reference.algorithms.mutating.stable_sort.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For versions of stable_sort without a predicate</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a model of the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>.
</li>
<li class="listitem">
The ordering relation on <code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is a <span class="bold"><strong>strict weak ordering</strong></span>,
as defined in the <code class="computeroutput"><span class="identifier">LessThanComparableConcept</span></code>
requirements.
</li>
</ul></div>
<p>
<span class="bold"><strong>For versions of stable_sort with a predicate:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is a model of the <a class="link" href="../../../concepts/random_access_range.html" title="Random Access Range">Random
Access Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BinaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">StrictWeakOrderingConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">RandomAccessRange</span></code>'s
value type is convertible to both of <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>'s
argument types.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.stable_sort.complexity"></a><h6>
<a name="id706307"></a>
<a class="link" href="stable_sort.html#range.reference.algorithms.mutating.stable_sort.complexity">Complexity</a>
</h6>
<p>
Best case: <code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">N</span><span class="special">)</span></code>
where <code class="computeroutput"><span class="identifier">N</span></code> is <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>.
Worst case: <code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">N</span> <span class="identifier">log</span><span class="special">(</span><span class="identifier">N</span><span class="special">)^</span><span class="number">2</span><span class="special">)</span></code>
comparisons, where <code class="computeroutput"><span class="identifier">N</span></code>
is <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="stable_partition.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="swap_ranges.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,103 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>swap_ranges</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="stable_sort.html" title="stable_sort">
<link rel="next" href="transform.html" title="transform">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="stable_sort.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="transform.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.swap_ranges"></a><a class="link" href="swap_ranges.html" title="swap_ranges">swap_ranges</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.swap_ranges.prototype"></a><h6>
<a name="id706485"></a>
<a class="link" href="swap_ranges.html#range.reference.algorithms.mutating.swap_ranges.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">SinglePassRange1</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">SinglePassRange2</span><span class="special">&gt;</span>
<span class="identifier">SinglePassRange2</span><span class="special">&amp;</span> <span class="identifier">swap_ranges</span><span class="special">(</span><span class="identifier">SinglePassRange1</span><span class="special">&amp;</span> <span class="identifier">rng1</span><span class="special">,</span> <span class="identifier">SinglePassRange</span><span class="special">&amp;</span> <span class="identifier">rng2</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.swap_ranges.description"></a><h6>
<a name="id706616"></a>
<a class="link" href="swap_ranges.html#range.reference.algorithms.mutating.swap_ranges.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">swap_ranges</span></code> swaps each
element <code class="computeroutput"><span class="identifier">x</span></code> in <code class="computeroutput"><span class="identifier">rng1</span></code> with the corresponding element
<code class="computeroutput"><span class="identifier">y</span></code> in <code class="computeroutput"><span class="identifier">rng2</span></code>.
Returns a reference to <code class="computeroutput"><span class="identifier">rng2</span></code>.
</p>
<a name="range.reference.algorithms.mutating.swap_ranges.definition"></a><h6>
<a name="id706703"></a>
<a class="link" href="swap_ranges.html#range.reference.algorithms.mutating.swap_ranges.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">swap_ranges</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.swap_ranges.requirements"></a><h6>
<a name="id706773"></a>
<a class="link" href="swap_ranges.html#range.reference.algorithms.mutating.swap_ranges.requirements">Requirements</a>
</h6>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange1</span></code>
is a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange1</span></code>
is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange2</span></code>
is a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange2</span></code>
is mutable.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.swap_ranges.complexity"></a><h6>
<a name="id706880"></a>
<a class="link" href="swap_ranges.html#range.reference.algorithms.mutating.swap_ranges.complexity">Complexity</a>
</h6>
<p>
Linear. Exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span></code> elements are swapped.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="stable_sort.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="transform.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,227 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>transform</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="swap_ranges.html" title="swap_ranges">
<link rel="next" href="unique.html" title="unique">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="swap_ranges.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unique.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.transform"></a><a class="link" href="transform.html" title="transform">transform</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.transform.prototype"></a><h6>
<a name="id706944"></a>
<a class="link" href="transform.html#range.reference.algorithms.mutating.transform.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">SinglePassRange1</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">UnaryOperation</span>
<span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">transform</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">SinglePassRange1</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span>
<span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
<span class="identifier">UnaryOperation</span> <span class="identifier">fun</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span>
<span class="keyword">class</span> <span class="identifier">SinglePassRange1</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">SinglePassRange2</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">OutputIterator</span><span class="special">,</span>
<span class="keyword">class</span> <span class="identifier">BinaryOperation</span>
<span class="special">&gt;</span>
<span class="identifier">OutputIterator</span> <span class="identifier">transform</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">SinglePassRange1</span><span class="special">&amp;</span> <span class="identifier">rng1</span><span class="special">,</span>
<span class="keyword">const</span> <span class="identifier">SinglePassRange2</span><span class="special">&amp;</span> <span class="identifier">rng2</span><span class="special">,</span>
<span class="identifier">OutputIterator</span> <span class="identifier">out</span><span class="special">,</span>
<span class="identifier">BinaryOperation</span> <span class="identifier">fun</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.transform.description"></a><h6>
<a name="id707279"></a>
<a class="link" href="transform.html#range.reference.algorithms.mutating.transform.description">Description</a>
</h6>
<p>
<span class="bold"><strong>UnaryOperation version:</strong></span>
</p>
<p>
<code class="computeroutput"><span class="identifier">transform</span></code> assigns the
value <code class="computeroutput"><span class="identifier">y</span></code> to each element
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)),</span> <span class="identifier">y</span> <span class="special">=</span> <span class="identifier">fun</span><span class="special">(</span><span class="identifier">x</span><span class="special">)</span></code> where <code class="computeroutput"><span class="identifier">x</span></code>
is the corresponding value to <code class="computeroutput"><span class="identifier">y</span></code>
in <code class="computeroutput"><span class="identifier">rng1</span></code>. The return value
is <code class="computeroutput"><span class="identifier">out</span> <span class="special">+</span>
<span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>.
</p>
<p>
<span class="bold"><strong>BinaryOperation version:</strong></span>
</p>
<p>
<code class="computeroutput"><span class="identifier">transform</span></code> assigns the
value <code class="computeroutput"><span class="identifier">z</span></code> to each element
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span> <span class="special">+</span> <span class="identifier">min</span><span class="special">(</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">),</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))),</span> <span class="identifier">z</span> <span class="special">=</span> <span class="identifier">fun</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span><span class="identifier">y</span><span class="special">)</span></code> where <code class="computeroutput"><span class="identifier">x</span></code>
is the corresponding value in <code class="computeroutput"><span class="identifier">rng1</span></code>
and <code class="computeroutput"><span class="identifier">y</span></code> is the corresponding
value in <code class="computeroutput"><span class="identifier">rng2</span></code>. This version
of <code class="computeroutput"><span class="identifier">transform</span></code> stops upon
reaching either the end of <code class="computeroutput"><span class="identifier">rng1</span></code>,
or the end of <code class="computeroutput"><span class="identifier">rng2</span></code>. Hence
there isn't a requirement for <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">==</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">)</span></code>
since there is a safe guaranteed behaviour, unlike with the iterator
counterpart in the standard library.
</p>
<p>
The return value is <code class="computeroutput"><span class="identifier">out</span> <span class="special">+</span> <span class="identifier">min</span><span class="special">(</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">),</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))</span></code>.
</p>
<a name="range.reference.algorithms.mutating.transform.definition"></a><h6>
<a name="id707818"></a>
<a class="link" href="transform.html#range.reference.algorithms.mutating.transform.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">transform</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.transform.requirements"></a><h6>
<a name="id707889"></a>
<a class="link" href="transform.html#range.reference.algorithms.mutating.transform.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the unary versions of transform:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange1</span></code>
is a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">OutputIterator</span></code> is
a model of the <code class="computeroutput"><span class="identifier">OutputIteratorConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">UnaryOperation</span></code> is
a model of the <code class="computeroutput"><span class="identifier">UnaryFunctionConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange1</span></code>'s
value type must be convertible to <code class="computeroutput"><span class="identifier">UnaryFunction</span></code>'s
argument type.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">UnaryFunction</span></code>'s result
type must be convertible to a type in <code class="computeroutput"><span class="identifier">OutputIterator</span></code>'s
set of value types.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the binary versions of transform:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange1</span></code>
is a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange2</span></code>
is a model of the <a class="link" href="../../../concepts/single_pass_range.html" title="Single Pass Range">Single
Pass Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">OutputIterator</span></code> is
a model of the <code class="computeroutput"><span class="identifier">OutputIteratorConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BinaryOperation</span></code> is
a model of the <code class="computeroutput"><span class="identifier">BinaryFunctionConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange1</span></code>'s
value type must be convertible to <code class="computeroutput"><span class="identifier">BinaryFunction</span></code>'s
first argument type.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">SinglePassRange2</span></code>'s
value type must be convertible to <code class="computeroutput"><span class="identifier">BinaryFunction</span></code>'s
second argument type.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BinaryOperation</span></code>'s
result type must be convertible to a type in <code class="computeroutput"><span class="identifier">OutputIterator</span></code>'s
set of value types.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.transform.precondition_"></a><h6>
<a name="id708258"></a>
<a class="link" href="transform.html#range.reference.algorithms.mutating.transform.precondition_">Precondition:</a>
</h6>
<p>
<span class="bold"><strong>For the unary version of transform:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">out</span></code> is not an iterator
within the range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">))</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span>
<span class="special">+</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">))</span></code> is a valid range.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the binary version of transform:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">out</span></code> is not an iterator
within the range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">))</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">out</span></code> is not an iterator
within the range <code class="computeroutput"><span class="special">[</span><span class="identifier">begin</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">)</span> <span class="special">+</span> <span class="number">1</span><span class="special">,</span> <span class="identifier">end</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="special">[</span><span class="identifier">out</span><span class="special">,</span> <span class="identifier">out</span>
<span class="special">+</span> <span class="identifier">min</span><span class="special">(</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">),</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">)))</span></code> is a valid range.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.transform.complexity"></a><h6>
<a name="id708682"></a>
<a class="link" href="transform.html#range.reference.algorithms.mutating.transform.complexity">Complexity</a>
</h6>
<p>
Linear. The operation is applied exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">)</span></code> for the unary version and <code class="computeroutput"><span class="identifier">min</span><span class="special">(</span><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng1</span><span class="special">),</span> <span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng2</span><span class="special">))</span></code>
for the binary version.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="swap_ranges.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unique.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

View File

@ -1,163 +0,0 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
<title>unique</title>
<link rel="stylesheet" href="../../../../../../../../doc/src/boostbook.css" type="text/css">
<meta name="generator" content="DocBook XSL Stylesheets V1.75.2">
<link rel="home" href="../../../../index.html" title="Chapter&#160;1.&#160;Range 2.0">
<link rel="up" href="../mutating.html" title="Mutating algorithms">
<link rel="prev" href="transform.html" title="transform">
<link rel="next" href="unique_copy.html" title="unique_copy">
</head>
<body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
<table cellpadding="2" width="100%"><tr>
<td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../../../boost.png"></td>
<td align="center"><a href="../../../../../../../../index.html">Home</a></td>
<td align="center"><a href="../../../../../../../../libs/libraries.htm">Libraries</a></td>
<td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
<td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
<td align="center"><a href="../../../../../../../../more/index.htm">More</a></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="transform.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unique_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
<div class="section">
<div class="titlepage"><div><div><h5 class="title">
<a name="range.reference.algorithms.mutating.unique"></a><a class="link" href="unique.html" title="unique">unique</a>
</h5></div></div></div>
<a name="range.reference.algorithms.mutating.unique.prototype"></a><h6>
<a name="id708800"></a>
<a class="link" href="unique.html#range.reference.algorithms.mutating.unique.prototype">Prototype</a>
</h6>
<p>
</p>
<pre class="programlisting"><span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">return_begin_found</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">unique</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">return_begin_found</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">unique</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">return_begin_found</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">unique</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">return_begin_found</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">unique</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">unique</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">unique</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">unique</span><span class="special">(</span><span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
<span class="keyword">template</span><span class="special">&lt;</span><span class="identifier">range_return_value</span> <span class="identifier">re</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">BinaryPredicate</span><span class="special">&gt;</span>
<span class="keyword">typename</span> <span class="identifier">range_return</span><span class="special">&lt;</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">,</span> <span class="identifier">re</span><span class="special">&gt;::</span><span class="identifier">type</span>
<span class="identifier">unique</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ForwardRange</span><span class="special">&amp;</span> <span class="identifier">rng</span><span class="special">,</span> <span class="identifier">BinaryPredicate</span> <span class="identifier">pred</span><span class="special">);</span>
</pre>
<p>
</p>
<a name="range.reference.algorithms.mutating.unique.description"></a><h6>
<a name="id709822"></a>
<a class="link" href="unique.html#range.reference.algorithms.mutating.unique.description">Description</a>
</h6>
<p>
<code class="computeroutput"><span class="identifier">unique</span></code> removes all but
the first element of each sequence of duplicate encountered in <code class="computeroutput"><span class="identifier">rng</span></code>.
</p>
<p>
Elements in the range <code class="computeroutput"><span class="special">[</span><span class="identifier">new_last</span><span class="special">,</span>
<span class="identifier">end</span><span class="special">(</span><span class="identifier">rng</span><span class="special">))</span></code>
are dereferenceable but undefined.
</p>
<p>
Equality is determined by the predicate if one is supplied, or by <code class="computeroutput"><span class="keyword">operator</span><span class="special">==()</span></code>
for <code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s value
type.
</p>
<a name="range.reference.algorithms.mutating.unique.definition"></a><h6>
<a name="id709940"></a>
<a class="link" href="unique.html#range.reference.algorithms.mutating.unique.definition">Definition</a>
</h6>
<p>
Defined in the header file <code class="computeroutput"><span class="identifier">boost</span><span class="special">/</span><span class="identifier">range</span><span class="special">/</span><span class="identifier">algorithm</span><span class="special">/</span><span class="identifier">unique</span><span class="special">.</span><span class="identifier">hpp</span></code>
</p>
<a name="range.reference.algorithms.mutating.unique.requirements"></a><h6>
<a name="id710010"></a>
<a class="link" href="unique.html#range.reference.algorithms.mutating.unique.requirements">Requirements</a>
</h6>
<p>
<span class="bold"><strong>For the non-predicate versions of unique:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s value
type is a model of the <code class="computeroutput"><span class="identifier">EqualityComparableConcept</span></code>.
</li>
</ul></div>
<p>
<span class="bold"><strong>For the predicate versions of unique:</strong></span>
</p>
<div class="itemizedlist"><ul class="itemizedlist" type="disc">
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is a
model of the <a class="link" href="../../../concepts/forward_range.html" title="Forward Range">Forward
Range</a> Concept.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code> is mutable.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">BinaryPredicate</span></code> is
a model of the <code class="computeroutput"><span class="identifier">BinaryPredicateConcept</span></code>.
</li>
<li class="listitem">
<code class="computeroutput"><span class="identifier">ForwardRange</span></code>'s value
type is convertible to <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>'s
first argument type and to <code class="computeroutput"><span class="identifier">BinaryPredicate</span></code>'s
second argument type.
</li>
</ul></div>
<a name="range.reference.algorithms.mutating.unique.complexity"></a><h6>
<a name="id710232"></a>
<a class="link" href="unique.html#range.reference.algorithms.mutating.unique.complexity">Complexity</a>
</h6>
<p>
Linear. <code class="computeroutput"><span class="identifier">O</span><span class="special">(</span><span class="identifier">N</span><span class="special">)</span></code>
where <code class="computeroutput"><span class="identifier">N</span></code> is <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>.
Exactly <code class="computeroutput"><span class="identifier">distance</span><span class="special">(</span><span class="identifier">rng</span><span class="special">)</span></code>
comparisons are performed.
</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">Copyright &#169; 2003 -2010 Thorsten Ottosen, Neil Groves<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>
</div></td>
</tr></table>
<hr>
<div class="spirit-nav">
<a accesskey="p" href="transform.html"><img src="../../../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../mutating.html"><img src="../../../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../../../index.html"><img src="../../../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="unique_copy.html"><img src="../../../../../../../../doc/src/images/next.png" alt="Next"></a>
</div>
</body>
</html>

Some files were not shown because too many files have changed in this diff Show More