Branch at revision 46530

[SVN r46531]
new jamfile to see warnings better
2025-06-27 04:51:44 +02:00 · 2008-06-19 18:57:10 +00:00 · 2008-06-12 12:00:57 +00:00 · 2008-06-12 10:54:44 +00:00 · 2008-06-12 10:00:54 +00:00 · 2008-05-11 13:49:20 +00:00
13 changed files with 90 additions and 171 deletions
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -28,6 +28,5 @@ boostbook standalone
 #    <xsl:param>generate.section.toc.level=4
 #    <xsl:param>chunk.first.sections=7
 #    <xsl:param>toc.section.depth=10
-     <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
  ;

--- a/doc/boost_range.html
+++ b/doc/boost_range.html
@ -152,7 +152,7 @@ class=identifier>range_reverse_iterator</span></a><span class=special>;
    </span><a href="#rend"><span class=identifier>rend</span></a><span class=special>( </span><span class=keyword>const </span><span 
 class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
    </span>
-    <span class=comment>//
+    </span><span class=comment>//
    // Random Access Range functions
    //
    
@ -235,7 +235,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    <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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    <th>
                        Complexity</th>
                </tr>
-                
-                <tr >
-                    <td><a name="range_iterator"></a><code>range_iterator&lt;X&gt;::type</code></td>
+                <tr>
+                    <a name="range_iterator"></a>
+                    <td><code>range_iterator&lt;X&gt;::type</code></td>
                    <td><code>T::iterator</code><br>
                        <code>P::first_type</code><br>
                        <code>A*</code><br>
@ -269,8 +269,8 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    <td>compile time</td>
                </tr>
                <tr>
-                    
-                    <td><a name="range_const_iterator"></a><code>range_iterator&lt;const X&gt;::type</code></td>
+                    <a name="range_const_iterator"></a>
+                    <td><code>range_iterator&lt;const X&gt;::type</code></td>
                    <td><code>T::const_iterator</code><br>
                        <code>P::first_type</code><br>
                        <code>const A*</code><br>
@ -278,53 +278,54 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    <td>compile time</td>
                </tr>
                <tr>
-                    
-                    <td><a name="range_value"></a><code>range_value&lt;X&gt;::type</code></td>
+                    <a name="range_value"></a>
+                    <td><code>range_value&lt;X&gt;::type</code></td>
                    <td><code>boost::iterator_value&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
                     </td>  
                    <td>compile time</td>
                </tr>
                <tr>
-                    
-                    <td><a name="range_reference"></a><code>range_reference&lt;X&gt;::type</code></td>
+                    <a name="range_reference"></a>
+                    <td><code>range_reference&lt;X&gt;::type</code></td>
                    <td><code>boost::iterator_reference&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
                     </td>  
                    <td>compile time</td>
                </tr>

                                <tr>
-                    
-                    <td><a name="range_pointer"></a><code>range_pointer&lt;X&gt;::type</code></td>
+                    <a name="range_pointer"></a>
+                    <td><code>range_pointer&lt;X&gt;::type</code></td>
                    <td><code>boost::iterator_pointer&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
                     </td>  
                    <td>compile time</td>
                </tr>
                
                                <tr>
-                    
-                    <td><a name="range_category"></a><code>range_category&lt;X&gt;::type</code></td>
+                    <a name="range_category"></a>
+                    <td><code>range_category&lt;X&gt;::type</code></td>
                    <td><code>boost::iterator_category&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
                     </td>  
                    <td>compile time</td>
                </tr>
                <tr>
-                    
-                    <td><a name="range_difference"></a><code>range_difference&lt;X&gt;::type</code></td>
+                    <a name="range_difference"></a>
+                    <td><code>range_difference&lt;X&gt;::type</code></td>
                    <td>
                        <code>boost::iterator_difference&lt;range_iterator&lt;X&gt;::type&gt;::type</code></td>
                        
                    <td>compile time</td>
                </tr>
+                </tr>

                <tr>
-                    
-                    <td><a name="range_reverse_iterator"></a><code>range_reverse_iterator&lt;X&gt;::type</code></td>
+                    <a name="range_reverse_iterator"></a>
+                    <td><code>range_reverse_iterator&lt;X&gt;::type</code></td>
                    <td><code>boost::reverse_iterator&lt;range_iterator&lt;X&gt;::type&gt;</code><br>
                    <td>compile time</td>
                </tr>
                <tr>
-                    
-                    <td><a name="range_const_reverse_iterator"></a><code>range_reverse_iterator&lt;const X&gt;::type</code></td>
+                    <a name="range_const_reverse_iterator"></a>
+                    <td><code>range_reverse_iterator&lt;const X&gt;::type</code></td>
                    <td><code>boost::reverse_iterator&lt;range_iterator&lt;const X&gt;::type&gt;</code>
                        <br>
                    <td>compile time</td>
@ -345,11 +346,11 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                        Complexity</th>
                </tr>
                <tr>
-                    
-                    <td><a name="begin"></a><code>begin(x)</code></td>
+                    <a name="begin"></a>
+                    <td><code>begin(x)</code></td>
                    <td><code>range_iterator&lt;X&gt;::type</code></td>
                    <td>
-                        <code>p.first</code> if <code>p</code> is of type <code>std::pair&lt;T&gt;<code><br>
+                        <code>p.first</code> if <code>p</code> is of type <code>std::pair&ltT&gt;<code><br>
                        <code>a</code> if <code>a</code> is an array <br>
                        <code>range_begin(x)</code> if that expression would invoke a function found by ADL <br>
                        <code>t.begin()</code> otherwise
@ -357,11 +358,11 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    <td>constant time</td>
                </tr>
                <tr>
-                    
-                    <td><a name="end"></a><code>end(x)</code></td>
+                    <a name="end"></a>
+                    <td><code>end(x)</code></td>
                    <td><code>range_iterator&lt;X&gt;::type</code></td>
                    <td>
-                        <code>p.second</code> if <code>p</code> is of type <code>std::pair&lt;T&gt;<code><br>
+                        <code>p.second</code> if <code>p</code> is of type <code>std::pair&ltT&gt;<code><br>
                        <code>a + sz</code> if <code>a</code> is an array of size <code>sz</code>
                        
                        <br>
@ -372,16 +373,16 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                        constant time </td>
                </tr>
                <tr>
-                    
-                    <td><a name="empty"></a><code>empty(x)</code></td>
+                    <a name="empty"></a>
+                    <td><code>empty(x)</code></td>
                    <td><code>bool</code></td>
                    <td><code>boost::begin(x) == boost::end(x)</code><br>
                    <td> constant time <br>
                    </td>
                </tr>
                <tr>
-                    
-                    <td><a name="distance"></a><code>distance(x)</code></td>
+                    <a name="distance"></a>
+                    <td><code>distance(x)</code></td>
                    <td><code>range_difference&lt;X&gt;::type</code></td>
                    <td>
                        <code>
@ -393,16 +394,16 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                </tr>

                <tr>
-                    
-                    <td><a name="size"></a><code>size(x)</code></td>
+                    <a name="size"></a>
+                    <td><code>size(x)</code></td>
                    <td><code>range_difference&lt;X&gt;::type</code></td>
                    <td><code> boost::end(x) - boost::begin(x)</code>
                        
                    <td>          constant time </td>
                </tr>
                <tr>
-                    
-                    <td><a name="rbegin"></a><code>rbegin(x)</code></td>
+                    <a name="rbegin"></a>
+                    <td><code>rbegin(x)</code></td>
                    <td><code>range_reverse_iterator&lt;X&gt;::type</code></td>
                    <td><code>range_reverse_iterator&lt;X&gt;::type( boost::end(x) )</code>
                        <br>
@ -410,15 +411,15 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    </td>
                </tr>
                <tr>
-                   
-                    <td> <a name="rend"></a><code>rend(x)</code></td>
+                    <a name="rend"></a>
+                    <td><code>rend(x)</code></td>
                    <td><code>range_reverse_iterator&lt;X&gt;::type</code></td>
                    <td><code>range_reverse_iterator&lt;X&gt;::type( boost::begin(x) )</code>
                    <td>constant time</td>
                </tr>
                <tr>
-                    
-                    <td><a name="const_begin"></a><code>const_begin(x)</code></td>
+                    <a name="const_begin"></a>
+                    <td><code>const_begin(x)</code></td>
                    <td><code>range_iterator&lt;const X&gt;::type</code></td>
                    <td><code>range_iterator&lt;const X&gt;::type( boost::begin(x) )</code>
                        <br>
@ -426,15 +427,15 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    </td>
                </tr>
                <tr>
-                    
-                    <td><a name="const_end"></a><code>const_end(x)</code></td>
+                    <a name="const_end"></a>
+                    <td><code>const_end(x)</code></td>
                    <td><code>range_iterator&lt;const X&gt;::type</code></td>
                    <td><code>range_iterator&lt;const X&gt;::type( boost::end(x) )</code>
                    <td>constant time</td>
                </tr>
                <tr>
-                    
-                    <td><a name="const_rbegin"></a><code>const_rbegin(x)</code></td>
+                    <a name="const_rbegin"></a>
+                    <td><code>const_rbegin(x)</code></td>
                    <td><code>range_reverse_iterator&lt;const X&gt;::type</code></td>
                    <td><code>range_reverse_iterator&lt;const X&gt;::type( boost::rbegin(x) )</code>
                        <br>
@ -442,16 +443,16 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    </td>
                </tr>
                <tr>
-                    
-                    <td><a name="const_rend"></a><code>const_rend(x)</code></td>
+                    <a name="const_rend"></a>
+                    <td><code>const_rend(x)</code></td>
                    <td><code>range_reverse_iterator&lt;const X&gt;::type</code></td>
                    <td><code>range_reverse_iterator&lt;const X&gt;::type( boost::rend(x) )</code>                    
        
                    <td>constant time</td>
                </tr>
                 <tr>
-                    
-                    <td><a name="as_literal"></a><code>as_literal(x)</code></td>
+                    <a name="as_literal"></a>
+                    <td><code>as_literal(x)</code></td>
                     <td><code>iterator_range&lt;U></code> where <code>U</code> is 
                        <code>Char*</code> if <code>x</code> is a pointer to a 
                        string and <code>U</code> is
@ -459,21 +460,20 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                        </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>
+                        <code>[a,a+sz-1)</code> if <code>a</code> is an array of size <code>sz</code><br>
+                            <code>[s,s + std::char_traits&lt;X&gt;::length(s))</code> if <code>s</code> is a <code>Char*</code>
                                <br>
                                    <code>[boost::begin(x),boost::end(x))</code> otherwise


                         
                         </td>   
-                    <td>linear time for pointers to a string or arrays of 
-                        <code>Char</code>, constant time otherwise</td>
+                    <td>linear time for pointers to a string, constant time 
+                        otherwise</td>
                </tr>
                 <tr>
-                    
-                    <td><a name="as_array"></a><code>as_array(x)</code></td>
+                    <a name="as_array"></a>
+                    <td><code>as_array(x)</code></td>
                     <td><code>iterator_range&lt;X></code>                       </td>
                     <td>
                                  <code>[boost::begin(x),boost::end(x))</code> 
@ -561,7 +561,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                        Member type</th>
                    <th>
                        Related concept</th>
-                </tr>
+                <tr>
                <tr>
                    <td><code>iterator</code></td>
                    <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
--- a/doc/examples.html
+++ b/doc/examples.html
@ -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> <a href="../test/iterator_range.cpp">iterator_range.cpp</a>
        <li> <a href="../test/sub_range.cpp">sub_range.cpp</a>
        <li> <a href="../test/iterator_pair.cpp">iterator_pair.cpp</a>     
--- a/doc/faq.html
+++ b/doc/faq.html
@ -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  >
--- a/doc/headers.html
+++ b/doc/headers.html
@ -167,7 +167,7 @@
        </tr>

    </table>
-    <br>
+    <br
      </p>


--- a/doc/intro.html
+++ b/doc/intro.html
@ -108,7 +108,7 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
    </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=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>;
--- a/doc/mfc_atl.html
+++ b/doc/mfc_atl.html
@ -291,7 +291,7 @@ ul.auto-toc {
 </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>
+<h1 class="title"><img alt="Boost" src="http://www.boost.org/libs/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" />
--- a/doc/portability.html
+++ b/doc/portability.html
@ -29,8 +29,9 @@ href="http://boost.sourceforge.net/regression-logs/developer/range.html">here</a
    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.
+    <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>
    <p  >
    Notice also that some compilers cannot do function template ordering properly. 
--- a/doc/range.html
+++ b/doc/range.html
@ -1,4 +1,3 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <HTML>
 <!--
  -- Copyright (c) Jeremy Siek 2000
@ -91,7 +90,7 @@ functions as free-standing functions to allow for a layer of indirection. </p>
 <code>boost</code></p>-->

    <hr>
-    <a name="single_pass_range"></a>
+    <a name="single_pass_range">
    <H2>Single Pass Range</H2>

    <h3>Notation</h3>
@ -228,7 +227,7 @@ otherwise</TD>
       

    <hr>
-    <a name=forward_range></a><h2>Forward Range</h2>
+    <a  name=forward_range><h2>Forward Range</h2>

    <h3>Notation</h3>
    <Table>
@ -256,7 +255,7 @@ Range</a>
  
    <hr>

-    <a name="bidirectional_range"></a><h2>Bidirectional Range</h2>
+    <a name="bidirectional_range"><h2>Bidirectional Range</h2>

    <h3>Notation</h3>
    <Table>
@ -284,8 +283,7 @@ s-lib-bidirectional-traversal-iterators">Bidirectional Traversal Iterator.</a>

    <hr>

-    <a name=random_access_range></a><h2>Random Access Range</h2> 
-    <h3>Description</h3>
+    <a name=random_access_range><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
@ -301,10 +299,10 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator

    <hr>

-    <a name=concept_checking></a><h2>Concept Checking</h2>
+    <a name=concept_checking><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
+    class in the file <code><boost/range/concepts.hpp></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
--- a/doc/upgrading.html
+++ b/doc/upgrading.html
@ -1,78 +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>
-
--- a/doc/utility_class.html
+++ b/doc/utility_class.html
@ -31,6 +31,7 @@
        <li>
            Class <a href="#sub_range"><code>sub_range</code></a>
    </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 
@ -83,7 +84,7 @@ corresponding <code>const_iterator</code> is. </p>
        </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>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>);
                    
@ -109,7 +110,7 @@ corresponding <code>const_iterator</code> is. </p>
        </span><span class=keyword>operator        </span><a href="#unspecified_bool"><span class=identifier>unspecified_bool_type</span></a><span class=special>() </span><span class=keyword>const</span><span class=special>;
    </span>    <span class=keyword>bool</span>            <span 
 class=identifier><a href="#equal">equal</a></span><span
-class=special>( </span><span class=keyword>const</span> <span class=identifier>iterator_range</span><span class=special>&amp; ) </span><span 
+class=special>( </span><span class=keyword>const</span> <span class=identifier>iterator_range</span><span class=special>& ) </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>
@ -118,7 +119,7 @@ class=keyword>const;</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=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;
@ -163,7 +164,7 @@ class=keyword>const;</span>
    </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=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>, 
@ -189,7 +190,7 @@ class=keyword>const;</span>
                         </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=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 
@ -225,9 +226,9 @@ non-const iterators from the same container. </p>
     
 <p>
 <a name="equal"></a>      
-<code>bool equal( iterator_range&amp; r ) const;</code>
+<code>bool equal( iterator_range& r ) const;</code>
 <blockquote>
-    <i>Returns</i> <code>begin() == r.begin() &amp;&amp; end() == r.end();</code>
+    <i>Returns</i> <code>begin() == r.begin() && end() == r.end();</code>
 </blockquote>
 </p>      

@ -235,21 +236,21 @@ non-const iterators from the same container. </p>

 <p> 
 <a name="comparison"></a>
-<code>bool operator==( const ForwardRange1&amp; l, const ForwardRange2&amp; r );</code>
+<code>bool operator==( const ForwardRange1& l, const ForwardRange2& 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>
+<code>bool operator!=( const ForwardRange1& l, const ForwardRange2& r );</code>
 <blockquote>
    <i>Returns</i> <code>!( l == r );</code>
 </blockquote>
-<code>bool operator<( const ForwardRange1&amp; l, const ForwardRange2&amp; r );</code>
+<code>bool operator<( const ForwardRange1& l, const ForwardRange2& 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, 
+iterator_range make_iterator_range( Range& r, 
                                    typename range_difference&lt;Range>::type advance_begin, 
                                    typename range_difference&lt;Range>::type advance_end );
 </pre>
@ -265,7 +266,7 @@ return make_iterator_range( new_begin, new_end );
 </blockquote>
 <p> 
 <a name="copy_range"></a> 
-<code>Sequence copy_range( const ForwardRange&amp; r );</code>
+<code>Sequence copy_range( const ForwardRange& r );</code>
 <blockquote>
    <i>Returns</i> <code>Sequence( begin(r), end(r) );</code>
 </blockquote>
@ -291,7 +292,7 @@ class can propagate constness since it knows what a corresponding
    </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=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=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>
    
--- a/include/boost/range/as_literal.hpp
+++ b/include/boost/range/as_literal.hpp
@ -38,7 +38,7 @@ namespace boost
            return strlen( s );
        }

-#ifndef BOOST_NO_CWCHAR  
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T 
        inline std::size_t length( const wchar_t* s )
        {
            return wcslen( s );
@ -61,7 +61,7 @@ namespace boost
            return true;
        }

-#ifndef BOOST_NO_CWCHAR  
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T 
        inline bool is_char_ptr( wchar_t* )
        {
            return true;
--- a/index.html
+++ b/index.html
@ -34,7 +34,7 @@
  </p>
  
  <ul>
-      <li> <a href="doc/intro.html">Introduction </a>
+      <li> <a href="doc/intro.html">Introduction </a></code>
          
      <li><a href="doc/range.html">Range concepts:</a>
      <ul>
@ -55,8 +55,6 @@
          <li><a href="doc/mfc_atl.html">MFC/ATL mapping (courtesy of Shunsuke
              Sogame)</a></li>  
      <li><a href="doc/portability.html">Portability</a>
-          <li><a href="doc/upgrading.html">Upgrading from Boost v. 
-              1.34.*</a></li>
      <li><a href="doc/faq.html">FAQ</a>    
      <li><a href="doc/history_ack.html">History and acknowledgment</a>
Author	SHA1	Message	Date
Beman Dawes	a4c9c3eb65	Branch at revision 46530 [SVN r46531]	2008-06-19 18:57:10 +00:00
Thorsten Jørgen Ottosen	15a697f86b	new jamfile to see warnings better [SVN r46348]	2008-06-12 12:00:57 +00:00
Thorsten Jørgen Ottosen	dbef3564c4	fixes from Trac [SVN r46346]	2008-06-12 10:54:44 +00:00
Thorsten Jørgen Ottosen	b948d9af17	fixes for problems from Trac [SVN r46345]	2008-06-12 10:00:54 +00:00
Daniel James	95d424012b	Quote href values - our tools don't support unquoted values. [SVN r45283]	2008-05-11 13:49:20 +00:00
Thorsten Jørgen Ottosen	36a99eb0a0	test of updated as_literal() [SVN r45124]	2008-05-05 06:42:30 +00:00
Thorsten Jørgen Ottosen	f117011b60	fix for as_literal() [SVN r45123]	2008-05-05 06:41:54 +00:00
Thorsten Jørgen Ottosen	7c0d73b8cf	fixed problem with operator()() when the value_type was abstract. [SVN r43322]	2008-02-19 15:10:05 +00:00
Eric Niebler	405ebd8cca	include config.hpp and workaround.hpp before uses of BOOST_WORKAROUND and BOOST_MSVC [SVN r43220]	2008-02-11 03:48:41 +00:00
Thorsten Jørgen Ottosen	94b45ef51e	missing ) fixed [SVN r43175]	2008-02-08 15:25:01 +00:00
Thorsten Jørgen Ottosen	e115ac1006	silence of warnings for unused arguments [SVN r43171]	2008-02-08 09:58:35 +00:00
Thorsten Jørgen Ottosen	8b712359a2	test [SVN r43156]	2008-02-07 14:46:19 +00:00
Thorsten Jørgen Ottosen	428e72ed22	iterator_range disables msvc warning 4996 <http://svn.boost.org/trac/boost/ticket/1565> [range] sub_range assignment issue <http://svn.boost.org/trac/boost/ticket/1284> [SVN r43155]	2008-02-07 14:41:04 +00:00
Thorsten Jørgen Ottosen	73db2a05b6	cleanup to pass inspection tool [SVN r43135]	2008-02-06 23:12:21 +00:00
Thorsten Jørgen Ottosen	507d1e8075	fixed #if to #ifdef [SVN r42715]	2008-01-13 11:37:41 +00:00
Thorsten Jørgen Ottosen	d31787daae	doc fixes [SVN r42693]	2008-01-12 12:38:57 +00:00
Thorsten Jørgen Ottosen	14a9a1906b	Ticket #1477 [SVN r41638]	2007-12-03 09:08:02 +00:00
Thorsten Jørgen Ottosen	f65c137e73	missing include [SVN r41636]	2007-12-03 09:00:23 +00:00
Thorsten Jørgen Ottosen	8085605217	fixed a serious oversigt [SVN r41457]	2007-11-29 09:19:24 +00:00
Thorsten Jørgen Ottosen	0eb365edbe	macro patch [SVN r41183]	2007-11-17 21:24:16 +00:00
Thorsten Jørgen Ottosen	2e0d7eab4a	removed some warnings [SVN r41181]	2007-11-17 21:21:53 +00:00
Thorsten Jørgen Ottosen	637dc618d1	iostream macro patch [SVN r41180]	2007-11-17 21:19:13 +00:00
Thorsten Jørgen Ottosen	dd1459f221	works after local test with vc8 [SVN r41177]	2007-11-17 20:44:29 +00:00
Thorsten Jørgen Ottosen	ba96d075b2	last updates [SVN r41176]	2007-11-17 20:22:20 +00:00
Thorsten Jørgen Ottosen	a2f3a45214	minor update of comments [SVN r41175]	2007-11-17 20:22:05 +00:00
Thorsten Jørgen Ottosen	6ac0cfe09c	improved reference [SVN r40968]	2007-11-09 15:15:28 +00:00
Thorsten Jørgen Ottosen	7b3857a9a8	minor tweaks to avoid warnings ... extension mechanism updated to follow new protocol [SVN r40966]	2007-11-09 13:31:43 +00:00
Thorsten Jørgen Ottosen	2605b9ee45	update of new concepts, and replacement of range_size<T>::type with range_difference<T>::type throughut the library [SVN r40965]	2007-11-09 13:30:57 +00:00
Thorsten Jørgen Ottosen	1509d5603b	minor editorial issue [SVN r40964]	2007-11-09 13:13:06 +00:00
Thorsten Jørgen Ottosen	93deddde63	major update wrt. new range concepts [SVN r40962]	2007-11-09 10:27:42 +00:00
Thorsten Jørgen Ottosen	68a63cab85	added deprecated headers again for backward compatibility sake [SVN r40629]	2007-10-31 21:48:11 +00:00
Thorsten Jørgen Ottosen	06c54ccd48	current version gave problem in regression ... to be updated later [SVN r40612]	2007-10-30 19:47:40 +00:00
Thorsten Jørgen Ottosen	2e298b5e60	adds test for inclusion of concept header [SVN r40521]	2007-10-28 10:11:54 +00:00
Thorsten Jørgen Ottosen	00e70244a5	fixes broken one from trunk ... still not finished [SVN r40520]	2007-10-28 10:11:10 +00:00
Thorsten Jørgen Ottosen	3f98d69c94	added mfc/atl link [SVN r40514]	2007-10-27 22:00:47 +00:00
Thorsten Jørgen Ottosen	4767db522b	first update ... more to come [SVN r40508]	2007-10-27 15:58:22 +00:00
Thorsten Jørgen Ottosen	f6e555dda3	updated example to new syntax [SVN r40507]	2007-10-27 15:57:56 +00:00
Thorsten Jørgen Ottosen	01826978d6	cleaned up deprecated headers [SVN r40506]	2007-10-27 15:57:20 +00:00
Thorsten Jørgen Ottosen	336c12b60f	removed deprecated mfc stuff [SVN r40425]	2007-10-24 15:53:54 +00:00
Thorsten Jørgen Ottosen	82768af3d2	roll-back of ADL names [SVN r40423]	2007-10-24 15:19:16 +00:00
Thorsten Jørgen Ottosen	8984de1c74	roll back of ADL names [SVN r40422]	2007-10-24 15:18:22 +00:00
Thorsten Jørgen Ottosen	4db083cd6d	Shunsuke Sogame's MFC/ATL docs and tests [SVN r40381]	2007-10-23 20:28:52 +00:00
Thorsten Jørgen Ottosen	f4cde208f2	Adding Shunsuke Sogame fantastic MFC/ATL mappings [SVN r40379]	2007-10-23 20:23:05 +00:00
Thorsten Jørgen Ottosen	d130dff5ec	cleanup [SVN r40378]	2007-10-23 20:08:35 +00:00
Thorsten Jørgen Ottosen	aa9158b199	applied Ticket #1309 (new Patches) [SVN r40377]	2007-10-23 19:56:39 +00:00
Thorsten Jørgen Ottosen	bbd9fdb7bd	displabed some warnings and applied Ticket #1284 : sub_range_copy.patch [SVN r40376]	2007-10-23 19:50:59 +00:00
Thorsten Jørgen Ottosen	17514e1d44	added operator() to allow random access index with transform iterators [SVN r40375]	2007-10-23 19:34:38 +00:00
Thorsten Jørgen Ottosen	d759c23552	added test for operator() [SVN r40374]	2007-10-23 19:34:06 +00:00
Thorsten Jørgen Ottosen	cf9ad808a6	new fancy quickbook documentaion [SVN r40373]	2007-10-23 19:12:19 +00:00
Thorsten Jørgen Ottosen	028bff0c22	changed ADL functions back the names of 1.34 ... these names have been in use for too long ... let's not break code that depends on them [SVN r40372]	2007-10-23 19:07:38 +00:00
Thorsten Jørgen Ottosen	33a8016af3	change names of ADL functions back to 1.34 names ... the old names have been in use for too long so let's not break code that depends on them [SVN r40371]	2007-10-23 19:06:39 +00:00
Thorsten Jørgen Ottosen	24466ae189	applied patch from Ticket #1302 (new Patches) to handle char arrays correctly [SVN r40370]	2007-10-23 18:59:11 +00:00
Thorsten Jørgen Ottosen	c8ffe55ae5	added test for char array with nested null in response to Ticket #471 [SVN r40367]	2007-10-23 18:36:03 +00:00
Nicola Musatti	a862a573df	Applied patch from Ticket #1320 [SVN r40020]	2007-10-14 17:53:15 +00:00
Markus Schöpflin	0b0dfc0e06	Added missing boost namespace reference to as_literal. [SVN r39683]	2007-10-04 11:51:51 +00:00
Caleb Epstein	e0a76af0f9	Quiet unused argument warnings from gcc. [SVN r39274]	2007-09-14 17:18:02 +00:00
Vladimir Prus	51650f1aa2	Remove V1 Jamfiles [SVN r38516]	2007-08-08 19:02:26 +00:00
Thorsten Jørgen Ottosen	aeb47120e3	fixed typo [SVN r36684]	2007-01-10 18:57:20 +00:00
Thorsten Jørgen Ottosen	22b7b4ec8e	commented out old array code [SVN r36683]	2007-01-10 18:50:13 +00:00
Vladimir Prus	a933622ae1	Allow building of shared versions of some Boost.Test libraries. Adjust tests to use always use static linking to Boost.Test, since linking to the shared version requires test changes. Patch from Juergen Hunold. [SVN r35989]	2006-11-10 19:09:56 +00:00
Thorsten Jørgen Ottosen	f49be0b382	* empty log message * [SVN r35717]	2006-10-24 10:37:46 +00:00
Daniel James	007117cefb	Merge in recent fixes for inspect errors. [SVN r34973]	2006-08-27 10:40:36 +00:00
Thorsten Jørgen Ottosen	73bb3d899a	* empty log message * [SVN r34034]	2006-05-19 18:01:02 +00:00
Thorsten Jørgen Ottosen	4a8987865e	dos2unix on some files [SVN r34025]	2006-05-19 10:30:02 +00:00
Thorsten Jørgen Ottosen	f885495565	* empty log message * [SVN r34015]	2006-05-18 21:27:29 +00:00
Thorsten Jørgen Ottosen	dc34cd6079	* empty log message * [SVN r34014]	2006-05-18 21:11:55 +00:00
Thorsten Jørgen Ottosen	5850d7ce3e	new traits and functions for v2 [SVN r34013]	2006-05-18 20:53:21 +00:00
Thorsten Jørgen Ottosen	554f832234	upgrade to v2 [SVN r34012]	2006-05-18 20:52:17 +00:00
Thorsten Jørgen Ottosen	dc96b440be	v2 upgrade [SVN r34011]	2006-05-18 19:17:04 +00:00