Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r61148 - in trunk/libs/range/doc: . html/range/reference/range_algorithm
From: neil_at_[hidden]
Date: 2010-04-08 16:56:02


Author: neilgroves
Date: 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
New Revision: 61148
URL: http://svn.boost.org/trac/boost/changeset/61148

Log:
Boost.Range remove deprecated html documentation.
Removed:
   trunk/libs/range/doc/boost_range.html
   trunk/libs/range/doc/counting_range.html
   trunk/libs/range/doc/examples.html
   trunk/libs/range/doc/faq.html
   trunk/libs/range/doc/headers.html
   trunk/libs/range/doc/history_ack.html
   trunk/libs/range/doc/html/range/reference/range_algorithm/
   trunk/libs/range/doc/intro.html
   trunk/libs/range/doc/istream_range.html
   trunk/libs/range/doc/mfc_atl.html
   trunk/libs/range/doc/portability.html
   trunk/libs/range/doc/range.html
   trunk/libs/range/doc/style.html
   trunk/libs/range/doc/upgrading.html
   trunk/libs/range/doc/utility_class.html

Deleted: trunk/libs/range/doc/boost_range.html
==============================================================================
--- trunk/libs/range/doc/boost_range.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,769 +0,0 @@
-<!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>
- Overview
- <li>
- Synopsis
- <li>
- Semantics
- <li>
- Extending the library</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 Range concepts 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>begin<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>begin<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>end<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>end<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>empty<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>distance<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>rbegin<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>rbegin<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>rend<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>rend<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>//
- // 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>size<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>
- const_begin<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>
- const_end<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>
- const_rbegin<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>
- const_rend<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>as_literal</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>as_literal</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>as_array</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>as_array</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 >
- <td><a name="range_iterator"></a><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>
-
- <td><a name="range_const_iterator"></a><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>
-
- <td><a name="range_value"></a><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>
-
- <td><a name="range_reference"></a><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>
-
- <td><a name="range_pointer"></a><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>
-
- <td><a name="range_category"></a><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>
-
- <td><a name="range_difference"></a><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>
-
- <td><a name="range_reverse_iterator"></a><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>
-
- <td><a name="range_const_reverse_iterator"></a><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>
-
- <td><a name="begin"></a><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&lt;T&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>
-
- <td><a name="end"></a><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&lt;T&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>
-
- <td><a name="empty"></a><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>
-
- <td><a name="distance"></a><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>
-
- <td><a name="size"></a><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>
-
- <td><a name="rbegin"></a><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>
-
- <td> <a name="rend"></a><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>
-
- <td><a name="const_begin"></a><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>
-
- <td><a name="const_end"></a><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>
-
- <td><a name="const_rbegin"></a><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>
-
- <td><a name="const_rend"></a><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>
-
- <td><a name="as_literal"></a><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> or an array of <code>Char</code>
- <br>
- <code>[boost::begin(x),boost::end(x))</code> otherwise
-
-
-
- </td>
- <td>linear time for pointers to a string or arrays of
- <code>Char</code>, constant time otherwise</td>
- </tr>
- <tr>
-
- <td><a name="as_array"></a><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>Method 1: provide member functions and nested types</li>
-
- <li>Method 2: provide free-standing functions and specialize metafunctions</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 method 2.
- </p>
-
- <p>
- The primary templates in this library are implemented such that standard
- containers will work automatically and so will <code>boost::array</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>Single Pass Range</td>
- </tr>
- <tr>
- <td><code>end()</code>
- </td>
- <td>Single Pass Range</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>Single Pass Range</td>
- </tr>
- <tr>
- <td><code>const_iterator</code></td>
- <td>Single Pass Range</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 method 1.
- </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>Single Pass Range</td>
- </tr>
- <tr>
- <td><code>range_end(x)</code>
- </td>
- <td>Single Pass Range</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>Single Pass Range</td>
- </tr>
- <tr>
- <td><code>boost::range_const_iterator</code></td>
- <td>Single Pass Range</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>

Deleted: trunk/libs/range/doc/counting_range.html
==============================================================================
--- trunk/libs/range/doc/counting_range.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,70 +0,0 @@
-<!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 Utilities</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>
- <a name="counting_range"></a> <h1>Function <code>counting_range</code></h1>
- <p>
- The intention of the <code>counting_range</code> function is to construct
- a new range with iterators that are wrapped in a
- <code>counting_iterator</code> (from Boost.Iterator)
- </p>
-
- <h3>Synopsis</h3>
-
- <pre><span class="keyword">namespace </span><span class="identifier">boost</span>
-<span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt; </span><span class="keyword">class </span><span class="identifier">Incrementable</span><span class="identifier"> </span><span class="special">&gt; <span style="color: #0000ff">inline</span>
- </span><span class="keyword"></span><span class="identifier">range&lt; counting_iterator&lt;Incrementable&gt; &gt;
- counting_range(Incrementable first, Incrementable last);
-
- <span class="keyword">template</span><span class="special">&lt; </span><span class="keyword">class </span><span class="identifier">SinglePassRange</span><span class="identifier"> </span><span class="special">&gt; </span><span class="keyword">inline
- </span><span class="identifier">range&lt; counting_iterator&lt;<span class="keyword">typename</span> range_iterator&lt;SinglePassRange&gt;::type &gt;
- counting_range(<span class="keyword">const</span> Range&amp; rng);
-
- </span><span class="keyword">template</span><span class="special">&lt; </span><span class="keyword">class </span><span class="identifier">SinglePassRange</span><span class="identifier"> </span><span class="special">&gt; <span style="color: #0000ff">inline</span></span>
- <span class="identifier">range&lt; counting_iterator&lt;<span style="color: #0000ff">typename</span> range_iterator&lt;SinglePassRange&gt;::type &gt;
- counting_range(Range&amp; rng);
- </span></span><span class="special"></span><span class="special"></span><span class="special"> </span>
-<span class="special">} </span><span class="comment">// namespace 'boost'</span>
- </pre>
-
- <p>
- &copy; <a name="Copyright" id="Copyright">Copyright</a> Neil Groves 2009.
-</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>
-

Deleted: trunk/libs/range/doc/examples.html
==============================================================================
--- trunk/libs/range/doc/examples.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,72 +0,0 @@
-<!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 >
- string.cpp
-
- shows how to implement a container version of <code >std::find()</code> that
- works with <code >char[],wchar_t[],char*,wchar_t*.</code>
- </li>
- <li >
- algorithm_example.cpp
-
-
- shows the replace example from the introduction.
- </li>
- <li> iterator_range.cpp
- <li> sub_range.cpp
- <li> iterator_pair.cpp
- <li> reversible_range.cpp
- <li> std_container.cpp
- <li> array.cpp
- </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>
-

Deleted: trunk/libs/range/doc/faq.html
==============================================================================
--- trunk/libs/range/doc/faq.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,145 +0,0 @@
-<!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>.
-
- <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 iterator_range
- 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>
- <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>
-

Deleted: trunk/libs/range/doc/headers.html
==============================================================================
--- trunk/libs/range/doc/headers.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,202 +0,0 @@
-<!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 >range_value</td>
- <td>Single Pass Range</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>Single Pass Range </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>Single Pass Range </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>Single Pass Range </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>Forward Range </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 >range_reverse_iterator</td>
- <td>Bidirectional Range </td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/begin.hpp&gt;</code></td>
- <td >
- begin and
- const_begin
- </td>
- <td>Single Pass Range </td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/end.hpp&gt;</code></td>
- <td >
- end and
- const_end
- </td>
- <td>Single Pass Range </td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/empty.hpp&gt;</code></td>
- <td >empty</td>
- <td>Single Pass Range </td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/distance.hpp&gt;</code></td>
- <td >distance</td>
- <td>Forward Range </td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/size.hpp&gt;</code></td>
- <td >size</td>
- <td>Random Access Range
- </td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/rbegin.hpp&gt;</code></td>
- <td >
- rbegin and
- const_rbegin
- </td>
- <td>Bidirectional Range </td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/rend.hpp&gt;</code></td>
- <td >
- rend and
- const_rend
- </td>
- <td>Bidirectional Range </td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/as_array.hpp&gt;</code></td>
- <td >
- as_array
- </td>
- <td>-</td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/as_literal.hpp&gt;</code></td>
- <td >
- as_literal
- </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 >sub_range</td>
- <td>- </td>
- </tr>
- <tr >
- <td ><code >&lt;boost/range/concepts.hpp&gt;</code></td>
- <td >concept checks</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>
-

Deleted: trunk/libs/range/doc/history_ack.html
==============================================================================
--- trunk/libs/range/doc/history_ack.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,90 +0,0 @@
-<!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>
-

Deleted: trunk/libs/range/doc/intro.html
==============================================================================
--- trunk/libs/range/doc/intro.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,164 +0,0 @@
-<!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 Introduction </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>Introduction</h2>
- <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
- href="range.html">Ranges</a> as much as possible.
- </p>
-
- <p>
- The most common form of ranges we are used to work with is standard library
- containers. However, one
- often finds it desirable to extend that code to work with other types that
- offer
- enough functionality to satisfy the needs of the generic code
- <i>if a suitable layer of indirection is applied </i>. For
- example, raw arrays are often suitable for use with generic code that
- works with containers, provided a suitable adapter is used.
- </p>
-
- <p>
- This library therefore provides the means to adapt standard-like
- containers, <code>std::pairs</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="../../mpl/doc/refmanual/metafunction.html">metafunctions</a> and
-free-standing functions so syntactic and/or semantic differences can be removed.
-</p>
-
- <p >
- The main advantages are
- <ul >
- <li >
- simpler implementation and specification of generic range algorithms
- </li>
- <li >
- more flexible, compact and maintainable client code
- </li>
- <li >
- safe use of built-in arrays
- </li>
-
- </ul>
- </p>
- <p > Below is given a small example (the complete example can be found <a
- href="../test/algorithm_example.cpp" target="_self" >here</a>): <blockquote>
- <pre >
-<span class=comment>
- //
- // example: extracting bounds in a generic algorithm
- //
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardReadableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
- </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_iterator</span><span class=special>&lt; </span><span class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><span class=identifier>type
- </span><span class=identifier>find</span><span class=special>( </span><span class=identifier>ForwardReadableRange</span><span class=special>&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>value </span><span class=special>)
- </span><span class=special>{
- </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>find</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>c </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>c </span><span class=special>), </span><span class=identifier>value </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>ForwardReadableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
- </span><span class=keyword>inline </span><span class=keyword>typename </span><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>ForwardReadableRange </span><span class=special>&gt;::</span><span class=identifier>type
- </span><span class=identifier>find</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardReadableRange</span><span class=special>&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>value </span><span class=special>)
- </span><span class=special>{
- </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>find</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>c </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>c </span><span class=special>), </span><span class=identifier>value </span><span class=special>);
- </span><span class=special>}
-
- </span><span class=comment>//
- // replace first value and return its index
- //
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardReadableWriteableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
- </span><span class=keyword>inline </span><span class=keyword>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>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type
- </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>ForwardReadableWriteableRange</span><span class=special>&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>value</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>replacement </span><span class=special>)
- </span><span class=special>{
- </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_iterator</span><span class=special>&lt; </span><span class=identifier>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>found </span><span class=special>= </span><span class=identifier>find</span><span class=special>( </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>value </span><span class=special>);
-
- </span><span class=keyword>if</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>c </span><span class=special>) </span><span class=special>)
- </span><span class=special>*</span><span class=identifier>found </span><span class=special>= </span><span class=identifier>replacement</span><span class=special>;
- </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>distance</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>c </span><span class=special>), </span><span class=identifier>found </span><span class=special>);
- </span><span class=special>}
-
- </span><span class=comment>//
- // usage
- //
- </span><span class=keyword>const </span><span class=keyword>int </span><span class=identifier>N </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>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>my_vector</span><span class=special>;
- </span><span class=keyword>int </span><span class=identifier>values</span><span class=special>[] </span><span class=special>= </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>my_vector</span><span class=special>.</span><span
-class=identifier>assign</span><span class=special>( </span><span class=identifier>values</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>values </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>iterator</span><span class=special>;
- </span><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><span class=identifier>my_view</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>my_vector </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>my_vector </span><span class=special>) </span><span class=special>+ </span><span class=identifier>N </span><span class=special>);
- </span><span class=keyword>char </span><span class=identifier>str_val</span><span class=special>[] </span><span class=special>= </span><span class=string>&quot;a string&quot;</span><span class=special>;
- </span><span class=keyword>char</span><span class=special>* </span><span class=identifier>str </span><span class=special>= </span><span class=identifier>str_val</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>my_generic_replace</span><span class=special>( </span><span class=identifier>my_vector</span><span class=special>, </span><span class=number>4</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>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>my_view</span><span class=special>, </span><span class=number>4</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>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>str</span><span class=special>, </span><span class=literal>'a'</span><span class=special>, </span><span class=literal>'b' </span><span class=special>);
-</span>
- <span class=comment>// prints '3', '5' and '0' </span>
- </pre>
- </blockquote>
-
- By using the free-standing functions and <a
-href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a>, the code automatically
- works for all the types supported by this library; now and in the future.
-Notice that we have to
- provide two version of <code >find()</code> since we cannot forward a non-const
- rvalue with reference arguments (see this article about <a href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_self" >The
- Forwarding Problem</a> ).
-
- </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>
-

Deleted: trunk/libs/range/doc/istream_range.html
==============================================================================
--- trunk/libs/range/doc/istream_range.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,64 +0,0 @@
-<!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 Utilities</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>
- <a name="istream_range"></a> <h1>Function <code>istream_range</code></h1>
- <p>
- The intention of the <code>istream_range</code> function is to construct
- a new range with a pair of <code>std::istream_iterator</code>s that wrap a
- specified <code>std::basic_istream</code> instance.
- </p>
-
- <h3>Synopsis</h3>
-
- <pre>
-<span class="keyword">namespace </span><span class="identifier">boost</span>
-<span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt; </span><span class="keyword">class </span><span class="identifier">
- Type,</span><span class="identifier"> <span style="color: #0000ff">class <span style="color: #000000">
- Elem</span><span style="color: #000000">, <span style="color: #0000ff">class <span
- style="color: #000000">Traits </span></span></span></span></span><span class="special">&gt; <span style="color: #0000ff">inline</span>
- </span><span class="keyword"></span><span class="identifier">range&lt; std::istream_iterator&lt;Type, Elem, Traits&gt; &gt;
- istream_range(std::basic_istream&lt;Elem, Traits&gt;&amp; in);
-} </pre>
-
- <p>
- &copy; <a name="Copyright" id="Copyright">Copyright</a> Neil Groves 2009.
-</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>
-

Deleted: trunk/libs/range/doc/mfc_atl.html
==============================================================================
--- trunk/libs/range/doc/mfc_atl.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,581 +0,0 @@
-<?xml version="1.0" encoding="utf-8" ?>
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
-<head>
-<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-<meta name="generator" content="Docutils 0.3.10: http://docutils.sourceforge.net/" />
-<title>Boost Range MFC/ATL Extension</title>
-<meta name="author" content="Shunsuke Sogame" />
-<meta name="date" content="26th of May 2006" />
-<meta name="copyright" content="Shunsuke Sogame 2005-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see LICENSE_1_0.txt)." />
-<style type="text/css">
-
-/*
-:Author: David Goodger
-:Contact: goodger_at_[hidden]
-:Date: $Date: 2005-09-25 17:49:54 +0200 (Sun, 25 Sep 2005) $
-:Revision: $Revision: 3901 $
-:Copyright: This stylesheet has been placed in the public domain.
-
-Default cascading style sheet for the HTML output of Docutils.
-
-See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
-customize this style sheet.
-*/
-
-/* "! important" is used here to override other ``margin-top`` and
- ``margin-bottom`` styles that are later in the stylesheet or
- more specific. See http://www.w3.org/TR/CSS1#the-cascade */
-.first {
- margin-top: 0 ! important }
-
-.last, .with-subtitle {
- margin-bottom: 0 ! important }
-
-.hidden {
- display: none }
-
-a.toc-backref {
- text-decoration: none ;
- color: black }
-
-blockquote.epigraph {
- margin: 2em 5em ; }
-
-dl.docutils dd {
- margin-bottom: 0.5em }
-
-/* Uncomment (and remove this text!) to get bold-faced definition list terms
-dl.docutils dt {
- font-weight: bold }
-*/
-
-div.abstract {
- margin: 2em 5em }
-
-div.abstract p.topic-title {
- font-weight: bold ;
- text-align: center }
-
-div.admonition, div.attention, div.caution, div.danger, div.error,
-div.hint, div.important, div.note, div.tip, div.warning {
- margin: 2em ;
- border: medium outset ;
- padding: 1em }
-
-div.admonition p.admonition-title, div.hint p.admonition-title,
-div.important p.admonition-title, div.note p.admonition-title,
-div.tip p.admonition-title {
- font-weight: bold ;
- font-family: sans-serif }
-
-div.attention p.admonition-title, div.caution p.admonition-title,
-div.danger p.admonition-title, div.error p.admonition-title,
-div.warning p.admonition-title {
- color: red ;
- font-weight: bold ;
- font-family: sans-serif }
-
-/* Uncomment (and remove this text!) to get reduced vertical space in
- compound paragraphs.
-div.compound .compound-first, div.compound .compound-middle {
- margin-bottom: 0.5em }
-
-div.compound .compound-last, div.compound .compound-middle {
- margin-top: 0.5em }
-*/
-
-div.dedication {
- margin: 2em 5em ;
- text-align: center ;
- font-style: italic }
-
-div.dedication p.topic-title {
- font-weight: bold ;
- font-style: normal }
-
-div.figure {
- margin-left: 2em }
-
-div.footer, div.header {
- clear: both;
- font-size: smaller }
-
-div.line-block {
- display: block ;
- margin-top: 1em ;
- margin-bottom: 1em }
-
-div.line-block div.line-block {
- margin-top: 0 ;
- margin-bottom: 0 ;
- margin-left: 1.5em }
-
-div.sidebar {
- margin-left: 1em ;
- border: medium outset ;
- padding: 1em ;
- background-color: #ffffee ;
- width: 40% ;
- float: right ;
- clear: right }
-
-div.sidebar p.rubric {
- font-family: sans-serif ;
- font-size: medium }
-
-div.system-messages {
- margin: 5em }
-
-div.system-messages h1 {
- color: red }
-
-div.system-message {
- border: medium outset ;
- padding: 1em }
-
-div.system-message p.system-message-title {
- color: red ;
- font-weight: bold }
-
-div.topic {
- margin: 2em }
-
-h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
-h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
- margin-top: 0.4em }
-
-h1.title {
- text-align: center }
-
-h2.subtitle {
- text-align: center }
-
-hr.docutils {
- width: 75% }
-
-img.align-left {
- clear: left }
-
-img.align-right {
- clear: right }
-
-img.borderless {
- border: 0 }
-
-ol.simple, ul.simple {
- margin-bottom: 1em }
-
-ol.arabic {
- list-style: decimal }
-
-ol.loweralpha {
- list-style: lower-alpha }
-
-ol.upperalpha {
- list-style: upper-alpha }
-
-ol.lowerroman {
- list-style: lower-roman }
-
-ol.upperroman {
- list-style: upper-roman }
-
-p.attribution {
- text-align: right ;
- margin-left: 50% }
-
-p.caption {
- font-style: italic }
-
-p.credits {
- font-style: italic ;
- font-size: smaller }
-
-p.label {
- white-space: nowrap }
-
-p.rubric {
- font-weight: bold ;
- font-size: larger ;
- color: maroon ;
- text-align: center }
-
-p.sidebar-title {
- font-family: sans-serif ;
- font-weight: bold ;
- font-size: larger }
-
-p.sidebar-subtitle {
- font-family: sans-serif ;
- font-weight: bold }
-
-p.topic-title {
- font-weight: bold }
-
-pre.address {
- margin-bottom: 0 ;
- margin-top: 0 ;
- font-family: serif ;
- font-size: 100% }
-
-pre.line-block {
- font-family: serif ;
- font-size: 100% }
-
-pre.literal-block, pre.doctest-block {
- margin-left: 2em ;
- margin-right: 2em ;
- background-color: #eeeeee }
-
-span.classifier {
- font-family: sans-serif ;
- font-style: oblique }
-
-span.classifier-delimiter {
- font-family: sans-serif ;
- font-weight: bold }
-
-span.interpreted {
- font-family: sans-serif }
-
-span.option {
- white-space: nowrap }
-
-span.pre {
- white-space: pre }
-
-span.problematic {
- color: red }
-
-span.section-subtitle {
- /* font-size relative to parent (h1..h6 element) */
- font-size: 80% }
-
-table.citation {
- border-left: solid thin gray }
-
-table.docinfo {
- margin: 2em 4em }
-
-table.docutils {
- margin-top: 0.5em ;
- margin-bottom: 0.5em }
-
-table.footnote {
- border-left: solid thin black }
-
-table.docutils td, table.docutils th,
-table.docinfo td, table.docinfo th {
- padding-left: 0.5em ;
- padding-right: 0.5em ;
- vertical-align: top }
-
-table.docutils th.field-name, table.docinfo th.docinfo-name {
- font-weight: bold ;
- text-align: left ;
- white-space: nowrap ;
- padding-left: 0 }
-
-h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
-h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
- font-size: 100% }
-
-tt.docutils {
- background-color: #eeeeee }
-
-ul.auto-toc {
- list-style-type: none }
-
-</style>
-</head>
-<body>
-<div class="document" id="boost-range-mfc-atl-extension">
-<h1 class="title"><img alt="Boost" src="../../ptr_container/doc/boost.png" /> Range MFC/ATL Extension</h1>
-<table class="docinfo" frame="void" rules="none">
-<col class="docinfo-name" />
-<col class="docinfo-content" />
-<tbody valign="top">
-<tr><th class="docinfo-name">Author:</th>
-<td>Shunsuke Sogame</td></tr>
-<tr><th class="docinfo-name">Contact:</th>
-<td><a class="first last reference" href="mailto:mb2act&#64;yahoo.co.jp">mb2act&#64;yahoo.co.jp</a></td></tr>
-<tr><th class="docinfo-name">Date:</th>
-<td>26th of May 2006</td></tr>
-<tr><th class="docinfo-name">Copyright:</th>
-<td>Shunsuke Sogame 2005-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see <a class="reference" href="http://www.boost.org/LICENSE_1_0.txt">LICENSE_1_0.txt</a>).</td></tr>
-</tbody>
-</table>
-<div class="section">
-<h1><a id="overview" name="overview">Overview</a></h1>
-<p>Boost.Range MFC/ATL Extension provides <a class="reference" href="../index.html">Boost.Range</a> support for MFC/ATL collection and string types.</p>
-<pre class="literal-block">
-CTypedPtrArray&lt;CPtrArray, CList&lt;CString&gt; *&gt; myArray;
-...
-BOOST_FOREACH (CList&lt;CString&gt; *theList, myArray)
-{
- BOOST_FOREACH (CString&amp; str, *theList)
- {
- boost::to_upper(str);
- std::sort(boost::begin(str), boost::end(str));
- ...
- }
-}
-</pre>
-<ul class="simple">
-<li><a class="reference" href="#requirements">Requirements</a></li>
-<li><a class="reference" href="#mfc-ranges">MFC Ranges</a></li>
-<li><a class="reference" href="#atl-ranges">ATL Ranges</a></li>
-<li><a class="reference" href="#const-ranges">const Ranges</a></li>
-<li><a class="reference" href="#references">References</a></li>
-</ul>
-</div>
-<div class="section">
-<h1><a id="requirements" name="requirements">Requirements</a></h1>
-<ul class="simple">
-<li><a class="reference" href="http://www.boost.org/">Boost C++ Libraries Version 1.34.0</a> or later (no compilation required)</li>
-<li>Visual C++ 7.1 or Visual C++ 8.0</li>
-</ul>
-</div>
-<div class="section">
-<h1><a id="mfc-ranges" name="mfc-ranges">MFC Ranges</a></h1>
-<p>If the <tt class="docutils literal"><span class="pre">&lt;boost/range/mfc.hpp&gt;</span></tt> is included before or after <a class="reference" href="../index.html">Boost.Range</a> headers,
-the MFC collections and strings become models of Range.
-The table below lists the Traversal Category and <tt class="docutils literal"><span class="pre">range_reference</span></tt> of MFC ranges.</p>
-<table border="1" class="docutils">
-<colgroup>
-<col width="34%" />
-<col width="21%" />
-<col width="45%" />
-</colgroup>
-<thead valign="bottom">
-<tr><th class="head"><tt class="docutils literal"><span class="pre">Range</span></tt></th>
-<th class="head">Traversal Category</th>
-<th class="head"><tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt></th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr><td><tt class="docutils literal"><span class="pre">CArray&lt;T,A&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">T&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CList&lt;T,A&gt;</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">T&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CMap&lt;K,AK,M,AM&gt;</span></tt></td>
-<td>Forward</td>
-<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CTypedPtrArray&lt;B,T*&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">T*</span> <span class="pre">const</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CTypedPtrList&lt;B,T*&gt;</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">T*</span> <span class="pre">const</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CTypedPtrMap&lt;B,T*,V*&gt;</span></tt></td>
-<td>Forward</td>
-<td><tt class="docutils literal"><span class="pre">std::pair&lt;T*,V*&gt;</span> <span class="pre">const</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CByteArray</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">BYTE&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CDWordArray</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">DWORD&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CObArray</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">CObject*</span> <span class="pre">&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CPtrArray</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">void*</span> <span class="pre">&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CStringArray</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">CString&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CUIntArray</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">UINT&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CWordArray</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">WORD&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CObList</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">CObject*</span> <span class="pre">&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CPtrList</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">void*</span> <span class="pre">&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CStringList</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">CString&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CMapPtrToWord</span></tt></td>
-<td>Forward</td>
-<td><tt class="docutils literal"><span class="pre">std::pair&lt;void*,WORD&gt;</span> <span class="pre">const</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CMapPtrToPtr</span></tt></td>
-<td>Forward</td>
-<td><tt class="docutils literal"><span class="pre">std::pair&lt;void*,void*&gt;</span> <span class="pre">const</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CMapStringToOb</span></tt></td>
-<td>Forward</td>
-<td><tt class="docutils literal"><span class="pre">std::pair&lt;String,CObject*&gt;</span> <span class="pre">const</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CMapStringToString</span></tt></td>
-<td>Forward</td>
-<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CMapWordToOb</span></tt></td>
-<td>Forward</td>
-<td><tt class="docutils literal"><span class="pre">std::pair&lt;WORD,CObject*&gt;</span> <span class="pre">const</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CMapWordToPtr</span></tt></td>
-<td>Forward</td>
-<td><tt class="docutils literal"><span class="pre">std::pair&lt;WORD,void*&gt;</span> <span class="pre">const</span></tt></td>
-</tr>
-</tbody>
-</table>
-<p>Other <a class="reference" href="../index.html">Boost.Range</a> metafunctions are defined by the following.
-Let <tt class="docutils literal"><span class="pre">Range</span></tt> be any type listed above and <tt class="docutils literal"><span class="pre">ReF</span></tt> be the same as <tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt>.
-<tt class="docutils literal"><span class="pre">range_value&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">remove_reference&lt;remove_const&lt;Ref&gt;::type&gt;::type</span></tt>,
-<tt class="docutils literal"><span class="pre">range_difference&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">std::ptrdiff_t</span></tt>, and
-<tt class="docutils literal"><span class="pre">range_pointer&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">add_pointer&lt;remove_reference&lt;Ref&gt;::type&gt;::type</span></tt>.
-As for <tt class="docutils literal"><span class="pre">const</span> <span class="pre">Range</span></tt>, see <a class="reference" href="#const-ranges">const Ranges</a>.</p>
-</div>
-<div class="section">
-<h1><a id="atl-ranges" name="atl-ranges">ATL Ranges</a></h1>
-<p>If the <tt class="docutils literal"><span class="pre">&lt;boost/range/atl.hpp&gt;</span></tt> is included before or after <a class="reference" href="../index.html">Boost.Range</a> headers,
-the ATL collections and strings become models of Range.
-The table below lists the Traversal Category and <tt class="docutils literal"><span class="pre">range_reference</span></tt> of ATL ranges.</p>
-<table border="1" class="docutils">
-<colgroup>
-<col width="34%" />
-<col width="21%" />
-<col width="45%" />
-</colgroup>
-<thead valign="bottom">
-<tr><th class="head"><tt class="docutils literal"><span class="pre">Range</span></tt></th>
-<th class="head">Traversal Category</th>
-<th class="head"><tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt></th>
-</tr>
-</thead>
-<tbody valign="top">
-<tr><td><tt class="docutils literal"><span class="pre">CAtlArray&lt;E,ET&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CAutoPtrArray&lt;E&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CInterfaceArray&lt;I,pi&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">CComQIPtr&lt;I,pi&gt;&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CAtlList&lt;E,ET&gt;</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CAutoPtrList&lt;E&gt;</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CHeapPtrList&lt;E,A&gt;</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CInterfaceList&lt;I,pi&gt;</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">CComQIPtr&lt;I,pi&gt;&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CAtlMap&lt;K,V,KT,VT&gt;</span></tt></td>
-<td>Forward</td>
-<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CRBTree&lt;K,V,KT,VT&gt;</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CRBMap&lt;K,V,KT,VT&gt;</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CRBMultiMap&lt;K,V,KT,VT&gt;</span></tt></td>
-<td>Bidirectional</td>
-<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CSimpleStringT&lt;B,b&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">B&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CStringT&lt;B,ST&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">B&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CFixedStringT&lt;S,n&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">range_reference&lt;S&gt;::type</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CStringT&lt;B,ST&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">B&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CComBSTR</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">OLECHAR&amp;</span></tt></td>
-</tr>
-<tr><td><tt class="docutils literal"><span class="pre">CSimpleArray&lt;T,TE&gt;</span></tt></td>
-<td>Random Access</td>
-<td><tt class="docutils literal"><span class="pre">T&amp;</span></tt></td>
-</tr>
-</tbody>
-</table>
-<p>Other <a class="reference" href="../index.html">Boost.Range</a> metafunctions are defined by the following.
-Let <tt class="docutils literal"><span class="pre">Range</span></tt> be any type listed above and <tt class="docutils literal"><span class="pre">ReF</span></tt> be the same as <tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt>.
-<tt class="docutils literal"><span class="pre">range_value&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">remove_reference&lt;Ref&gt;::type</span></tt>,
-<tt class="docutils literal"><span class="pre">range_difference&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">std::ptrdiff_t</span></tt>, and
-<tt class="docutils literal"><span class="pre">range_pointer&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">add_pointer&lt;remove_reference&lt;Ref&gt;::type&gt;::type</span></tt>.
-As for <tt class="docutils literal"><span class="pre">const</span> <span class="pre">Range</span></tt>, see <a class="reference" href="#const-ranges">const Ranges</a>.</p>
-</div>
-<div class="section">
-<h1><a id="const-ranges" name="const-ranges">const Ranges</a></h1>
-<p><tt class="docutils literal"><span class="pre">range_reference&lt;const</span> <span class="pre">Range&gt;::type</span></tt> is defined by the following algorithm.
-Let <tt class="docutils literal"><span class="pre">Range</span></tt> be any type listed above and <tt class="docutils literal"><span class="pre">ReF</span></tt> be the same as <tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt>.</p>
-<pre class="literal-block">
-if (Range is CObArray || Range is CObList)
- return CObject const * &amp;
-else if (Range is CPtrArray || Range is CPtrList)
- return void const * &amp;
-else if (there is a type X such that X&amp; is the same as ReF)
- return X const &amp;
-else if (there is a type X such that X* const is the same as ReF)
- return X const * const
-else
- return ReF
-</pre>
-<p>Other <a class="reference" href="../index.html">Boost.Range</a> metafunctions are defined by the following.
-<tt class="docutils literal"><span class="pre">range_value&lt;const</span> <span class="pre">Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">range_value&lt;Range&gt;::type</span></tt>,
-<tt class="docutils literal"><span class="pre">range_difference&lt;const</span> <span class="pre">Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">std::ptrdiff_t</span></tt>, and
-<tt class="docutils literal"><span class="pre">range_pointer&lt;const</span> <span class="pre">Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">add_pointer&lt;remove_reference&lt;range_reference&lt;const</span> <span class="pre">Range&gt;::type&gt;::type&gt;::type</span></tt>.</p>
-</div>
-<div class="section">
-<h1><a id="references" name="references">References</a></h1>
-<ul class="simple">
-<li><a class="reference" href="../index.html">Boost.Range</a></li>
-<li><a class="reference" href="http://msdn2.microsoft.com/en-us/library/942860sh.aspx">MFC Collections</a></li>
-<li><a class="reference" href="http://msdn2.microsoft.com/en-US/library/15e672bd.aspx">ATL Collection Classes</a></li>
-</ul>
-</div>
-</div>
-</body>
-</html>

Deleted: trunk/libs/range/doc/portability.html
==============================================================================
--- trunk/libs/range/doc/portability.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,103 +0,0 @@
-<!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 Portability </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>Portability</h2><a name="Portability" ></a>
-
- <p>
- A huge effort has been made to port the library to as many compilers as possible.
-<!-- The results of the test-suites can be found <a
-href="http://boost.sourceforge.net/regression-logs/developer/range.html">here</a
->.--> </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.
- </p>
- <p> 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 on <a
- href="boost_range.html#range_iterator"><code >range_iterator</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:
-
- <ol>
- <li>
- do not use built-in arrays,
- <li>
- do not pass rvalues to <a
- href="boost_range.html#begin"><code>begin()</code></a>, <a
- href="boost_range.html#end"><code>end()</code></a> and <a href="utility_class.html#iter_range">
- <code>iterator_range</code></a> Range constructors and assignment operators,
- <li>
- use const_begin()
- and const_end()
- whenever your code by intention is read-only; this will also solve
- most rvalue problems,
- <li>
- do not rely on ADL:
- <ul>
- <li>
- if you overload functions, include that header <i>before</i> the headers in this
- library,
- <li>
- put all overloads in namespace <code>boost</code>.
- </ul>
-
- </ol>
- </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>
-

Deleted: trunk/libs/range/doc/range.html
==============================================================================
--- trunk/libs/range/doc/range.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,379 +0,0 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
-<HTML>
-<!--
- -- Copyright (c) Jeremy Siek 2000
- --
- -- Permission to use, copy, modify, distribute and sell this software
- -- and its documentation for any purpose is hereby granted without fee,
- -- provided that the above copyright notice appears in all copies and
- -- that both that copyright notice and this permission notice appear
- -- in supporting documentation. Silicon Graphics makes no
- -- representations about the suitability of this software for any
- -- purpose. It is provided "as is" without express or implied warranty.
- -->
-<Head>
- <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
- <Title>Range Concepts</Title>
- <link rel="stylesheet" href="style.css" type="text/css">
-</HEAD>
-
- <table border="0" >
- <tr>
- <td ><img src="../../../boost.png" border="0" ></td>
- <td ><h1 align="center">Boost.Range </h1></td>
- </tr>
- </table>
-
- <h2>Range concepts </h2>
-
- <ul>
- <li>
- Overview
- <li>
- Single Pass Range
- <li>
- Forward Range
- <li>
- Bidirectional Range
- <li>
- Random Access Range
- <li>
- Concept Checking
- </ul>
-
- <a name="overview"></a>
- <hr>
- <h3>Overview</h3>
-
- <p>
- A Range is a <i>concept</i> similar to the STL <a
- href="http://www.sgi.com/Technology/STL/Container.html">Container</a> concept. A
- Range provides iterators for accessing a half-open range
-<code>[first,one_past_last)</code> of elements and provides
- information about the number of elements in the Range. However, a Range has
- <i>much</i> 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
-
- <ul>
- <li>
- own the elements that can be accessed through it,
- <li>
- have copy semantics,
- <!--
- <li>
- require that the associated reference type is a real C++ reference.
- -->
- </ul>
-
-
- 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="../../iterator/doc/new-iter-concepts.html#iterator-traversal-concepts-lib-iterator-traversal">traversal
-category</a> of the underlying iterator type. Therefore
- the range concepts are named to reflect which traversal category their
- iterators support. See also <a href="style.html">terminology and style
- guidelines.</a> for more information about naming of ranges.</p>
-
- <p> The concepts described below specifies associated types as
-metafunctions and all
-functions as free-standing functions to allow for a layer of indirection. </p>
-
-<!--<p><i>Notice that these metafunctions must be defined in namespace </i>
-<code>boost</code></p>-->
-
- <hr>
- <a name="single_pass_range"></a>
- <H2>Single Pass Range</H2>
-
- <h3>Notation</h3>
- <Table>
- <TR>
- <TD VAlign="top"><code>X</code></TD>
- <TD VAlign="top">A type that is a model of Single Pass Range.</TD>
- </TR>
- <TR>
- <TD VAlign="top"><code>a</code></TD>
- <TD VAlign="top">Object of type <code>X</code>.</TD>
- </TR>
- </table>
-
-
- <h3>Description</h3>
- <p>
- A range X where <code>boost::range_iterator&lt;X>::type</code> is a model of <a
-href="../../iterator/doc/new-iter-concepts.html#single-pass-iterators-lib-single-pass-iterators">
-Single Pass Iterator</a>
-
- </p>
-
-
- <h3>Associated types</h3>
-
- <table border="1" cellpadding="5">
-
- <TR>
- <TD VAlign="top">Iterator type</TD>
- <TD VAlign="top"><code>boost::range_iterator&lt;X>::type</code></TD>
- <TD VAlign="top">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.
- </TR>
- <TR>
- <TD VAlign="top">Const iterator type</TD>
- <TD VAlign="top"><code>boost::range_iterator&lt;const X>::type</code></TD>
- <TD VAlign="top">A type of iterator that may be used to examine, but not to
- modify, a Range's elements.</TD>
- </TR>
- <!--
- <TR>
- <TD VAlign="top">Reference type</TD>
- <TD VAlign="top"><code>reference_of&lt;X>::type</code></TD>
- <TD VAlign="top">A type that behaves like a reference to the Range's value type. [1]</TD>
- </TR>
- -->
- </table>
-
-
- <h3>Valid expressions</h3>
-
- The following expressions must be valid.
- <p>
-
- <Table border="1" cellpadding="5">
- <TR>
- <TH>Name</TH>
- <TH>Expression</TH>
- <TH>Return type</TH>
- </TR>
- <TR>
- <TD VAlign="top">Beginning of range</TD>
- <TD VAlign="top"><code>boost::begin(a)</code></TD>
- <TD VAlign="top"><code>boost::range_iterator&lt;X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_iterator&lt;const X>::type</code>
-otherwise</TD> </TR>
- <TR>
- <TD VAlign="top">End of range</TD>
- <TD VAlign="top"><code>boost::end(a)</code></TD>
- <TD VAlign="top"><code>boost::range_iterator&lt;X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_iterator&lt;const X>::type</code>
-otherwise</TD>
- </TR>
-
- </table>
- <h3>Expression semantics</h3>
-
- <Table border>
- <TR>
- <TH>Expression</TH>
- <TH>Semantics</TH>
- <TH>Postcondition</TH>
- </TR>
- <TR>
- <TD VAlign="top"><code>boost::begin(a)</code></TD>
- <TD VAlign="top">Returns an iterator pointing to the first element in the Range.</TD>
- <TD VAlign="top"><code>boost::begin(a)</code> is either dereferenceable or past-the-end.
- It is past-the-end if and only if <code>boost::distance(a) == 0</code>.</TD>
- </TR>
- <TR>
- <TD VAlign="top"><code>boost::end(a)</code></TD>
- <TD VAlign="top">Returns an iterator pointing one past the last element in the
- Range.</TD>
- <TD VAlign="top"><code>boost::end(a)</code> is past-the-end.</TD>
- </TR>
-
- </table>
-
- <h3>Complexity guarantees</h3>
-
- <code>boost::end(a)</code> is at most amortized linear time, <code>boost::begin(a)</code> is
- amortized constant time. For most practical
- purposes, one can expect both to be amortized constant time.
-
- <h3>Invariants</h3>
- <Table border>
- <TR>
- <TD VAlign="top">Valid range</TD>
- <TD VAlign="top">For any Range <code>a</code>, <code>[boost::begin(a),boost::end(a))</code> is
- a valid range, that is, <code>boost::end(a)</code> is reachable from <code>boost::begin(a)</code>
- in a finite number of increments.</TD>
- </TR>
- <TR>
- <TD VAlign="top">Completeness</TD>
- <TD VAlign="top">An algorithm that iterates through the range <code>[boost::begin(a),boost::end(a))</code>
- will pass through every element of <code>a</code>.</TD>
- </tr>
- </table>
-
-
- <h3>See also</h3>
- <p><a
- href="boost_range.html#minimal_interface">Extending the library for UDTs </a></p>
- <p> <a href="boost_range.html#boost::rang_difference">Implementation of
- metafunctions </a></p>
-
- <p> <a href="boost_range.html#begin">Implementation of
- functions </a></p>
- <p>
- Container
- </p>
-
-
- <hr>
- <a name=forward_range></a><h2>Forward Range</h2>
-
- <h3>Notation</h3>
- <Table>
- <TR>
- <TD VAlign="top"><code>X</code></TD>
- <TD VAlign="top">A type that is a model of Forward Range.</TD>
- </TR>
- <TR>
- <TD VAlign="top"><code>a</code></TD>
- <TD VAlign="top">Object of type <code>X</code>.</TD>
- </TR>
- </table>
-
- <h3>Description</h3>
- <p>
- A range <code>X</code> where <code>boost::range_iterator&lt;X>::type</code> is a model
-of <a
-href="../../iterator/doc/new-iter-concepts.html#forward-traversal-iterators-lib-forward-traversal-iterators">Forward Traversal Iterator</a>
- </p>
-
- <h3>Refinement of</h3> <a href="#single_pass_range">Single Pass
-Range</a>
-
- </p>
-
- <hr>
-
- <a name="bidirectional_range"></a><h2>Bidirectional Range</h2>
-
- <h3>Notation</h3>
- <Table>
- <TR>
- <TD VAlign="top"><code>X</code></TD>
- <TD VAlign="top">A type that is a model of Bidirectional Range.</TD>
- </TR>
- <TR>
- <TD VAlign="top"><code>a</code></TD>
- <TD VAlign="top">Object of type <code>X</code>.</TD>
- </TR>
- </table>
-
- <h3>Description</h3> This concept provides access to iterators that traverse in
- both directions (forward and reverse). The
-<code>boost::range_iterator&lt;X>::type</code> iterator must meet all of the requirements
-of <a
-href="../../iterator/doc/new-iter-concepts.html#bidirectional-traversal-iterator
-s-lib-bidirectional-traversal-iterators">Bidirectional Traversal Iterator.</a>
-
- <h3>Refinement of</h3> Forward Range
-
-
-</p>
-
- <hr>
-
- <a name=random_access_range></a><h2>Random Access Range</h2>
- <h3>Description</h3>
- <p>
- A range <code>X</code> where <code>boost::range_iterator&lt;X>::type</code> is a model
-of <a
-
-href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterators
--lib-random-access-traversal-iterators">Random Access Traversal Iterator</a>
- </p>
-
- <h3>Refinement of</h3>
- <p>
- Bidirectional Range
- </p>
-
- <hr>
-
- <a name=concept_checking></a><h2>Concept Checking</h2>
-
- Each of the range concepts has a corresponding concept checking
- class in the file <code>&lt;boost/range/concepts.hpp&gt;</code>. These classes may be
- used in conjunction with the <a
- href="../../concept_check/concept_check.htm">Boost Concept
- Check</a> library to insure 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>T</code> models the
- ForwardRange concept.
-
- <pre>
- function_requires&lt;ForwardRangeConcept&lt;T&gt; &gt;();
- </pre>
-
- 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.
-
- <pre>
- function_requires&lt;ForwardRangeConcept&lt;T&gt; &gt;();
- function_requires&lt;
- ReadableIteratorConcept&lt;
- typename range_iterator&lt;T&gt;::type
- &gt;
- &gt;();
- </pre>
-
- The following range concept checking classes are provided.
- <ul>
- <li>
- Class <code>SinglePassRangeConcept</code> checks for <a
- href="#single_pass_range">Single Pass Range</a>
- <li>
- Class <code>ForwardRangeConcept</code> checks for <a
- href="#forward_range">Forward Range</a>
- <li>
- Class <code>BidirectionalRangeConcept</code> checks for <a
- href="#bidirectional_range">Bidirectional Range</a>
- <li>
- Class <code>RandomAccessRangeConcept</code> checks for <a
- href="#random_access_range">Random Access Range</a>
- </ul>
-
- <h3>See also</h3>
- <p> Range Terminology and style guidelines</p>
- <p> Iterator Concepts</p>
- <p> Boost Concept Check library</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>
-
- </BODY>
-</HTML>

Deleted: trunk/libs/range/doc/style.html
==============================================================================
--- trunk/libs/range/doc/style.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,132 +0,0 @@
-<!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 Terminology and Style Guidelines </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>Terminology and style guidelines </h2>
-
- <p>
- The use of a consistent terminology is as important for Ranges
- and range-based algorithms as it is for iterators and iterator-based algorithms.
- If a conventional set of names are adopted, we can avoid misunderstandings and
- write generic function prototypes that are <i>self-documenting</i>.
- </p>
-
- <p>
- Since ranges are characterized by a specific underlying iterator type, we get a
- type of range for each type of iterator. Hence we can speak of the following
- types of ranges:
- <ul>
- <li>
- <i>Value access</i> category:
- <ul>
- <li>
- Readable Range
- <li>
- Writeable Range
- <li>
- Swappable Range
- <li>
- Lvalue Range
- </ul>
- <li>
- <i>Traversal</i> category:
- <ul>
- <li>
- Single Pass Range
- <li>
- Forward Range
- <li>
- Bidirectional Range <li>
- Random Access Range </ul>
- </ul>
- Notice how we have used the categories from the <a href="../../iterator/doc/new-iter-concepts.html">new
- style iterators</a>.
-
- <p>
- Notice that an iterator (and therefore an range) has one <i>traversal</i>
- property and one or more properties from the <i>value access</i> category. So in
- reality we will mostly talk about mixtures such as
- <ul>
- <li>
- Random Access Readable Writeable Range
- <li>
- Forward Lvalue Range
- </ul>
- By convention, we should always specify the <i>traversal</i> property first as
- done above. This seems reasonable since there will only be one <i>traversal</i>
- property, but perhaps many <i>value access</i> properties.
- </p>
-
- <p>
- It might, however, be reasonable to specify only one category if the other
- category does not matter. For example, the <a
- href="utility_class.html#iter_range">iterator_range</a> can be constructed from
- a Forward Range. This means that we do not care about what <i>value access</i>
- properties the Range has. Similarly, a Readable Range will be one that has the
- lowest possible <i>traversal</i> property (Single Pass).
- </p>
-
- <p>
- As another example, consider how we specify the interface of <code>std::sort()</code>.
- Algorithms are usually more cumbersome to specify the interface of since both <i>traversal</i>
- and <i>value access</i> properties must be exactly defined. The iterator-based
- version looks like this:
-
- <pre>
- <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>RandomAccessTraversalReadableWritableIterator </span><span class=special>&gt;
- </span><span class=keyword>void </span><span class=identifier>sort</span><span class=special>( </span><span class=identifier>RandomAccessTraversalReadableWritableIterator </span><span class=identifier>first</span><span class=special>,
- </span><span class=identifier>RandomAccessTraversalReadableWritableIterator </span><span class=identifier>last </span><span class=special>);</span>
- </pre>
- For ranges the interface becomes
-
- <pre>
- <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>RandomAccessReadableWritableRange </span><span class=special>&gt;
- </span><span class=keyword>void </span><span class=identifier>sort</span><span class=special>( </span><span class=identifier>RandomAccessReadableWritableRange</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);</span>
- </pre>
- </p>
- <p>
-
- </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>
-

Deleted: trunk/libs/range/doc/upgrading.html
==============================================================================
--- trunk/libs/range/doc/upgrading.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,79 +0,0 @@
-<!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 Upgrading </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 >Upgrading from Boost v. 1.34.*</h2><a name="v1.34" ></a>
- <p >
- Boost v. 1.35 introduced some larger refactorings of the library:
- </p>
- <ul >
- <li>Direct support for character arrays was abandoned in favor of
- uniform treatment of all arrays. Instead string algorithms can use
- the new function <a
- href="boost_range.html#as_literal">as_literal()</a>.</li>
- <li><a
- href="boost_range.html#size">boost::size()</a> now requires a Random
- Access Range. The old behavior is provided as <a
- href="boost_range.html#distance">boost::distance()</a> </li>
- <li> <code>range_size&lt;T&gt;::type</code> has been completely removed
- in favor of <code>range_difference&lt;T&gt;::type</code>
- <li>
- <code>boost_range_begin()</code> and <code>boost_range_end()</code>
- have been renamed <code>range_begin()</code> and <code>range_begin()</code>, respectively.</li>
-
-
- <li><code>range_result_iterator&lt;T&gt;::type</code> and
- <code>range_reverse_result_iterator&lt;T&gt;::type</code> are have
- been renamed
- <code>range_iterator&lt;T&gt;::type</code> and
- <code>range_reverse_iterator&lt;T&gt;::type</code>.
- </li>
- <li>The procedure that makes a custom type work with the library
- has been greatly simplified. See <a
- href="boost_range.html#minimal_interface">extending the library </a>
- for details.</li>
- </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>
-

Deleted: trunk/libs/range/doc/utility_class.html
==============================================================================
--- trunk/libs/range/doc/utility_class.html 2010-04-08 16:56:00 EDT (Thu, 08 Apr 2010)
+++ (empty file)
@@ -1,380 +0,0 @@
-<!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 Utilities </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>Utilities</h2>
- <p>
- Having an abstraction that encapsulates a pair of iterators is very useful. The
- standard library uses <code>std::pair</code> in some circumstances, but that
- class is cumbersome to use because we need to specify two template arguments,
- and for all range algorithm purposes we must enforce the two template arguments
- to be the same. Moreover, <code>std::pair&lt;iterator,iterator></code> is hardly
- self-documenting whereas more domain specific class names are. Therefore these
- two classes are provided:
-
- <ul>
- <li>
- Class iterator_range
- <li>
- Class sub_range
- </ul>
-
- The <code>iterator_range</code> class is templated on a <a
- href="../../iterator/doc/new-iter-concepts.html#forward-traversal-iterators-lib-forward-traversal-iterators">Forward
- Traversal Iterator</a> and should be used whenever fairly general code is needed.
- The <code>sub_range</code> class is templated on a <a
- href="range.html#forward_range">Forward Range</a> and it is less general,
- but a bit easier to use since its template
- argument is easier to specify. The biggest difference is, however, that a
- <code>sub_range</code> can propagate constness because it knows what a
-corresponding <code>const_iterator</code> is. </p>
-
- <p>
- Both classes can be used as ranges since they implement the <a
- href="boost_range.html#minimal_interface">minimal interface</a>
- required for this to work automatically.
- </p>
-
- <hr>
- <a name=iter_range></a> <h1>Class <code>iterator_range</code></h1>
- <p>
- The intention of the <code>iterator_range</code> class is to encapsulate two
- iterators so they fulfill the <a
- href="range.html#forward_range">Forward Range</a> concept. A few other
- functions are also provided for convenience.
- </p>
- <p>
- If the template argument is not a model of Forward Traversal Iterator, one can
- still use a subset of the interface. In particular, <code>size()</code> requires
- Random Access Iterators whereas <code>empty()</code> only requires Single
- Pass Iterators.
- </p>
-
- <p>
- Recall that many default constructed iterators
- are <i>singular</i> and hence can only be assigned, but not compared or
- incremented or anything. Likewise, if one creates a default constructed
- <code>iterator_range</code>, then one have to be careful about not doing
- anything besides copying. </p>
-
- <h3>Synopsis</h3>
-
- <pre>
-<span class=keyword>namespace </span><span class=identifier>boost</span>
-<span class=special>{
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator </span><span class=special>&gt;
- </span><span class=keyword>class </span><span class=identifier>iterator_range
- </span><span class=special>{
- </span><span class=keyword>public</span><span class=special>: </span><span class=comment>// Forward Range types
- </span><span class=keyword>typedef </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>iterator</span><span class=special>;
- </span><span class=keyword>typedef </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>const_iterator</span><span class=special>;</span>
- <span class=keyword>typedef </span><span class=identifier>iterator_difference</span><span class=special>&lt;</span><span class=identifier>iterator</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>difference_type</span><span class=special>;</span>
-
- <span class=keyword>public</span><span class=special>: </span><span class=comment>// construction, assignment
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator2 </span><span class=special>&gt;
- </span><span class=identifier>iterator_range</span><span class=special>( </span><span class=identifier>ForwardTraversalIterator2 </span><span class=identifier>Begin</span><span class=special>, </span><span class=identifier>ForwardTraversalIterator2 </span><span class=identifier>End </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=identifier>iterator_range</span><span class=special>( </span><span class=identifier>ForwardRange</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>ForwardRange </span><span class=special>&gt;
- </span><span class=identifier>iterator_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardRange</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>ForwardRange </span><span class=special>&gt;
- </span><span class=identifier>iterator_range</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>=( </span><span class=identifier>ForwardRange</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>ForwardRange </span><span class=special>&gt;
- </span><span class=identifier>iterator_range</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>=( </span><span class=keyword>const </span><span class=identifier>ForwardRange</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
-
- </span><span class=keyword>public</span><span class=special>: </span><span class=comment>// Forward Range functions
- </span><span class=identifier>iterator </span><span class=identifier>begin</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
- </span><span class=identifier>iterator </span><span class=identifier>end</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
- </span><span class=identifier>difference_type </span><span class=identifier>size</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
- </span><span class=keyword>bool </span><span class=identifier>empty</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
-
- </span><span class=keyword>public</span><span class=special>: </span><span class=comment>// convenience
- </span><span class=keyword>operator </span>unspecified_bool_type<span class=special>() </span><span class=keyword>const</span><span class=special>;
- </span> <span class=keyword>bool</span> <span
-class=identifier>equal</span><span
-class=special>( </span><span class=keyword>const</span> <span class=identifier>iterator_range</span><span class=special>&amp; ) </span><span
-class=keyword>const;</span>
- <span class=identifier>reference </span><span class=identifier>front</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
- <span class=identifier>reference </span><span class=identifier>back</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
- <span class=identifier>iterator_range</span><span class=special>&amp;</span> <span class=identifier>advance_begin</span><span class=special>(</span> <span class=identifier>difference_type</span> <span class=identifier>n</span> <span class=special>);</span>
- <span class=identifier>iterator_range</span><span class=special>&amp;</span> <span class=identifier>advance_end</span><span class=special>(</span> <span class=identifier>difference_type</span> <span class=identifier>n</span> <span class=special>);</span>
- <span class=comment>// for Random Access Range only: </span>
- <span class=identifier>reference </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
- <span class=identifier>value_type</span> <span class=keyword>operator</span><span class=special>()( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
- <span class=special>};
-
- </span><span class=comment>// stream output
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>Traits </span><span class=special>&gt;
- </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>basic_ostream</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>,</span><span class=identifier>Traits</span><span class=special>&gt;&amp;
- </span><span class=keyword>operator</span><span class=special>&lt;&lt;( </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>basic_ostream</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>,</span><span class=identifier>Traits</span><span class=special>&gt;&amp; </span><span class=identifier>Os</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&amp; </span><span class=identifier>r </span><span class=special>);
-
- </span><span class=comment>// comparison
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator2 </span><span class=special>&gt;
- </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>==( </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&amp; </span><span class=identifier>l</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator2</span><span class=special>&gt;&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>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
- </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>==( </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&amp; </span><span class=identifier>l</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>ForwardRange</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>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
- </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>==( </span><span class=keyword>const </span><span class=identifier>ForwardRange</span><span class=special>&amp; </span><span class=identifier>l</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&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>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator2 </span><span class=special>&gt;
- </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>!=( </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&amp; </span><span class=identifier>l</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator2</span><span class=special>&gt;&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>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
- </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>!=( </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&amp; </span><span class=identifier>l</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>ForwardRange</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>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
- </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>!=( </span><span class=keyword>const </span><span class=identifier>ForwardRange</span><span class=special>&amp; </span><span class=identifier>l</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&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>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator2 </span><span class=special>&gt;
- </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>&lt;( </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&amp; </span><span class=identifier>l</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator2</span><span class=special>&gt;&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>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
- </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>&lt;( </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&amp; </span><span class=identifier>l</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>ForwardRange</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>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
- </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>&lt;( </span><span class=keyword>const </span><span class=identifier>ForwardRange</span><span class=special>&amp; </span><span class=identifier>l</span><span class=special>,
- </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&amp; </span><span class=identifier>r </span><span class=special>);</span>
-
- <span class=comment>// external construction
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator </span><span class=special>&gt;
- </span><span class=identifier>iterator_range</span><span class=special>&lt; </span><span class=identifier>ForwardTraversalIterator </span><span class=special>&gt;
- </span><span class=identifier>make_iterator_range</span><span class=special>( </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>Begin</span><span class=special>,
- </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>End </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=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>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
- </span><span class=identifier>make_iterator_range</span><span class=special>( </span><span class=identifier>ForwardRange</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>ForwardRange </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>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
- </span><span class=identifier>make_iterator_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardRange</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>Range </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>Range</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;</span>
- <span class=identifier>make_iterator_range</span><span class=special>(</span><span class=identifier> Range</span><span class=special>&amp; </span><span class=identifier>r</span><span class=special>,
- </span><span class=keyword>typename </span><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><span class=identifier>advance_begin</span><span class=special>,
- </span><span class=keyword>typename </span><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><span class=identifier>advance_end </span><span class=special>);
- </span>
- <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Range </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>Range</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;</span>
- <span class=identifier>make_iterator_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>Range</span><span class=special>&amp; </span><span class=identifier>r</span><span class=special>,
- </span><span class=keyword>typename </span><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><span class=identifier>advance_begin</span><span class=special>,
- </span><span class=keyword>typename </span><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><span class=identifier>advance_end </span><span class=special>);</span>
-
- <span class=comment>// convenience
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Sequence</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
- </span><span class=identifier>Sequence </span><a href="#copy_range"><span
-class=identifier>copy_range</span></a><span class=special>( </span><span
-class=keyword>const </span><span class=identifier>ForwardRange</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>
- If an instance of
-<code>iterator_range</code> is constructed by a client with two iterators, the
-client must ensure that the two iterators delimit a valid closed-open range
-<code>[begin,end)</code>.
- </p>
-
-<p>
-It is worth noticing that the templated constructors and assignment operators
-allow conversion from <code>iterator_range&lt;iterator></code> to
-<code>iterator_range&lt;const_iterator></code>. Similarly, since the comparison
-operators have two template arguments, we can compare ranges whenever the
-iterators are comparable; for example when we are dealing with const and
-non-const iterators from the same container. </p>
-
- <h3>Details member functions</h3>
-
-<p>
-<a name="unspecified_bool"></a>
-<code>operator unspecified_bool_type() const; </code>
- <blockquote>
-<i>Returns</i> <code>!empty();</code>
- </blockquote>
-</p>
-
-<p>
-<a name="equal"></a>
-<code>bool equal( iterator_range&amp; r ) const;</code>
-<blockquote>
- <i>Returns</i> <code>begin() == r.begin() &amp;&amp; end() == r.end();</code>
-</blockquote>
-</p>
-
- <h3>Details functions</h3>
-
-<p>
-<a name="comparison"></a>
-<code>bool operator==( const ForwardRange1&amp; l, const ForwardRange2&amp; r );</code>
-<blockquote>
- <i>Returns</i> <code>size(l) != size(r) ? false : std::equal( begin(l), end(l), begin(r) );</code> </blockquote> </p>
-<code>bool operator!=( const ForwardRange1&amp; l, const ForwardRange2&amp; r );</code>
-<blockquote>
- <i>Returns</i> <code>!( l == r );</code>
-</blockquote>
-<code>bool operator<( const ForwardRange1&amp; l, const ForwardRange2&amp; r );</code>
-<blockquote>
- <i>Returns</i> <code>std::lexicographical_compare( begin(l), end(l), begin(r), end(r) );</code> </blockquote>
-
-<p>
-<a name="make_iterator_range"></a>
-<pre>
-iterator_range make_iterator_range( Range&amp; r,
- typename range_difference&lt;Range>::type advance_begin,
- typename range_difference&lt;Range>::type advance_end );
-</pre>
-<blockquote>
- <i>Effects</i>:
-<pre>
-iterator new_begin = begin( r ),
-iterator new_end = end( r );
-std::advance( new_begin, advance_begin );
-std::advance( new_end, advance_end );
-return make_iterator_range( new_begin, new_end );
-</pre>
-</blockquote>
-<p>
-<a name="copy_range"></a>
-<code>Sequence copy_range( const ForwardRange&amp; r );</code>
-<blockquote>
- <i>Returns</i> <code>Sequence( begin(r), end(r) );</code>
-</blockquote>
-</p>
-
-<hr> <a name=sub_range></a>
-<h1>Class <code>sub_range</code></h1>
-
-The <code>sub_range</code> class inherits all its functionality
-from the iterator_range class.
-The <code>sub_range</code> class is often easier to use because
-one must specify the Forward Range
-template argument instead of an iterator. Moreover, the <code>sub_range</code>
-class can propagate constness since it knows what a corresponding
-<code>const_iterator</code> is.
-
-<h3>Synopsis</h3>
-
-<pre>
-<span class=keyword>namespace </span><span class=identifier>boost</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>class </span><span class=identifier>sub_range </span><span class=special>: </span><span class=keyword>public </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>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
- </span><span class=special>{
- </span><span class=keyword>public</span><span class=special>: </span>
- <span class=keyword>typedef </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>iterator</span><span class=special>;</span>
- <span class=keyword>typedef </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>const_iterator</span><span class=special>;</span>
- <span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>iterator_difference</span><span class=special>&lt;</span><span class=identifier>iterator</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>difference_type</span><span class=special>;</span>
-
-
- <span class=keyword>public</span><span class=special>: </span><span class=comment>// construction, assignment
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator </span><span class=special>&gt;
- </span><span class=identifier>sub_range</span><span class=special>( </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>Begin</span><span class=special>, </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>End </span><span class=special>);
-
- </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardRange2 </span><span class=special>&gt;
- </span><span class=identifier>sub_range</span><span class=special>( </span><span class=identifier>ForwardRange2</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>ForwardRange2 </span><span class=special>&gt;
- </span><span class=identifier>sub_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardRange2</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>ForwardRange2 </span><span class=special>&gt;
- </span><span class=identifier>sub_range</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>=( </span><span class=identifier>ForwardRange2</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>ForwardRange2 </span><span class=special>&gt;
- </span><span class=identifier>sub_range</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>=( </span><span class=keyword>const </span><span class=identifier>ForwardRange2</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
- </span>
- <span class=keyword>public</span><span class=special>: </span><span class=comment>// Forward Range functions
- </span><span class=identifier>iterator </span><span class=identifier>begin</span><span class=special>();
- </span><span class=identifier>const_iterator </span><span class=identifier>begin</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
- </span><span class=identifier>iterator </span><span class=identifier>end</span><span class=special>();
- </span><span class=identifier>const_iterator </span><span class=identifier>end</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
-
- <span class=keyword>public</span><span class=special>: </span><span class=comment>// convenience
- </span> <span class=identifier>value_type</span><span class=special>&amp; </span><span class=identifier>front</span><span class=special>();</span>
- <span class=keyword>const </span><span class=identifier>value_type</span><span class=special>&amp; </span><span class=identifier>front</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
- <span class=identifier>value_type</span><span class=special>&amp; </span><span class=identifier>back</span><span class=special>();</span>
- <span class=keyword>const </span><span class=identifier>value_type</span><span class=special>&amp; </span><span class=identifier>back</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
- <span class=comment>// for Random Access Range only: </span>
- <span class=identifier>value_type</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>);</span>
- <span class=keyword>const </span><span class=identifier>value_type</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
-
- <span class=keyword>public</span><span class=special>:
- </span><span class=comment>// rest of interface inherited from iterator_range
- </span><span class=special>};
- </span>
-<span class=special>} </span><span class=comment>// namespace 'boost'</span>
-</pre>
-
- <p>
- The class should be trivial to use as seen below.
- Imagine that we have an algorithm that searches for a sub-string in a string.
- The
- result is an <code>iterator_range</code>, that delimits the match. We need to
-store the result
- from this algorithm. Here is an example of how we can do it with and without
-<code>sub_range</code>
- <pre>
- <span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span> <span class=identifier>str</span><span class=special>(</span><span class=string>&quot;hello&quot;</span><span class=special>);</span>
- <span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>::</span><span class=identifier>iterator</span><span class=special>&gt;</span> <span class=identifier>ir</span> <span class=special>=</span> <span class=identifier>find_first</span><span class=special>(</span> <span class=identifier>str</span><span class=special>,</span> <span class=identifier>as_literal</span><span class=special>(</span><span class=string>&quot;ll&quot;</span><span class=special>)</span> <span class=special>);</span>
- <span class=identifier>sub_range</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&gt;</span> <span class=identifier>sub</span> <span class=special>=</span> <span class=identifier>find_first</span><span class=special>(</span> <span class=identifier>str</span><span class=special>,</span> <span class=identifier>as_literal</span><span class=special>(</span><span class=string>&quot;ll&quot;</span><span class=special>)</span> <span class=special>);</span>
-</pre>
- </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>
-


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk