Boost logo

Boost-Commit :

From: nesotto_at_[hidden]
Date: 2008-06-24 11:42:54


Author: nesotto
Date: 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
New Revision: 46652
URL: http://svn.boost.org/trac/boost/changeset/46652

Log:
more changes from trunk
Text files modified:
   branches/release/libs/range/doc/boost_range.html | 110 ++++++++++++++++++++--------------------
   branches/release/libs/range/doc/examples.html | 8 +-
   branches/release/libs/range/doc/faq.html | 4
   branches/release/libs/range/doc/headers.html | 2
   branches/release/libs/range/doc/intro.html | 2
   branches/release/libs/range/doc/portability.html | 5 -
   branches/release/libs/range/doc/range.html | 14 ++--
   branches/release/libs/range/doc/utility_class.html | 27 ++++-----
   branches/release/libs/range/index.html | 2
   9 files changed, 87 insertions(+), 87 deletions(-)

Modified: branches/release/libs/range/doc/boost_range.html
==============================================================================
--- branches/release/libs/range/doc/boost_range.html (original)
+++ branches/release/libs/range/doc/boost_range.html 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
@@ -152,7 +152,7 @@
     </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><span class=comment>//
+ <span class=comment>//
     // Random Access Range functions
     //
     
@@ -235,7 +235,7 @@
                     <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>
                 <tr>
                     <td><code>Char*</code>
                     <td><code>s</code>
@@ -259,9 +259,9 @@
                     <th>
                         Complexity</th>
                 </tr>
- <tr>
- <a name="range_iterator"></a>
- <td><code>range_iterator&lt;X&gt;::type</code></td>
+
+ <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>
@@ -269,8 +269,8 @@
                     <td>compile time</td>
                 </tr>
                 <tr>
- <a name="range_const_iterator"></a>
- <td><code>range_iterator&lt;const X&gt;::type</code></td>
+
+ <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>
@@ -278,54 +278,53 @@
                     <td>compile time</td>
                 </tr>
                 <tr>
- <a name="range_value"></a>
- <td><code>range_value&lt;X&gt;::type</code></td>
+
+ <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>
- <a name="range_reference"></a>
- <td><code>range_reference&lt;X&gt;::type</code></td>
+
+ <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>
- <a name="range_pointer"></a>
- <td><code>range_pointer&lt;X&gt;::type</code></td>
+
+ <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>
- <a name="range_category"></a>
- <td><code>range_category&lt;X&gt;::type</code></td>
+
+ <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>
- <a name="range_difference"></a>
- <td><code>range_difference&lt;X&gt;::type</code></td>
+
+ <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>
 
                 <tr>
- <a name="range_reverse_iterator"></a>
- <td><code>range_reverse_iterator&lt;X&gt;::type</code></td>
+
+ <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>
- <a name="range_const_reverse_iterator"></a>
- <td><code>range_reverse_iterator&lt;const X&gt;::type</code></td>
+
+ <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>
@@ -346,11 +345,11 @@
                         Complexity</th>
                 </tr>
                 <tr>
- <a name="begin"></a>
- <td><code>begin(x)</code></td>
+
+ <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&ltT&gt;<code><br>
+ <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
@@ -358,11 +357,11 @@
                     <td>constant time</td>
                 </tr>
                 <tr>
- <a name="end"></a>
- <td><code>end(x)</code></td>
+
+ <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&ltT&gt;<code><br>
+ <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>
@@ -373,16 +372,16 @@
                         constant time </td>
                 </tr>
                 <tr>
- <a name="empty"></a>
- <td><code>empty(x)</code></td>
+
+ <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>
- <a name="distance"></a>
- <td><code>distance(x)</code></td>
+
+ <td><a name="distance"></a><code>distance(x)</code></td>
                     <td><code>range_difference&lt;X&gt;::type</code></td>
                     <td>
                         <code>
@@ -394,16 +393,16 @@
                 </tr>
 
                 <tr>
- <a name="size"></a>
- <td><code>size(x)</code></td>
+
+ <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>
- <a name="rbegin"></a>
- <td><code>rbegin(x)</code></td>
+
+ <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>
@@ -411,15 +410,15 @@
                     </td>
                 </tr>
                 <tr>
- <a name="rend"></a>
- <td><code>rend(x)</code></td>
+
+ <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>
- <a name="const_begin"></a>
- <td><code>const_begin(x)</code></td>
+
+ <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>
@@ -427,15 +426,15 @@
                     </td>
                 </tr>
                 <tr>
- <a name="const_end"></a>
- <td><code>const_end(x)</code></td>
+
+ <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>
- <a name="const_rbegin"></a>
- <td><code>const_rbegin(x)</code></td>
+
+ <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>
@@ -443,16 +442,16 @@
                     </td>
                 </tr>
                 <tr>
- <a name="const_rend"></a>
- <td><code>const_rend(x)</code></td>
+
+ <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>
- <a name="as_literal"></a>
- <td><code>as_literal(x)</code></td>
+
+ <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
@@ -460,20 +459,21 @@
                         </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>
+ <!-- <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, constant time
- otherwise</td>
+ <td>linear time for pointers to a string or arrays of
+ <code>Char</code>, constant time otherwise</td>
                 </tr>
                  <tr>
- <a name="as_array"></a>
- <td><code>as_array(x)</code></td>
+
+ <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>
@@ -561,7 +561,7 @@
                         Member type</th>
                     <th>
                         Related concept</th>
- <tr>
+ </tr>
                 <tr>
                     <td><code>iterator</code></td>
                     <td>Single Pass Range</td>

Modified: branches/release/libs/range/doc/examples.html
==============================================================================
--- branches/release/libs/range/doc/examples.html (original)
+++ branches/release/libs/range/doc/examples.html 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
@@ -23,16 +23,16 @@
     <ul >
         <li >
             <a href="../test/string.cpp" target="_self" ><code >string.cpp</code></a>
- </li>
+
         shows how to implement a container version of <code >std::find()</code> that
         works with <code >char[],wchar_t[],char*,wchar_t*.</code>
-
+ </li>
         <li >
             <a href="../test/algorithm_example.cpp" target="_self" ><code >algorithm_example.cpp</code></a>
 
- </li>
+
         shows the replace example from the introduction.
-
+ </li>
         <li> iterator_range.cpp
         <li> sub_range.cpp
         <li> iterator_pair.cpp

Modified: branches/release/libs/range/doc/faq.html
==============================================================================
--- branches/release/libs/range/doc/faq.html (original)
+++ branches/release/libs/range/doc/faq.html 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
@@ -22,7 +22,7 @@
         <li >
             <i>Why is there no difference between <code >range_iterator&lt;C&gt;::type</code>
             and <code >range_const_iterator&lt;C&gt;::type</code> for <code>std::pair&lt;iterator, iterator&gt;</code></i>.
- </li>
+
         <p >
         In general it is not possible nor desirable to find a corresponding <code >const_iterator</code>.
         When it is possible to come up with one, the client might choose to construct a <code >std::pair&lt;const_iterator,const_iterator&gt;</code>
@@ -33,7 +33,7 @@
         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 >

Modified: branches/release/libs/range/doc/headers.html
==============================================================================
--- branches/release/libs/range/doc/headers.html (original)
+++ branches/release/libs/range/doc/headers.html 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
@@ -167,7 +167,7 @@
         </tr>
 
     </table>
- <br
+ <br>
       </p>
 
 

Modified: branches/release/libs/range/doc/intro.html
==============================================================================
--- branches/release/libs/range/doc/intro.html (original)
+++ branches/release/libs/range/doc/intro.html 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
@@ -108,7 +108,7 @@
     </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><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 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>;

Modified: branches/release/libs/range/doc/portability.html
==============================================================================
--- branches/release/libs/range/doc/portability.html (original)
+++ branches/release/libs/range/doc/portability.html 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
@@ -29,9 +29,8 @@
     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>
- <pp>
- 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> 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.

Modified: branches/release/libs/range/doc/range.html
==============================================================================
--- branches/release/libs/range/doc/range.html (original)
+++ branches/release/libs/range/doc/range.html 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
@@ -1,3 +1,4 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <HTML>
 <!--
   -- Copyright (c) Jeremy Siek 2000
@@ -90,7 +91,7 @@
 <code>boost</code></p>-->
 
     <hr>
- <a name="single_pass_range">
+ <a name="single_pass_range"></a>
     <H2>Single Pass Range</H2>
 
     <h3>Notation</h3>
@@ -227,7 +228,7 @@
        
 
     <hr>
- <a name=forward_range><h2>Forward Range</h2>
+ <a name=forward_range></a><h2>Forward Range</h2>
 
     <h3>Notation</h3>
     <Table>
@@ -255,7 +256,7 @@
   
     <hr>
 
- <a name="bidirectional_range"><h2>Bidirectional Range</h2>
+ <a name="bidirectional_range"></a><h2>Bidirectional Range</h2>
 
     <h3>Notation</h3>
     <Table>
@@ -283,7 +284,8 @@
 
     <hr>
 
- <a name=random_access_range><h2>Random Access Range</h2> <h3>Description</h3>
+ <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
@@ -299,10 +301,10 @@
 
     <hr>
 
- <a name=concept_checking><h2>Concept Checking</h2>
+ <a name=concept_checking></a><h2>Concept Checking</h2>
 
     Each of the range concepts has a corresponding concept checking
- class in the file <code><boost/range/concepts.hpp></codE>. These classes may be
+ 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

Modified: branches/release/libs/range/doc/utility_class.html
==============================================================================
--- branches/release/libs/range/doc/utility_class.html (original)
+++ branches/release/libs/range/doc/utility_class.html 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
@@ -31,7 +31,6 @@
         <li>
             Class sub_range
     </ul>
- </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
@@ -84,7 +83,7 @@
         </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><span class=keyword>public</span><span class=special>: </span><span class=comment>// construction, assignment
+ <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>);
                     
@@ -110,7 +109,7 @@
         </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>& ) </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>
@@ -119,7 +118,7 @@
         <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><span class=special>};
+ <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;
@@ -164,7 +163,7 @@
     </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><span class=comment>// external construction
+ <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>,
@@ -190,7 +189,7 @@
                          </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><span class=comment>// convenience
+ <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
@@ -226,9 +225,9 @@
      
 <p>
 <a name="equal"></a>
-<code>bool equal( iterator_range& r ) const;</code>
+<code>bool equal( iterator_range&amp; r ) const;</code>
 <blockquote>
- <i>Returns</i> <code>begin() == r.begin() && end() == r.end();</code>
+ <i>Returns</i> <code>begin() == r.begin() &amp;&amp; end() == r.end();</code>
 </blockquote>
 </p>
 
@@ -236,21 +235,21 @@
 
 <p>
 <a name="comparison"></a>
-<code>bool operator==( const ForwardRange1& l, const ForwardRange2& r );</code>
+<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& l, const ForwardRange2& r );</code>
+<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& l, const ForwardRange2& r );</code>
+<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& r,
+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>
@@ -266,7 +265,7 @@
 </blockquote>
 <p>
 <a name="copy_range"></a>
-<code>Sequence copy_range( const ForwardRange& r );</code>
+<code>Sequence copy_range( const ForwardRange&amp; r );</code>
 <blockquote>
     <i>Returns</i> <code>Sequence( begin(r), end(r) );</code>
 </blockquote>
@@ -292,7 +291,7 @@
     </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><spanclass=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=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>
     

Modified: branches/release/libs/range/index.html
==============================================================================
--- branches/release/libs/range/index.html (original)
+++ branches/release/libs/range/index.html 2008-06-24 11:42:48 EDT (Tue, 24 Jun 2008)
@@ -34,7 +34,7 @@
   </p>
   
   <ul>
- <li> Introduction </code>
+ <li> Introduction
           
       <li>Range concepts:
       <ul>


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