updated naming convention

[SVN r24518]

doc/boost_range.html

@@ -56,7 +56,7 @@
     the standard container requirements. For example, the utility class <a
       href="utility_class.html#iter_range"><code>iterator_range</code></a> implements 
       the <a href="#minimal_interface">minimal interface</a> required to make the 
-      class a <a href="range.htm#forward_range">Forward Range</a>.
+      class a <a href="range.html#forward_range">Forward Range</a>.
     </p>
 
     <p>
@@ -75,28 +75,28 @@
     //
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#value_type_of"><span 
+    </span><span class=keyword>struct </span><a href="#range_value"><span 
-class=identifier>value_type_of</span></a><span class=special>;
+class=identifier>range_value</span></a><span class=special>;
                  
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#iterator_of"><span 
+    </span><span class=keyword>struct </span><a href="#range_iterator"><span 
-class=identifier>iterator_of</span></a><span class=special>;
+class=identifier>range_iterator</span></a><span class=special>;
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#const_iterator_of"><span 
+    </span><span class=keyword>struct </span><a href="#range_const_iterator"><span 
-class=identifier>const_iterator_of</span></a><span class=special>;
+class=identifier>range_const_iterator</span></a><span class=special>;
     
     </span><span class=comment>//
     // Forward Range metafunctions
     //
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#difference_type_of"><span 
+    </span><span class=keyword>struct </span><a href="#range_difference"><span 
-class=identifier>difference_type_of</span></a><span class=special>;
+class=identifier>range_difference</span></a><span class=special>;
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#size_type_of"><span 
+    </span><span class=keyword>struct </span><a href="#range_size"><span 
-class=identifier>size_type_of</span></a><span class=special>;
+class=identifier>range_size</span></a><span class=special>;
     
     </span><span class=comment>//
     // Bidirectional Range metafunctions
@@ -104,45 +104,45 @@ class=identifier>size_type_of</span></a><span class=special>;
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
     </span><span class=keyword>struct </span><a 
-href="#reverse_iterator_of"><span
+href="#range_reverse_iterator"><span
-class=identifier>reverse_iterator_of</span></a><span class=special>;
+class=identifier>range_reverse_iterator</span></a><span class=special>;
 
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
     </span><span class=keyword>struct </span><a 
-href="#const_reverse_iterator_of"><span
+href="#range_const_reverse_iterator"><span
-class=identifier>const_reverse_iterator_of</span></a><span class=special>;
+class=identifier>range_const_reverse_iterator</span></a><span class=special>;
     
     </span><span class=comment>//
     // Special metafunctions
     //
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>struct </span><a href="#result_iterator_of"><span 
+    </span><span class=keyword>struct </span><a href="#range_result_iterator"><span 
-class=identifier>result_iterator_of</span></a><span class=special>;
+class=identifier>range_result_iterator</span></a><span class=special>;
                  
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
     </span><span class=keyword>struct </span><a 
-href="#reverse_result_iterator_of"><span
+href="#range_reverse_result_iterator"><span
-class=identifier>reverse_result_iterator_of</span></a><span class=special>;
+class=identifier>range_reverse_result_iterator</span></a><span class=special>;
 
     </span><span class=comment>//
     // Single Pass Range functions
     //
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#begin"><span class=identifier>begin</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>const_iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_const_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#begin"><span class=identifier>begin</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
         
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#end"><span class=identifier>end</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
                       
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>const_iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_const_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#end"><span class=identifier>end</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
@@ -154,7 +154,7 @@ class=identifier>reverse_result_iterator_of</span></a><span class=special>;
     //
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>size_type_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_size</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#size"><span class=identifier>size</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
                             
     </span><span class=comment>//
@@ -162,19 +162,19 @@ class=identifier>reverse_result_iterator_of</span></a><span class=special>;
     //
                      
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>reverse_iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#rbegin"><span class=identifier>rbegin</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>const_reverse_iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_const_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#rbegin"><span class=identifier>rbegin</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
         
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>reverse_iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </span><a href="#rend"><span class=identifier>rend</span></a><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>c </span><span class=special>);
                       
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>const_reverse_iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword></span><span class=keyword>typename </span><span class=identifier>range_const_reverse_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type
     </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>c </span><span class=special>);
     </span>
@@ -234,8 +234,8 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
             <th  >Complexity</th>
         </tr>
         <tr  >
-            <a name="value_type_of" ></a>
+            <a name="range_value" ></a>
-            <td  ><code  >value_type_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_value&lt;X&gt;::type</code></td>
             <td  ><code  >T::value_type</code><br>
                 <code  >boost::iterator_value&lt;P::first_type&gt;::type</code><br>
                 <code  >A</code><br>
@@ -243,8 +243,8 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
             <td  >compile time</td>
         </tr>
         <tr  >
-            <a name="iterator_of" ></a>
+            <a name="range_iterator" ></a>
-            <td  ><code  >iterator_of&lt;X&gt;::type</code></td>
+            <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>
@@ -252,8 +252,8 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
             <td  >compile time</td>
         </tr>
         <tr  >
-            <a name="const_iterator_of" ></a>
+            <a name="range_const_iterator" ></a>
-            <td  ><code  >const_iterator_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_const_iterator&lt;X&gt;::type</code></td>
             <td  ><code  >T::const_iterator</code><br>
                 <code  >P::first_type</code><br>
                 <code  >const A*</code><br>
@@ -261,8 +261,8 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
             <td  >compile time</td>
         </tr>
         <tr  >
-            <a name="difference_type_of" ></a>
+            <a name="range_difference" ></a>
-            <td  ><code  >difference_type_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_difference&lt;X&gt;::type</code></td>
             <td  ><code  >T::difference_type</code><br>
                 <code
 >boost_iterator_difference&lt;P::first_type&gt;::type</code><br>
@@ -271,8 +271,8 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
             <td  >compile time</td>
         </tr>
         <tr  >
-            <a name="size_type_of" ></a>
+            <a name="range_size" ></a>
-            <td  ><code  >size_type_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_size&lt;X&gt;::type</code></td>
             <td  ><code  >T::size_type</code><br>
                 <code  >std::size_t</code><br>
                 <code  >std::size_t</code><br>
@@ -280,30 +280,30 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
             <td  >compile time</td>
         </tr>
         <tr  >
-            <a name="result_iterator_of" ></a>
+            <a name="range_result_iterator" ></a>
-            <td  ><code  >result_iterator_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_result_iterator&lt;X&gt;::type</code></td>
-            <td  ><code  >const_iterator_of&lt;X&gt;::type</code> if <code
+            <td  ><code  >range_const_iterator&lt;X&gt;::type</code> if <code
                               >X</code> is <code  >const</code> <br>
-                <code  >iterator_of&lt;X&gt;::type</code> otherwise </td>
+                <code  >range_iterator&lt;X&gt;::type</code> otherwise </td>
             <td  >compile time</td>
         </tr>
         <tr  >
-            <a name="reverse_iterator_of" ></a>
+            <a name="range_reverse_iterator" ></a>
-            <td  ><code  >reverse_iterator_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_reverse_iterator&lt;X&gt;::type</code></td>
-            <td  ><code  >boost::reverse_iterator< typename iterator_of&lt;T>::type ></code><br>
+            <td  ><code  >boost::reverse_iterator< typename range_iterator&lt;T>::type ></code><br>
             <td  >compile time</td>
         </tr>
         <tr  >
-            <a name="const_reverse_iterator_of" ></a>
+            <a name="range_const_reverse_iterator" ></a>
-            <td  ><code  >const_reverse_iterator_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_const_reverse_iterator&lt;X&gt;::type</code></td>
-            <td  ><code  >boost::reverse_iterator< typename const_iterator_of&lt;T>::type ></code>
+            <td  ><code  >boost::reverse_iterator< typename range_const_iterator&lt;T>::type ></code>
                 <br>
             <td  >compile time</td>
         </tr>
         <tr  >
-            <a name="reverse_result_iterator_of" ></a>
+            <a name="range_reverse_result_iterator" ></a>
-            <td  ><code  >reverse_result_iterator_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_reverse_result_iterator&lt;X&gt;::type</code></td>
-            <td  ><code  >boost::reverse_iterator< typename result_iterator_of&lt;T&gt;::type 
+            <td  ><code  >boost::reverse_iterator< typename range_result_iterator&lt;T&gt;::type 
             ></code>
             <td  >compile time</td>
         </tr>
@@ -312,7 +312,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
     </table>
     </p>
     <p>
-    The special metafunctions <code>result_iterator_of</code> and <code>reverse_result_iterator_of</code> 
+    The special metafunctions <code>range_result_iterator</code> and <code>range_reverse_result_iterator</code> 
     are not part of any Range concept, but they are very useful when implementing 
     certain Range classes like <a
       href="utility_class.html#sub_range"><code>sub_range</code></a> because of their 
@@ -331,7 +331,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
         <tr  >
             <a name="begin" ></a>
             <td  ><code  >begin(x)</code></td>
-            <td  ><code  >result_iterator_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_result_iterator&lt;X&gt;::type</code></td>
             <td  ><code  >t.begin()</code><br>
                 <code  >p.first</code><br>
                 <code  >a</code><br>
@@ -341,7 +341,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
         <tr  >
             <a name="end" ></a>
             <td  ><code  >end(x)</code></td>
-            <td  ><code  >result_iterator_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_result_iterator&lt;X&gt;::type</code></td>
             <td  ><code  >t.end()</code><br>
                 <code  >p.second</code><br>
                 <code  >a + sz</code> <br>
@@ -365,7 +365,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
         <tr  >
             <a name="size" ></a>
             <td  ><code  >size(x)</code></td>
-            <td  ><code  >size_type_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_size&lt;X&gt;::type</code></td>
             <td  ><code  >t.size()</code><br>
                 <code>std::distance(p.first,p.second)</code><br>
                 <code  >sz</code><br>
@@ -378,15 +378,15 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
         <tr  >
             <a name="rbegin" ></a>
             <td  ><code  >rbegin(x)</code></td>
-            <td  ><code  >reverse_result_iterator_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_reverse_result_iterator&lt;X&gt;::type</code></td>
-            <td  ><code  >reverse_result_iterator_of&lt;X&gt;::type( end(x) )</code> <br>
+            <td  ><code  >range_reverse_result_iterator&lt;X&gt;::type( end(x) )</code> <br>
             <td  >same as <code>end(x)</code> </td>
         </tr>
         <tr  >
             <a name="rend" ></a>
             <td  ><code  >rend(x)</code></td>
-            <td  ><code  >reverse_result_iterator_of&lt;X&gt;::type</code></td>
+            <td  ><code  >range_reverse_result_iterator&lt;X&gt;::type</code></td>
-            <td  ><code  >reverse_result_iterator_of&lt;X&gt;::type( begin(x) )</code>
+            <td  ><code  >range_reverse_result_iterator&lt;X&gt;::type( begin(x) )</code>
             <td  >same as <code>begin(x)</code></td>
         </tr>
 
@@ -409,15 +409,15 @@ be useable as a certain Range concept.
             <th>Related concept</th>
         <tr>
             <td><code>begin()</code></td>
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a></td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
         </tr>
         <tr>
             <td><code>end()</code> </td>
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a></td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
         </tr>
         <tr>
             <td><code>size()</code></td>
-            <td><a href="range.htm#forward_range">Forward Range</a></td>
+            <td><a href="range.html#forward_range">Forward Range</a></td>
         </tr>
 
     </table>
@@ -437,23 +437,23 @@ be useable as a certain Range concept.
         <tr>
         <tr>
             <td><code>value_type</code></td>
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a></td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
         </tr>
         <tr>
             <td><code>iterator</code></td>
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a></td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
         </tr>
         <tr>
             <td><code>const_iterator</code></td>
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a></td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
         </tr>
         <tr>
             <td><code>difference_type</code></td>
-            <td><a href="range.htm#forward_range">Forward Range</a></td>
+            <td><a href="range.html#forward_range">Forward Range</a></td>
         </tr>
         <tr>
             <td><code>size_type</code></td>
-            <td><a href="range.htm#forward_range">Forward Range</a></td>
+            <td><a href="range.html#forward_range">Forward Range</a></td>
         </tr>
         
     </table>        

doc/faq.html

@@ -20,9 +20,8 @@
     <h2  >FAQ</h2> <a name="FAQ" ></a>
     <ol  >
         <li  >
-            <i>Why is there no difference between <code  >iterator_of&lt;C&gt;::type</code> 
+            <i>Why is there no difference between <code  >range_iterator&lt;C&gt;::type</code> 
-            and <code  >const_iterator_of&lt;C&gt;::type</code> for <code  >std::pair&lt;iterator, 
+            and <code  >range_const_iterator&lt;C&gt;::type</code> for <code>std::pair&lt;iterator, iterator&gt;</code></i>.
-            iterator&gt;</code></i>.
         </li>
         <p  >
         In general it is not possible nor desirable to find a corresponding <code  >const_iterator</code>. 
@@ -83,12 +82,12 @@ is somewhat more convenient than a <code>pair</code>. </p>
     </span><span class=keyword>namespace </span><span class=identifier>range_detail                
     </span><span class=special>{
         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;            
-        </span><span class=keyword>typename </span><span class=identifier>iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;:</span><span class=identifier>type </span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>)
+        </span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;:</span><span class=identifier>type </span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>)
         </span><span class=special>{ </span><span class=comment>/* normal implementation */ </span><span class=special>}
     </span><span class=special>}   
                 
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;                
-    </span><span class=keyword>typename </span><span class=identifier>iterator_of</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>)
+    </span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>)
     </span><span class=special>{
         </span><span class=comment>//        
         // Create ADL hook

doc/headers.html

@@ -41,83 +41,87 @@
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/value_type.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#value_type_of" >value_type_of</a></td>
+            <td  ><a href="boost_range.html#range_value" >range_value</a></td>
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a></td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/iterator.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#iterator_of" >iterator_of</a></td>
+            <td  ><a href="boost_range.html#range_iterator"
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a> </td>
+                                                >range_iterator</a></td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/const_iterator.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#const_iterator_of" >const_iterator_of</a></td>
+            <td  ><a href="boost_range.html#range_const_iterator"
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a> </td>
+                                                >range_const_iterator</a></td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/difference_type.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#difference_type_of" >difference_type_of</a></td>
+            <td  ><a href="boost_range.html#range_difference"
-            <td><a href="range.htm#forward_range">Forward Range</a> </td>
+                                >range_difference</a></td>
+            <td><a href="range.html#forward_range">Forward Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/size_type.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#size_type_of" >size_type_of</a></td>
+            <td  ><a href="boost_range.html#range_size" >range_size</a></td>
-            <td><a href="range.htm#forward_range">Forward Range</a> </td>
+            <td><a href="range.html#forward_range">Forward Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/result_iterator.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#result_iterator_of" >result_iterator_of</a></td>
+            <td  ><a href="boost_range.html#range_result_iterator"
+                >range_result_iterator</a></td>
             <td>- </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/reverse_iterator.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#reverse_iterator_of" >reverse_iterator_of</a></td>
+            <td  ><a href="boost_range.html#range_reverse_iterator" >range_reverse_iterator</a></td>
-            <td><a href="range.htm#bidirectional_range">Bidirectional Range</a> </td>
+            <td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/const_reverse_iterator.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#const_reverse_iterator_of" >const_reverse_iterator_of</a></td>
+            <td  ><a href="boost_range.html#range_const_reverse_iterator" >range_const_reverse_iterator</a></td>
-            <td><a href="range.htm#bidirectional_range">Bidirectional Range</a> </td>
+            <td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/reverse_result_iterator.hpp&gt;</code></td>
-            <td  ><a href="boost_range.html#reverse_result_iterator_of">reverse_result_iterator_of</a></td>
+            <td  ><a href="boost_range.html#range_reverse_result_iterator">range_reverse_result_iterator</a></td>
             <td>- </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/begin.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#begin" >begin</a></td>
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a> </td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/end.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#end" >end</a></td>
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a> </td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/empty.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#empty" >empty</a></td>
-            <td><a href="range.htm#single_pass_range">Single Pass Range</a> </td>
+            <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/size.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#size" >size</a></td>
-            <td><a href="range.htm#forward_range">Forward Range</a> </td>
+            <td><a href="range.html#forward_range">Forward Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/rbegin.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#rbegin" >rbegin</a></td>
-            <td><a href="range.htm#bidirectional_range">Bidirectional Range</a> </td>
+            <td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/rend.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#rend" >rend</a></td>
-            <td><a href="range.htm#bidirectional_range">Bidirectional Range</a> </td>
+            <td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
         </tr>
         <tr  >
             <td  ><code >&lt;boost/range/iterator_range.hpp&gt;</code></td>
             <td  ><a href="utility_class.html#iter_range"
-                                >iterator_range</a></td>
+                                                                                >iterator_range</a></td>
             <td>- </td>
         </tr>
         <tr  >

doc/intro.html

@@ -75,14 +75,15 @@ arrays?) </li>
     // example: extracting bounds in a generic algorithm
     //
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardReadableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>iterator_of</span><span class=special>&lt; </span><span class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_iterator</span><span class=special>&lt; </span><span class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><span class=identifier>type
     </span><span class=identifier>find</span><span class=special>( </span><span class=identifier>ForwardReadableRange</span><span class=special>&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>value </span><span class=special>)
     </span><span class=special>{
        </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>find</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>value </span><span class=special>);
     </span><span class=special>}
     
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardReadableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>const_iterator_of</span><span class=special>&lt; </span><span class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_const_iterator</span><span class=special>&lt; </span><span
+class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><span class=identifier>type
     </span><span class=identifier>find</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardReadableRange</span><span class=special>&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>value </span><span class=special>)
     </span><span class=special>{
        </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>find</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>value </span><span class=special>);
@@ -92,10 +93,10 @@ arrays?) </li>
     // replace first value and return its index
     //
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardReadableWriteableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
-    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>size_type_of</span><span class=special>&lt; </span><span class=identifier>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type
+    </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_size</span><span class=special>&lt; </span><span class=identifier>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type
     </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>ForwardReadableWriteableRange</span><span class=special>&amp; </span><span class=identifier>c</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>value</span><span class=special>, </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>replacement </span><span class=special>)
     </span><span class=special>{
-       </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>iterator_of</span><span class=special>&lt; </span><span class=identifier>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>found </span><span class=special>= </span><span class=identifier>find</span><span class=special>( </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>value </span><span class=special>);
+       </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_iterator</span><span class=special>&lt; </span><span class=identifier>ForwardReadableWriteableRange </span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>found </span><span class=special>= </span><span class=identifier>find</span><span class=special>( </span><span class=identifier>c</span><span class=special>, </span><span class=identifier>value </span><span class=special>);
        
        </span><span class=keyword>if</span><span class=special>( </span><span class=identifier>found </span><span class=special>!= </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c </span><span class=special>) </span><span class=special>)
            </span><span class=special>*</span><span class=identifier>found </span><span class=special>= </span><span class=identifier>replacement</span><span class=special>;
@@ -111,11 +112,9 @@ arrays?) </li>
     </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><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>range_iterator </span><span class=identifier>range_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>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special>&lt;</span><span class=identifier>range_iterator</span><span class=special>,</span><span class=identifier>range_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 
+                                                            </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>);
-class=identifier>boost</span><span
-class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>my_vector </span><span class=special>) </span><span class=special>+ </span><span class=identifier>N </span><span class=special>);
     </span><span class=keyword>char  </span><span class=identifier>str_val</span><span class=special>[] </span><span class=special>= </span><span class=string>&quot;a string&quot;</span><span class=special>;
     </span><span class=keyword>char</span><span class=special>* </span><span class=identifier>str       </span><span class=special>= </span><span class=identifier>str_val</span><span class=special>;
     

doc/range.html

@@ -103,7 +103,7 @@ functions as free-standing functions to allow for a layer of indirection. </p>
     
     <h3>Description</h3>
     <p>
-    A range X where <code>iterator_of&lt;X>::type</code> is a model of <a 
+    A range X where <code>range_iterator&lt;X>::type</code> is a model of <a 
 href="../../iterator/doc/new-iter-concepts.html#single-pass-iterators-lib-single-pass-iterators">
 Single Pass Iterator</a>
 
@@ -115,19 +115,19 @@ Single Pass Iterator</a>
     <table border="1" cellpadding="5">
         <TR>
             <TD VAlign="top">Value type</TD>
-            <TD VAlign="top"><code>value_type_of&lt;X>::type</code></TD>
+            <TD VAlign="top"><code>range_value&lt;X>::type</code></TD>
             <TD VAlign="top">The type of the object stored in a Range.
         </TR>
         <TR>
             <TD VAlign="top">Iterator type</TD>
-            <TD VAlign="top"><code>iterator_of&lt;X>::type</code></TD>
+            <TD VAlign="top"><code>range_iterator&lt;X>::type</code></TD>
             <TD VAlign="top">The type of iterator used to iterate through a Range's elements. 
             The iterator's value type is expected to be the Range's value type.  A 
             conversion from the iterator type to the const iterator type must exist.
         </TR>
         <TR>
             <TD VAlign="top">Const iterator type</TD>
-            <TD VAlign="top"><code>const_iterator_of&lt;X>::type</code></TD>
+            <TD VAlign="top"><code>range_const_iterator&lt;X>::type</code></TD>
             <TD VAlign="top">A type of iterator that may be used to examine, but not to 
             modify, a Range's elements.</TD>
         </TR>
@@ -155,14 +155,14 @@ Single Pass Iterator</a>
         <TR>
             <TD VAlign="top">Beginning of range</TD>
             <TD VAlign="top"><code>begin(a)</code></TD>
-            <TD VAlign="top"><code>iterator_of&lt;X>::type</code> if 
+            <TD VAlign="top"><code>range_iterator&lt;X>::type</code> if 
-<code>a</code> is mutable, <code>const_iterator_of&lt;X>::type</code> 
+<code>a</code> is mutable, <code>range_const_iterator&lt;X>::type</code> 
 otherwise</TD> </TR>
         <TR>
             <TD VAlign="top">End of range</TD>
             <TD VAlign="top"><code>end(a)</code></TD>
-            <TD VAlign="top"><code>iterator_of&lt;X>::type</code> if 
+            <TD VAlign="top"><code>range_iterator&lt;X>::type</code> if 
-<code>a</code> is mutable, <code>const_iterator_of&lt;X>::type</code> 
+<code>a</code> is mutable, <code>range_const_iterator&lt;X>::type</code> 
 otherwise</TD>
         </TR>
         <tr>
@@ -243,7 +243,7 @@ otherwise</TD>
 
     <h3>Description</h3>
     <p>
-    A range <code>X</code> where <code>iterator_of&lt;X>::type</code> is a model 
+    A range <code>X</code> where <code>range_iterator&lt;X>::type</code> is a model 
 of <a 
 href="../../iterator/doc/new-iter-concepts.html#forward-traversal-iterators-lib-forward-traversal-iterators">Forward Traversal Iterator</a>
     </p>
@@ -256,14 +256,14 @@ Range</a>
     <table cellpadding="5" border="1">
         <TR>
             <TD VAlign="top">Distance type</TD>
-            <TD VAlign="top"><code>difference_type_of&lt;X>::type</code></TD>
+            <TD VAlign="top"><code>range_difference&lt;X>::type</code></TD>
             <TD VAlign="top">A signed integral type used to represent the distance between 
             two of the Range's iterators.  This type must be the same as the iterator's 
             distance type.</TD>
         </TR>
         <TR>
             <TD VAlign="top">Size type</TD>
-            <TD VAlign="top"><code>size_type_of&lt;X>::type</code></TD>
+            <TD VAlign="top"><code>range_size&lt;X>::type</code></TD>
             <TD VAlign="top">An unsigned integral type that can represent any nonnegative 
             value of the Range's distance type.</TD>
         </tr>
@@ -280,7 +280,7 @@ Range</a>
         <TR>
             <TD VAlign="top">Size of range</TD>
             <TD VAlign="top"><code>size(a)</code></TD>
-            <TD VAlign="top"><code>size_type</code></TD>
+            <TD VAlign="top"><code>range_size&lt;X>::type</code></TD>
         </TR>
     </table>
 
@@ -331,7 +331,7 @@ of elements. Note <code>size(a) == 0u</code> is equivalent to
 
     <h3>Description</h3> This concept provides access to iterators that traverse in 
     both directions (forward and reverse). The 
-<code>iterator_of&lt;X>::type</code> iterator must meet all of the requirements 
+<code>range_iterator&lt;X>::type</code> iterator must meet all of the requirements 
 of <a
 href="../../iterator/doc/new-iter-concepts.html#bidirectional-traversal-iterator
 s-lib-bidirectional-traversal-iterators">Bidirectional Traversal Iterator.</a>
@@ -343,7 +343,7 @@ s-lib-bidirectional-traversal-iterators">Bidirectional Traversal Iterator.</a>
     <Table border>
         <TR>
             <TD VAlign="top">Reverse Iterator type</TD>
-            <TD VAlign="top"><code>reverse_iterator_of&lt;X>::type</code></TD>
+            <TD VAlign="top"><code>range_reverse_iterator&lt;X>::type</code></TD>
             <TD VAlign="top">The type of iterator used to iterate through a Range's elements 
             in reverse order.  The iterator's value type is expected to be the Range's value 
             type.  A conversion from the reverse iterator type to the const reverse iterator 
@@ -352,7 +352,7 @@ s-lib-bidirectional-traversal-iterators">Bidirectional Traversal Iterator.</a>
         <TR>
             <TD VAlign="top">Const reverse iterator type</TD>
             <TD 
-VAlign="top"><code>const_reverse_iterator_of&ltX>::type</code></TD>
+VAlign="top"><code>range_const_reverse_iterator&ltX>::type</code></TD>
             <TD VAlign="top">A type of reverse iterator that may be used to examine, but not 
             to modify, a Range's elements.</TD>
         </TR>
@@ -371,19 +371,19 @@ VAlign="top"><code>const_reverse_iterator_of&ltX>::type</code></TD>
         <TR>
             <TD VAlign="top">Beginning of range</TD>
             <TD VAlign="top"><code>rbegin(a)</code></TD>
-            <TD VAlign="top"><code>reverse_iterator_of&lt;X>::type</code> if 
+            <TD VAlign="top"><code>range_reverse_iterator&lt;X>::type</code> if 
-<code>a</code> is mutable, <code>const_reverse_iterator_of&lt;X>::type</code> 
+<code>a</code> is mutable, <code>range_const_reverse_iterator&lt;X>::type</code> 
 otherwise.</TD>
             <TD VAlign="top">Equivalent to 
-<code>reverse_iterator_of&lt;X>::type(end(a))</code>.</TD> </TR>
+<code>range_reverse_iterator&lt;X>::type(end(a))</code>.</TD> </TR>
         <TR>
             <TD VAlign="top">End of range</TD>
             <TD VAlign="top"><code>rend(a)</code></TD>
-            <TD VAlign="top"><code>reverse_iterator_of&lt;X>::type</code> if 
+            <TD VAlign="top"><code>range_reverse_iterator&lt;X>::type</code> if 
-<code>a</code> is mutable, <code>const_reverse_iterator_of&lt;X>::type</code> 
+<code>a</code> is mutable, <code>range_const_reverse_iterator&lt;X>::type</code> 
 otherwise.</TD>
             <TD VAlign="top">Equivalent to 
-<code>reverse_iterator_of&lt;X>::type(begin(a))</code>.</TD> </tr>
+<code>range_reverse_iterator&lt;X>::type(begin(a))</code>.</TD> </tr>
 
     </table>
 
@@ -413,7 +413,7 @@ otherwise.</TD>
 
     <a name=random_access_range><h2>Random Access Range</h2> <h3>Description</h3>
     <p>
-    A range <code>X</code> where <code>iterator_of&lt;X>::type</code> is a model 
+    A range <code>X</code> where <code>range_iterator&lt;X>::type</code> is a model 
 of <a
       href="../../iterator/doc/new-iter-concept.html#random-access-traversal-iterators
 -lib-random-access-traversal-iterators">Random Access Traversal Iterator</a>

doc/style.html

@@ -46,14 +46,12 @@
             <i>Traversal</i> category:
             <ul>
                 <li>
-                    <a href="range.htm#single_pass_range">Single Pass Range</a>
+                    <a href="range.html#single_pass_range">Single Pass Range</a>
                 <li>
-                    <a href="range.htm#forward_range">Forward Range</a>
+                    <a href="range.html#forward_range">Forward Range</a>
                 <li>
-                    <a href="range.htm#bidirectional_range">Bidirectional Range</a>
+                    <a href="range.html#bidirectional_range">Bidirectional Range</a> <li>
-                <li>
+                    <a href="range.html#random_access_range">Random Access Range</a> </ul>
-                    <a href="range.htm#random_access_range">Random Access Range</a>
-            </ul>
     </ul>
     Notice how we have used the categories from the <a href=../../iterator/doc/new-iter-concepts.html>new 
     style iterators</a>.

doc/utility_class.html

@@ -35,7 +35,8 @@
 
     The <code>iterator_range</code> class is templated on an <a href="">Forward 
     Traversal Iterator</a> and should be used whenever fairly general code is needed. 
-    The <code>sub_range</code> class is templated on an <a href="range.htm#forward_range">Forward 
+    The <code>sub_range</code> class is templated on an <a 
+href="range.html#forward_range">Forward
     Range</a> and it is less general, but a bit easier to use since its template 
     argument is easier to specify. The biggest difference is, however, that a 
     <code>sub_range</code> can propagate constness because it knows what a 
@@ -52,8 +53,8 @@ corresponding <code>const_iterator</code> is. </p>
     <p>
     The intention of the <code>iterator_range</code> class is to encapsulate two 
     iterators so they fulfill the <a
-      href="range.htm#forward_range">Forward Range</a> concept. A few other functions 
+      href="range.html#forward_range">Forward Range</a> concept. A few other 
-      are also provided for convenience.
+functions are also provided for convenience.
     </p>
     <p>
     If the template argument is not a model of Forward Traversal Iterator, one can 
@@ -209,12 +210,11 @@ class can propagate constness since it knows what a corresponding
 <span class=keyword>namespace </span><span class=identifier>boost</span>
 <span class=special>{
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
-    </span><span class=keyword>class </span><span class=identifier>sub_range </span><span class=special>: </span><span class=keyword>public </span><span class=identifier>iterator_range</span><span class=special>&lt; </span><span class=keyword>typename </span><span class=identifier>result_iterator_of</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=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_result_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>iterator_of</span><span class=special>&lt;</span><span class=identifier>ForwardRange</span><span 
+        <span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>range_result_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>
-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_const_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>const_iterator</span><span class=special>;</span>
-        <span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>const_iterator_of</span><span class=special>&lt;</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>public</span><span class=special>: </span><span class=comment>// construction, assignment
         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator </span><span class=special>&gt;