Create a branch for autoprefixing

[SVN r59996]

doc/Jamfile.v2

@@ -28,5 +28,6 @@ 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
   ;
 

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><span class=comment>//
+    <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>
-                    <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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                     <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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                     <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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                         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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                     <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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                         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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                 </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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                     </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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                     </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 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                     </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 @@ 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>
+                       <!-- <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 @@ 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>

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>     

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  >

doc/headers.html

@@ -167,7 +167,7 @@
         </tr>
 
     </table>
-    <br
+    <br>
       </p>
 
 

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><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>;

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="http://www.boost.org/libs/ptr_container/doc/boost.png" /> Range MFC/ATL Extension</h1>
+<h1 class="title"><img alt="Boost" src="../../ptr_container/doc/boost.png" /> Range MFC/ATL Extension</h1>
 <table class="docinfo" frame="void" rules="none">
 <col class="docinfo-name" />
 <col class="docinfo-content" />

doc/portability.html

@@ -29,9 +29,8 @@ 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>
-    <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. 

doc/range.html

@@ -1,3 +1,4 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <HTML>
 <!--
   -- Copyright (c) Jeremy Siek 2000
@@ -90,7 +91,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 name="single_pass_range"></a>
     <H2>Single Pass Range</H2>
 
     <h3>Notation</h3>
@@ -227,7 +228,7 @@ otherwise</TD>
        
 
     <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 @@ Range</a>
   
     <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 @@ s-lib-bidirectional-traversal-iterators">Bidirectional Traversal Iterator.</a>
 
     <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 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator
 
     <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

doc/upgrading.html

@@ -0,0 +1,79 @@
+<!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>
+

doc/utility_class.html

@@ -31,7 +31,6 @@
         <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 
@@ -84,7 +83,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><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 @@ 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>& ) </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 @@ 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><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 @@ 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><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 @@ 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><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 @@ non-const iterators from the same container. </p>
      
 <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 @@ non-const iterators from the same container. </p>
 
 <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 @@ return make_iterator_range( new_begin, new_end );
 </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 @@ 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><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>
     

include/boost/range/as_literal.hpp

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

index.html

@@ -34,7 +34,7 @@
   </p>
   
   <ul>
-      <li> <a href="doc/intro.html">Introduction </a></code>
+      <li> <a href="doc/intro.html">Introduction </a>
           
       <li><a href="doc/range.html">Range concepts:</a>
       <ul>
@@ -55,6 +55,8 @@
           <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>