Boost-Commit :

Date view	Thread view	Subject view	Author view

From: nesotto_at_[hidden]
Date: 2007-10-27 11:58:22

Next message: nesotto_at_[hidden]: "[Boost-commit] svn:boost r40509 - trunk/boost/ptr_container"
Previous message: nesotto_at_[hidden]: "[Boost-commit] svn:boost r40507 - trunk/libs/range/test"

Author: nesotto
Date: 2007-10-27 11:58:22 EDT (Sat, 27 Oct 2007)
New Revision: 40508
URL: http://svn.boost.org/trac/boost/changeset/40508

Log:
first update ... more to come
Binary files modified:
   trunk/libs/range/doc/Jamfile.v2
Text files modified:
   trunk/libs/range/doc/boost_range.html | 1226 +++++++++++++++++++--------------------
   trunk/libs/range/doc/headers.html | 54 +
   trunk/libs/range/doc/intro.html | 20
   trunk/libs/range/doc/utility_class.html | 6
   4 files changed, 657 insertions(+), 649 deletions(-)

Modified: trunk/libs/range/doc/Jamfile.v2
==============================================================================
Binary files. No diff available.

Modified: trunk/libs/range/doc/boost_range.html
==============================================================================
--- trunk/libs/range/doc/boost_range.html (original)
+++ trunk/libs/range/doc/boost_range.html 2007-10-27 11:58:22 EDT (Sat, 27 Oct 2007)
@@ -1,86 +1,83 @@
<!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> 
- 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>
- 
- Four types of objects are currently supported by the library:
- <ul>
- <li>
- standard-like containers
- <li>
- <code>std::pair<iterator,iterator></code>
- <li>
- null terminated strings (this includes <code>char[]</code>,<code>wchar_t[]</code>,
- <code>char*</code>, and <code>wchar_t*</code>)
- 
- Warning: support for null-terminated strings is deprecated and will
- disappear in the next Boost release (1.34). 
- 
- <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>
- .
- 
- 
- Please also see Range concepts for more details.
- 
- <a name="Synopsis"></a>
- <h3>Synopsis</h3>
- 
- <pre>
+ <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> 
+ 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>
+ 
+ Three types of objects are currently supported by the library:
+ <ul>
+ <li>
+ standard-like containers
+ <li>
+ <code>std::pair<iterator,iterator></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>
+ .
+ 
+ 
+ Please also see Range concepts for more details.
+ 
+ <a name="Synopsis"></a>
+ <h3>Synopsis</h3>
+ 
+ <pre>
namespace boost
{
 //
 // Single Pass Range metafunctions
 //
+
+ template< class T >
+ struct <a href="#range_iterator">range_iterator</a>;

 template< class T >
 struct <a href="#range_value">range_value</a>;
-
+
 template< class T >
- struct <a href="#range_iterator">range_iterator</a>;
+ struct <a href="#range_pointer">range_pointer</a>;

 template< class T >
- struct <a href="#range_const_iterator">range_const_iterator</a>;
-
+ struct <a href="#range_category">range_category</a>;
+
 //
 // Forward Range metafunctions
 //
@@ -89,10 +86,6 @@
 struct <a href="#range_difference">range_difference</a>;

- template< class T >
- struct <a href="#range_size">range_size</a>;
-
 //
 // Bidirectional Range metafunctions
 //
@@ -102,24 +95,14 @@
href="#range_reverse_iterator">range_reverse_iterator</a>;

- template< class T >
- struct <a
-href="#range_const_reverse_iterator">range_const_reverse_iterator</a>;
-
 //
- // Special metafunctions
+ // Random Access Range metafunctions
 //

 template< class T >
- struct <a href="#range_result_iterator">range_result_iterator</a>;
-
- template< class T >
- struct <a
-href="#range_reverse_result_iterator">range_reverse_result_iterator</a>;
-
+ struct <a href="#range_size">range_size</a>;
+
 //
 // Single Pass Range functions
 //
@@ -129,7 +112,7 @@
 begin( T& c );

 template< class T >
- typename range_const_iterator<T>::type
+ typename range_iterator<T>::type
 begin( const T& c );

 template< class T >
@@ -137,7 +120,7 @@
 end( T& c );

 template< class T >
- typename range_const_iterator<T>::type
+ typename range_iterator<T>::type
 end( const T& c );

 template< class T >
@@ -149,8 +132,8 @@
 //

 template< class T >
- typename range_size<T>::type
- size( const T& c );
+ typename range_difference<T>::type
+ distance( const T& c );

 //
 // Bidirectional Range functions
@@ -161,7 +144,7 @@
 rbegin( T& c );

 template< class T >
- typename range_const_reverse_iterator<T>::type
+ typename range_reverse_iterator<T>::type
 rbegin( const T& c );

 template< class T >
@@ -169,535 +152,544 @@
 rend( T& c );

 template< class T >
- typename range_const_reverse_iterator<T>::type
+ typename range_reverse_iterator<T>::type
 rend( const T& c );
 
+
+ //
+ // Random Access Range functions
+ //
+
+ template< class T >
+ typename range_size<T>::type
+ size( const T& c );
+
 //
 // Special const Range functions
 //
 
 template< class T >
- typename range_const_iterator<T>::type 
+ typename range_iterator<const T>::type 
 <a href="#const_begin">const_begin</a>( const T& r );
 
 template< class T >
- typename range_const_iterator<T>::type 
+ typename range_iterator<const T>::type 
 <a href="#const_end">const_end</a>( const T& r );
 
 template< class T >
- typename range_const_reverse_iterator<T>::type 
+ typename range_reverse_iterator<const T>::type 
 <a href="#const_rbegin">const_rbegin</a>( const T& r );
 
 template< class T >
- typename range_const_reverse_iterator<T>::type 
+ typename range_reverse_iterator<const T>::type 
 <a href="#const_rend">const_rend</a>( const T& r );

} // namespace 'boost'

</pre>
- 
- <a name="Semantics"></a>
- <h3>Semantics</h3>
- <h4>notation</h4>
- 
- <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<iterator,iterator></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>
- 
- 
- 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.
- 
- <h4>Metafunctions</h4>
- 
- <table border="1" cellpadding="5">
- <tr>
- <th>
- Expression</th>
- <th>
- Return type</th>
- <th>
- Complexity</th>
- </tr>
- <tr>
- <a name="range_value"></a>
- <td><code>range_value<X>::type</code></td>
- <td><code>T::value_type</code> 
- <code>boost::iterator_value<P::first_type>::type</code>  
- <code>A</code> 
- <code>Char</code>
- <td>compile time</td>
- </tr>
- <tr>
- <a name="range_iterator"></a>
- <td><code>range_iterator<X>::type</code></td>
- <td><code>T::iterator</code> 
- <code>P::first_type</code> 
- <code>A*</code> 
- <code>Char*</code>
- <td>compile time</td>
- </tr>
- <tr>
- <a name="range_const_iterator"></a>
- <td><code>range_const_iterator<X>::type</code></td>
- <td><code>T::const_iterator</code> 
- <code>P::first_type</code> 
- <code>const A*</code> 
- <code>const Char*</code>
- <td>compile time</td>
- </tr>
- <tr>
- <a name="range_difference"></a>
- <td><code>range_difference<X>::type</code></td>
- <td><code>T::difference_type</code> 
- <code>boost::iterator_difference<P::first_type>::type</code> 
- <code>std::ptrdiff_t</code> 
- <code>std::ptrdiff_t</code> 
- <td>compile time</td>
- </tr>
- <tr>
- <a name="range_size"></a>
- <td><code>range_size<X>::type</code></td>
- <td><code>T::size_type</code> 
- <code>std::size_t</code> 
- <code>std::size_t</code> 
- <code>std::size_t</code> 
- <td>compile time</td>
- </tr>
- <tr>
- <a name="range_result_iterator"></a>
- <td><code>range_result_iterator<X>::type</code></td>
- <td><code>range_const_iterator<X>::type</code> if <code>X</code> is <code>const</code>
- 
- <code>range_iterator<X>::type</code> otherwise
- </td>
- <td>compile time</td>
- </tr>
- <tr>
- <a name="range_reverse_iterator"></a>
- <td><code>range_reverse_iterator<X>::type</code></td>
- <td><code>boost::reverse_iterator< typename range_iterator<T>::type ></code> 
- <td>compile time</td>
- </tr>
- <tr>
- <a name="range_const_reverse_iterator"></a>
- <td><code>range_const_reverse_iterator<X>::type</code></td>
- <td><code>boost::reverse_iterator< typename range_const_iterator<T>::type ></code>
- 
- <td>compile time</td>
- </tr>
- <tr>
- <a name="range_reverse_result_iterator"></a>
- <td><code>range_reverse_result_iterator<X>::type</code></td>
- <td><code>boost::reverse_iterator< typename range_result_iterator<T>::type
- ></code>
- <td>compile time</td>
- </tr>
- </table>
- 
- 
- The special metafunctions <code>range_result_iterator</code> and <code>range_reverse_result_iterator</code>
- are not part of any Range concept, but they are very useful when implementing
- certain Range classes like sub_range
- because of their ability to select iterators based on constness.
- 
- <h4>Functions</h4>
- 
- <table border="1" cellpadding="5">
- <tr>
- <th>
- Expression</th>
- <th>
- Return type</th>
- <th>
- Returns</th>
- <th>
- Complexity</th>
- </tr>
- <tr>
- <a name="begin"></a>
- <td><code>begin(x)</code></td>
- <td><code>range_result_iterator<X>::type</code></td>
- <td>
- <code>p.first</code> if <code>p</code> is of type <code>std::pair&ltT><code> 
- <code>a</code> if <code>a</code> is an array 
- <code>s</code> if <code>s</code> is a string literal 
- <code>boost_range_begin(x)</code> if that expression would invoke a function found by ADL 
- <code>t.begin()</code> otherwise
+ 
+ <a name="Semantics"></a>
+ <h3>Semantics</h3>
+ <h4>notation</h4>
+ 
+ <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<iterator,iterator></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>
+ 
+ 
+ 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.
+ 
+ <h4>Metafunctions</h4>
+ 
+ <table border="1" cellpadding="5">
+ <tr>
+ <th>
+ Expression</th>
+ <th>
+ Return type</th>
+ <th>
+ Complexity</th>
+ </tr>
+ <tr>
+ <a name="range_value"></a>
+ <td><code>range_value<X>::type</code></td>
+ <td><code>T::value_type</code> 
+ <code>boost::iterator_value<P::first_type>::type</code>  
+ <code>A</code> 
+ <code>Char</code>
+ <td>compile time</td>
+ </tr>
+ <tr>
+ <a name="range_iterator"></a>
+ <td><code>range_iterator<X>::type</code></td>
+ <td><code>T::iterator</code> 
+ <code>P::first_type</code> 
+ <code>A*</code> 
+ <code>Char*</code>
+ <td>compile time</td>
+ </tr>
+ <tr>
+ <a name="range_const_iterator"></a>
+ <td><code>range_const_iterator<X>::type</code></td>
+ <td><code>T::const_iterator</code> 
+ <code>P::first_type</code> 
+ <code>const A*</code> 
+ <code>const Char*</code>
+ <td>compile time</td>
+ </tr>
+ <tr>
+ <a name="range_difference"></a>
+ <td><code>range_difference<X>::type</code></td>
+ <td><code>T::difference_type</code> 
+ <code>boost::iterator_difference<P::first_type>::type</code> 
+ <code>std::ptrdiff_t</code> 
+ <code>std::ptrdiff_t</code> 
+ <td>compile time</td>
+ </tr>
+ <tr>
+ <a name="range_size"></a>
+ <td><code>range_size<X>::type</code></td>
+ <td><code>T::size_type</code> 
+ <code>std::size_t</code> 
+ <code>std::size_t</code> 
+ <code>std::size_t</code> 
+ <td>compile time</td>
+ </tr>
+ <tr>
+ <a name="range_result_iterator"></a>
+ <td><code>range_result_iterator<X>::type</code></td>
+ <td><code>range_const_iterator<X>::type</code> if <code>X</code> is <code>const</code>
+ 
+ <code>range_iterator<X>::type</code> otherwise
+ </td>
+ <td>compile time</td>
+ </tr>
+ <tr>
+ <a name="range_reverse_iterator"></a>
+ <td><code>range_reverse_iterator<X>::type</code></td>
+ <td><code>boost::reverse_iterator< typename range_iterator<T>::type ></code> 
+ <td>compile time</td>
+ </tr>
+ <tr>
+ <a name="range_const_reverse_iterator"></a>
+ <td><code>range_const_reverse_iterator<X>::type</code></td>
+ <td><code>boost::reverse_iterator< typename range_const_iterator<T>::type ></code>
+ 
+ <td>compile time</td>
+ </tr>
+ <tr>
+ <a name="range_reverse_result_iterator"></a>
+ <td><code>range_reverse_result_iterator<X>::type</code></td>
+ <td><code>boost::reverse_iterator< typename range_result_iterator<T>::type
+ ></code>
+ <td>compile time</td>
+ </tr>
+ </table>
+ 
+ 
+ The special metafunctions <code>range_result_iterator</code> and <code>range_reverse_result_iterator</code>
+ are not part of any Range concept, but they are very useful when implementing
+ certain Range classes like sub_range
+ because of their ability to select iterators based on constness.
+ 
+ <h4>Functions</h4>
+ 
+ <table border="1" cellpadding="5">
+ <tr>
+ <th>
+ Expression</th>
+ <th>
+ Return type</th>
+ <th>
+ Returns</th>
+ <th>
+ Complexity</th>
+ </tr>
+ <tr>
+ <a name="begin"></a>
+ <td><code>begin(x)</code></td>
+ <td><code>range_result_iterator<X>::type</code></td>
+ <td>
+ <code>p.first</code> if <code>p</code> is of type <code>std::pair&ltT><code> 
+ <code>a</code> if <code>a</code> is an array 
+ <code>s</code> if <code>s</code> is a string literal 
+ <code>boost_range_begin(x)</code> if that expression would invoke a function found by ADL 
+ <code>t.begin()</code> otherwise

- <td>constant time</td>
- </tr>
- <tr>
- <a name="end"></a>
- <td><code>end(x)</code></td>
- <td><code>range_result_iterator<X>::type</code></td>
- <td>
- <code>p.second</code> if <code>p</code> is of type <code>std::pair&ltT><code> 
- <code>a + sz</code> if <code>a</code> is an array of size <code>sz</code> 
- <code>s + std::char_traits<X>::length( s )</code> if <code>s</code> is a <code>Char*</code>
- 
- <code>s + sz - 1</code> if <code>s</code> is a string literal of size <code>sz</code>
- 
- <code>boost_range_end(x)</code> if that expression would invoke a function found by ADL 
- <code>t.end()</code> otherwise
-
- <td>linear if <code>X</code> is <code>Char*</code>
- 
- constant time otherwise</td>
- </tr>
- <tr>
- <a name="empty"></a>
- <td><code>empty(x)</code></td>
- <td><code>bool</code></td>
- <td><code>begin(x) == end( x )</code> 
- <td>linear if <code>X</code> is <code>Char*</code>
- 
- constant time otherwise 
- </td>
- </tr>
- <tr>
- <a name="size"></a>
- <td><code>size(x)</code></td>
- <td><code>range_size<X>::type</code></td>
- <td>
- <code>std::distance(p.first,p.second)</code> if <code>p</code> is of type <code>std::pair&ltT><code> 
- <code>sz</code> if <code>a</code> is an array of size <code>sz</code> 
- <code>end(s) - s</code> if <code>s</code> is a string literal or a <code>Char*</code> 
- <code>boost_range_size(x)</code> if that expression would invoke a function found by ADL 
- <code>t.size()</code> otherwise
- <td>linear if <code>X</code> is <code>Char*</code>
- 
- or if <code>std::distance()</code> is linear
- 
- constant time otherwise</td>
- </tr>
- <tr>
- <a name="rbegin"></a>
- <td><code>rbegin(x)</code></td>
- <td><code>range_reverse_result_iterator<X>::type</code></td>
- <td><code>range_reverse_result_iterator<X>::type( end(x) )</code>
- 
- <td>same as <code>end(x)</code>
- </td>
- </tr>
- <tr>
- <a name="rend"></a>
- <td><code>rend(x)</code></td>
- <td><code>range_reverse_result_iterator<X>::type</code></td>
- <td><code>range_reverse_result_iterator<X>::type( begin(x) )</code>
- <td>same as <code>begin(x)</code></td>
- </tr>
- <tr>
- <a name="const_begin"></a>
- <td><code>const_begin(x)</code></td>
- <td><code>range_const_iterator<X>::type</code></td>
- <td><code>range_const_iterator<X>::type( begin(x) )</code>
- 
- <td>same as <code>begin(x)</code>
- </td>
- </tr>
- <tr>
- <a name="const_end"></a>
- <td><code>const_end(x)</code></td>
- <td><code>range_const_iterator<X>::type</code></td>
- <td><code>range_const_iterator<X>::type( end(x) )</code>
- <td>same as <code>end(x)</code></td>
- </tr>
- <tr>
- <a name="const_rbegin"></a>
- <td><code>const_rbegin(x)</code></td>
- <td><code>range_const_reverse_iterator<X>::type</code></td>
- <td><code>range_const_reverse_iterator<X>::type( rbegin(x) )</code>
- 
- <td>same as <code>rbegin(x)</code>
- </td>
- </tr>
- <tr>
- <a name="const_rend"></a>
- <td><code>const_rend(x)</code></td>
- <td><code>range_const_reverse_iterator<X>::type</code></td>
- <td><code>range_const_reverse_iterator<X>::type( rend(x) )</code>
- <td>same as <code>rend(x)</code></td>
- </tr>
- </table>
- 
- 
- The special <code>const</code> functions are not part of any Range concept, but
- are very useful when you want to document clearly that your code is read-only.
- 
- <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>
-
- 
-
- <a name="method1"></a>
- <h4>Method 1: provide member functions and nested types</h4>
-
- 
- This procedure assumes that you have control over the types that should be made
- conformant to a Range concept. If not, see method 2.
- 
-
- 
- 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.
- 
- 
- <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>
- <tr>
- <td><code>size()</code></td>
- <td>Forward Range</td>
- </tr>
- </table>
- 
- 
- Notice that <code>rbegin()</code> and <code>rend()</code> member functions are
- not needed even though the container can support bidirectional iteration.
- 
- 
- The required member types are:
- 
- 
- <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>
- <tr>
- <td><code>size_type</code></td>
- <td>Forward Range</td>
- </tr>
- </table>
- 
- 
- Again one should notice that member types <code>reverse_iterator</code> and <code>const_reverse_iterator</code>
- are not needed.
- 
- <a name="method2"></a>
- <h4>Method 2: provide free-standing functions and specialize metafunctions</h4>
-
- 
- 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.
- 
-
- 
- 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.
- 
- 
- <table cellpadding="5" border="1" ID="Table1">
- <tr>
- <th>
- Function</th>
- <th>
- Related concept</th>
- <tr>
- <td><code>boost_range_begin(x)</code></td>
- <td>Single Pass Range</td>
- </tr>
- <tr>
- <td><code>boost_range_end(x)</code>
- </td>
- <td>Single Pass Range</td>
- </tr>
- <tr>
- <td><code>boost_range_size(x)</code></td>
- <td>Forward Range</td>
- </tr>
- </table>
- 
- <code>boost_range_begin()</code> and <code>boost_range_end()</code> must be
- overloaded for both <code>const</code> and mutable reference arguments.
- 
-
- 
- You must also specialize 3 metafunctions for your type <code>X</code>:
- 
- 
- <table cellpadding="5" border="1" ID="Table2">
- <tr>
- <th>
- Metafunction</th>
- <th>
- Related concept</th>
- <tr>
- <td><code>boost::range_iterator</code></td>
- <td>Single Pass Range</td>
- </tr>
- <tr>
- <td><code>boost::range_const_iterator</code></td>
- <td>Single Pass Range</td>
- </tr>
- <tr>
- <td><code>boost::range_size</code></td>
- <td>Forward Range</td>
- </tr>
- </table>
- 
- 
- A complete example is given here:
- 
- <blockquote>
- <pre>
+ <td>constant time</td>
+ </tr>
+ <tr>
+ <a name="end"></a>
+ <td><code>end(x)</code></td>
+ <td><code>range_result_iterator<X>::type</code></td>
+ <td>
+ <code>p.second</code> if <code>p</code> is of type <code>std::pair&ltT><code> 
+ <code>a + sz</code> if <code>a</code> is an array of size <code>sz</code> 
+ <code>s + std::char_traits<X>::length( s )</code> if <code>s</code> is a <code>Char*</code>
+ 
+ <code>s + sz - 1</code> if <code>s</code> is a string literal of size <code>sz</code>
+ 
+ <code>boost_range_end(x)</code> if that expression would invoke a function found by ADL 
+ <code>t.end()</code> otherwise
+
+ <td>linear if <code>X</code> is <code>Char*</code>
+ 
+ constant time otherwise</td>
+ </tr>
+ <tr>
+ <a name="empty"></a>
+ <td><code>empty(x)</code></td>
+ <td><code>bool</code></td>
+ <td><code>begin(x) == end( x )</code> 
+ <td>linear if <code>X</code> is <code>Char*</code>
+ 
+ constant time otherwise 
+ </td>
+ </tr>
+ <tr>
+ <a name="size"></a>
+ <td><code>size(x)</code></td>
+ <td><code>range_size<X>::type</code></td>
+ <td>
+ <code>std::distance(p.first,p.second)</code> if <code>p</code> is of type <code>std::pair&ltT><code> 
+ <code>sz</code> if <code>a</code> is an array of size <code>sz</code> 
+ <code>end(s) - s</code> if <code>s</code> is a string literal or a <code>Char*</code> 
+ <code>boost_range_size(x)</code> if that expression would invoke a function found by ADL 
+ <code>t.size()</code> otherwise
+ <td>linear if <code>X</code> is <code>Char*</code>
+ 
+ or if <code>std::distance()</code> is linear
+ 
+ constant time otherwise</td>
+ </tr>
+ <tr>
+ <a name="rbegin"></a>
+ <td><code>rbegin(x)</code></td>
+ <td><code>range_reverse_result_iterator<X>::type</code></td>
+ <td><code>range_reverse_result_iterator<X>::type( end(x) )</code>
+ 
+ <td>same as <code>end(x)</code>
+ </td>
+ </tr>
+ <tr>
+ <a name="rend"></a>
+ <td><code>rend(x)</code></td>
+ <td><code>range_reverse_result_iterator<X>::type</code></td>
+ <td><code>range_reverse_result_iterator<X>::type( begin(x) )</code>
+ <td>same as <code>begin(x)</code></td>
+ </tr>
+ <tr>
+ <a name="const_begin"></a>
+ <td><code>const_begin(x)</code></td>
+ <td><code>range_const_iterator<X>::type</code></td>
+ <td><code>range_const_iterator<X>::type( begin(x) )</code>
+ 
+ <td>same as <code>begin(x)</code>
+ </td>
+ </tr>
+ <tr>
+ <a name="const_end"></a>
+ <td><code>const_end(x)</code></td>
+ <td><code>range_const_iterator<X>::type</code></td>
+ <td><code>range_const_iterator<X>::type( end(x) )</code>
+ <td>same as <code>end(x)</code></td>
+ </tr>
+ <tr>
+ <a name="const_rbegin"></a>
+ <td><code>const_rbegin(x)</code></td>
+ <td><code>range_const_reverse_iterator<X>::type</code></td>
+ <td><code>range_const_reverse_iterator<X>::type( rbegin(x) )</code>
+ 
+ <td>same as <code>rbegin(x)</code>
+ </td>
+ </tr>
+ <tr>
+ <a name="const_rend"></a>
+ <td><code>const_rend(x)</code></td>
+ <td><code>range_const_reverse_iterator<X>::type</code></td>
+ <td><code>range_const_reverse_iterator<X>::type( rend(x) )</code>
+ <td>same as <code>rend(x)</code></td>
+ </tr>
+ </table>
+ 
+ 
+ The special <code>const</code> functions are not part of any Range concept, but
+ are very useful when you want to document clearly that your code is read-only.
+ 
+ <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>
+
+ 
+
+ <a name="method1"></a>
+ <h4>Method 1: provide member functions and nested types</h4>
+
+ 
+ This procedure assumes that you have control over the types that should be made
+ conformant to a Range concept. If not, see method 2.
+ 
+
+ 
+ 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.
+ 
+ 
+ <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>
+ <tr>
+ <td><code>size()</code></td>
+ <td>Forward Range</td>
+ </tr>
+ </table>
+ 
+ 
+ Notice that <code>rbegin()</code> and <code>rend()</code> member functions are
+ not needed even though the container can support bidirectional iteration.
+ 
+ 
+ The required member types are:
+ 
+ 
+ <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>
+ <tr>
+ <td><code>size_type</code></td>
+ <td>Forward Range</td>
+ </tr>
+ </table>
+ 
+ 
+ Again one should notice that member types <code>reverse_iterator</code> and <code>const_reverse_iterator</code>
+ are not needed.
+ 
+ <a name="method2"></a>
+ <h4>Method 2: provide free-standing functions and specialize metafunctions</h4>
+
+ 
+ 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.
+ 
+
+ 
+ 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.
+ 
+ 
+ <table cellpadding="5" border="1" ID="Table1">
+ <tr>
+ <th>
+ Function</th>
+ <th>
+ Related concept</th>
+ <tr>
+ <td><code>boost_range_begin(x)</code></td>
+ <td>Single Pass Range</td>
+ </tr>
+ <tr>
+ <td><code>boost_range_end(x)</code>
+ </td>
+ <td>Single Pass Range</td>
+ </tr>
+ <tr>
+ <td><code>boost_range_size(x)</code></td>
+ <td>Forward Range</td>
+ </tr>
+ </table>
+ 
+ <code>boost_range_begin()</code> and <code>boost_range_end()</code> must be
+ overloaded for both <code>const</code> and mutable reference arguments.
+ 
+
+ 
+ You must also specialize 3 metafunctions for your type <code>X</code>:
+ 
+ 
+ <table cellpadding="5" border="1" ID="Table2">
+ <tr>
+ <th>
+ Metafunction</th>
+ <th>
+ Related concept</th>
+ <tr>
+ <td><code>boost::range_iterator</code></td>
+ <td>Single Pass Range</td>
+ </tr>
+ <tr>
+ <td><code>boost::range_const_iterator</code></td>
+ <td>Single Pass Range</td>
+ </tr>
+ <tr>
+ <td><code>boost::range_size</code></td>
+ <td>Forward Range</td>
+ </tr>
+ </table>
+ 
+ 
+ A complete example is given here:
+ 
+ <blockquote>
+ <pre>
#include <boost/range.hpp>
#include <iterator> // for std::iterator_traits, std::distance()

namespace Foo
{
- //
- // Our sample UDT. A 'Pair'
- // will work as a range when the stored
- // elements are iterators.
- //
- template< class T >
- struct Pair
- {
- T first, last;
- };
+ //
+ // Our sample UDT. A 'Pair'
+ // will work as a range when the stored
+ // elements are iterators.
+ //
+ template< class T >
+ struct Pair
+ {
+ T first, last;
+ };

} // namespace 'Foo'

namespace boost
{
- //
- // Specialize metafunctions. We must include the range.hpp header.
- // We must open the 'boost' namespace.
- //
-
- template< class T >
- struct range_iterator< Foo::Pair<T> >
- {
- typedef T type;
- };
-
- template< class T >
- struct range_const_iterator< Foo::Pair<T> >
- {
- //
- // Remark: this is defined similar to 'range_iterator'
- // because the 'Pair' type does not distinguish
- // between an iterator and a const_iterator.
- //
- typedef T type;
- };
-
- template< class T >
- struct range_size< Foo::Pair<T> >
- {
+ //
+ // Specialize metafunctions. We must include the range.hpp header.
+ // We must open the 'boost' namespace.
+ //
+
+ template< class T >
+ struct range_iterator< Foo::Pair<T> >
+ {
+ typedef T type;
+ };
+
+ template< class T >
+ struct range_const_iterator< Foo::Pair<T> >
+ {
+ //
+ // Remark: this is defined similar to 'range_iterator'
+ // because the 'Pair' type does not distinguish
+ // between an iterator and a const_iterator.
+ //
+ typedef T type;
+ };
+
+ template< class T >
+ struct range_size< Foo::Pair<T> >
+ {

- typedef std::size_t type;
- };
+ typedef std::size_t type;
+ };

} // namespace 'boost'

namespace Foo
{
- //
- // The required functions. These should be defined in
- // the same namespace as 'Pair', in this case
- // in namespace 'Foo'.
- //
-
- template< class T >
- inline T boost_range_begin( Pair<T>& x )
- {
- return x.first;
- }
-
- template< class T >
- inline T boost_range_begin( const Pair<T>& x )
- {
- return x.first;
- }
-
- template< class T >
- inline T boost_range_end( Pair<T>& x )
- {
- return x.last;
- }
-
- template< class T >
- inline T boost_range_end( const Pair<T>& x )
- {
- return x.last;
- }
-
- template< class T >
- inline typename boost::range_size< Pair<T> >::type
- boost_range_size( const Pair<T>& x )
- {
- return std::distance(x.first,x.last);
- }
+ //
+ // The required functions. These should be defined in
+ // the same namespace as 'Pair', in this case
+ // in namespace 'Foo'.
+ //
+
+ template< class T >
+ inline T boost_range_begin( Pair<T>& x )
+ {
+ return x.first;
+ }
+
+ template< class T >
+ inline T boost_range_begin( const Pair<T>& x )
+ {
+ return x.first;
+ }
+
+ template< class T >
+ inline T boost_range_end( Pair<T>& x )
+ {
+ return x.last;
+ }
+
+ template< class T >
+ inline T boost_range_end( const Pair<T>& x )
+ {
+ return x.last;
+ }
+
+ template< class T >
+ inline typename boost::range_size< Pair<T> >::type
+ boost_range_size( const Pair<T>& x )
+ {
+ return std::distance(x.first,x.last);
+ }

} // namespace 'Foo'

@@ -705,41 +697,41 @@

int main()
{
- typedef std::vector<int>::iterator iter;
- std::vector<int> vec;
- Foo::Pair<iter> pair = { vec.begin(), vec.end() };
- const Foo::Pair<iter>& cpair = pair;
- //
- // Notice that we call 'begin' etc with qualification.
- //
- iter i = boost::begin( pair );
- iter e = boost::end( pair );
- i = boost::begin( cpair );
- e = boost::end( cpair );
- boost::range_size< Foo::Pair<iter> >::type s = boost::size( pair );
- s = boost::size( cpair );
- boost::range_const_reverse_iterator< Foo::Pair<iter> >::type
- ri = boost::rbegin( cpair ),
- re = boost::rend( cpair );
-}
+ typedef std::vector<int>::iterator iter;
+ std::vector<int> vec;
+ Foo::Pair<iter> pair = { vec.begin(), vec.end() };
+ const Foo::Pair<iter>& cpair = pair;
+ //
+ // Notice that we call 'begin' etc with qualification.
+ //
+ iter i = boost::begin( pair );
+ iter e = boost::end( pair );
+ i = boost::begin( cpair );
+ e = boost::end( cpair );
+ boost::range_size< Foo::Pair<iter> >::type s = boost::size( pair );
+ s = boost::size( cpair );
+ boost::range_const_reverse_iterator< Foo::Pair<iter> >::type
+ ri = boost::rbegin( cpair ),
+ re = boost::rend( cpair );
+}
</pre>
</blockquote>
-
- <hr>
- 
- (C) Copyright Thorsten Ottosen 2003-2004
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- </body>
+
+ <hr>
+ 
+ (C) Copyright Thorsten Ottosen 2003-2004
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ </body>
</html>

Modified: trunk/libs/range/doc/headers.html
==============================================================================
--- trunk/libs/range/doc/headers.html (original)
+++ trunk/libs/range/doc/headers.html 2007-10-27 11:58:22 EDT (Sat, 27 Oct 2007)
@@ -50,6 +50,12 @@
>range_iterator</a></td>
 <td>Single Pass Range </td>
 </tr>
+ <tr >
+ <td ><code ><boost/range/mutable_iterator.hpp></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 ><boost/range/const_iterator.hpp></code></td>
 <td ><a href="boost_range.html#range_const_iterator"
@@ -67,28 +73,25 @@
 <td >range_size</td>
 <td>Forward Range </td>
 </tr>
- <tr >
- <td ><code ><boost/range/result_iterator.hpp></code></td>
- <td ><a href="boost_range.html#range_result_iterator"
- >range_result_iterator</a></td>
+ <tr >
+ <td ><code ><boost/range/pointer.hpp></code></td>
+ <td ><a href="boost_range.html#range_pointer"
+ >range_pointer</a></td>
 <td>- </td>
 </tr>
+ <tr >
+ <td ><code ><boost/range/category.hpp></code></td>
+ <td ><a href="boost_range.html#range_category"
+ >range_category</a></td>
+ <td>- </td>
+ </tr>
+
 <tr >
 <td ><code ><boost/range/reverse_iterator.hpp></code></td>
 <td >range_reverse_iterator</td>
 <td>Bidirectional Range </td>
 </tr>
 <tr >
- <td ><code ><boost/range/const_reverse_iterator.hpp></code></td>
- <td >range_const_reverse_iterator</td>
- <td>Bidirectional Range </td>
- </tr>
- <tr >
- <td ><code ><boost/range/reverse_result_iterator.hpp></code></td>
- <td >range_reverse_result_iterator</td>
- <td>- </td>
- </tr>
- <tr >
 <td ><code ><boost/range/begin.hpp></code></td>
 <td >
 <a href="boost_range.html#begin" >begin</a> and
@@ -109,10 +112,16 @@
 <td >empty</td>
 <td>Single Pass Range </td>
 </tr>
+ <tr >
+ <td ><code ><boost/range/distance.hpp></code></td>
+ <td >distance</td>
+ <td>Forward Range </td>
+ </tr>
 <tr >
 <td ><code ><boost/range/size.hpp></code></td>
 <td >size</td>
- <td>Forward Range </td>
+ <td>Random Access Range
+ </td>
 </tr>
 <tr >
 <td ><code ><boost/range/rbegin.hpp></code></td>
@@ -130,6 +139,21 @@
 </td>
 <td>Bidirectional Range </td>
 </tr>
+ <tr >
+ <td ><code ><boost/range/as_array.hpp></code></td>
+ <td >
+ as_array
+ </td>
+ <td>-</td>
+ </tr>
+ <tr >
+ <td ><code ><boost/range/as_literal.hpp></code></td>
+ <td >
+ as_literal
+ </td>
+ <td>-</td>
+ </tr>
+
 <tr >
 <td ><code ><boost/range/iterator_range.hpp></code></td>
 <td ><a href="utility_class.html#iter_range"

Modified: trunk/libs/range/doc/intro.html
==============================================================================
--- trunk/libs/range/doc/intro.html (original)
+++ trunk/libs/range/doc/intro.html 2007-10-27 11:58:22 EDT (Sat, 27 Oct 2007)
@@ -60,22 +60,14 @@
 more flexible, compact and maintainable client code
 </li>
 <li >
- correct handling of null-terminated strings
- 
- Warning: support for null-terminated strings is deprecated and will
- disappear in the next Boost release (1.34). 
- 
+ safe use of built-in arrays
 </li>
- <li >
- safe use of built-in arrays (for legacy code; why else would you use
- built-in arrays?) </li>

 </ul>
 
 
- Below are given a small example (the complete example can be found here
- ):
- <blockquote>
+ Below are given a small example (the complete example can be found <a
+ href="../test/algorithm_example.cpp" target="_self" >here</a>): <blockquote>
 <pre >

 //
@@ -89,7 +81,7 @@
 }

 template< class ForwardReadableRange, class T >
- inline typename boost::range_const_iterator< inline typename boost::range_iterator< const ForwardReadableRange >::type
 find( const ForwardReadableRange& c, const T& value )
 {
@@ -100,7 +92,7 @@
 // replace first value and return its index
 //
 template< class ForwardReadableWriteableRange, class T >
- inline typename boost::range_size< ForwardReadableWriteableRange >::type
+ inline typename boost::range_difference< ForwardReadableWriteableRange >::type
 my_generic_replace( ForwardReadableWriteableRange& c, const T& value, const T& replacement )
 {
 typename boost::range_iterator< ForwardReadableWriteableRange >::type found = find( c, value );
@@ -146,7 +138,7 @@

 <hr>
 
- (C) Copyright Thorsten Ottosen 2003-2004
+ (C) Copyright Thorsten Ottosen 2003-2007

Modified: trunk/libs/range/doc/utility_class.html
==============================================================================
--- trunk/libs/range/doc/utility_class.html (original)
+++ trunk/libs/range/doc/utility_class.html 2007-10-27 11:58:22 EDT (Sat, 27 Oct 2007)
@@ -173,11 +173,11 @@
 ForwardTraversalIterator End );

 template< class ForwardRange >
- iterator_range< typename iterator_of<ForwardRange>::type >
+ iterator_range< typename iterator<ForwardRange>::type >
 make_iterator_range( ForwardRange& r );

 template< class ForwardRange >
- iterator_range< typename const_iterator_of<ForwardRange>::type >
+ iterator_range< typename const_iterator<ForwardRange>::type >
 make_iterator_range( const ForwardRange& r );
 
 template< class Range >
@@ -305,7 +305,7 @@
 sub_range( ForwardRange2& r );

 template< class ForwardRange2 >
- sub_range( const Range2& r );
+ sub_range( const ForwardRange2& r );

 template< class ForwardRange2 >
 sub_range& operator=( ForwardRange2& r );

Next message: nesotto_at_[hidden]: "[Boost-commit] svn:boost r40509 - trunk/boost/ptr_container"
Previous message: nesotto_at_[hidden]: "[Boost-commit] svn:boost r40507 - trunk/libs/range/test"

Date view	Thread view	Subject view	Author view

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