Merged revisions 40922-40969 via svnmerge from

https://svn.boost.org/svn/boost/trunk ........ r40923 | eric_niebler | 2007-11-07 22:48:08 -0800 (Wed, 07 Nov 2007) | 1 line fix errors and warnings on msvc-9 ........ r40924 | chris_kohlhoff | 2007-11-07 23:52:49 -0800 (Wed, 07 Nov 2007) | 2 lines Fix timer stalls. ........ r40925 | johnmaddock | 2007-11-08 01:38:22 -0800 (Thu, 08 Nov 2007) | 1 line Fixed license text. ........ r40926 | bemandawes | 2007-11-08 04:35:50 -0800 (Thu, 08 Nov 2007) | 1 line Borland appends newline, so just check text ........ r40927 | johnmaddock | 2007-11-08 04:39:58 -0800 (Thu, 08 Nov 2007) | 1 line Removed non-BSL files, updated and regenerated docs accordingly. ........ r40928 | bemandawes | 2007-11-08 05:01:23 -0800 (Thu, 08 Nov 2007) | 1 line Markup older Borland compilers that don't support enable_if ........ r40932 | bemandawes | 2007-11-08 06:25:09 -0800 (Thu, 08 Nov 2007) | 1 line Clarify comment ........ r40934 | joaquin | 2007-11-08 07:46:57 -0800 (Thu, 08 Nov 2007) | 1 line removed markup for a fixed failure of multi_index on vacpp ........ r40935 | nikiml | 2007-11-08 08:28:44 -0800 (Thu, 08 Nov 2007) | 1 line changed handle cast to downcast ........ r40936 | hljin | 2007-11-08 09:31:56 -0800 (Thu, 08 Nov 2007) | 1 line GIL: added missing standard C++ header files ........ r40937 | hljin | 2007-11-08 09:35:37 -0800 (Thu, 08 Nov 2007) | 1 line GIL: added namespace prefix to avoid confusion ........ r40938 | danieljames | 2007-11-08 10:04:12 -0800 (Thu, 08 Nov 2007) | 3 lines Remove the <small> from the copyright footer, because it was causing the markup to be invalid. ........ r40939 | johnmaddock | 2007-11-08 10:05:28 -0800 (Thu, 08 Nov 2007) | 1 line Applied fix from http://svn.boost.org/trac/boost/ticket/1023. ........ r40956 | vladimir_prus | 2007-11-09 00:26:47 -0800 (Fri, 09 Nov 2007) | 1 line Don't use toolset.register ........ r40957 | vladimir_prus | 2007-11-09 00:30:27 -0800 (Fri, 09 Nov 2007) | 2 lines Remove toolset.register. ........ r40958 | speedsnail | 2007-11-09 00:31:45 -0800 (Fri, 09 Nov 2007) | 2 lines Force static linking for toolsets mingw and boorland. ........ r40959 | speedsnail | 2007-11-09 01:28:29 -0800 (Fri, 09 Nov 2007) | 1 line Reverted the previous commit, until I find a better solution... ........ r40960 | johnmaddock | 2007-11-09 01:54:43 -0800 (Fri, 09 Nov 2007) | 1 line Still trying to get the Solaris error rates correct.... ........ r40961 | johnmaddock | 2007-11-09 01:59:37 -0800 (Fri, 09 Nov 2007) | 1 line Trivial fix for issue #647. ........ r40962 | nesotto | 2007-11-09 02:27:42 -0800 (Fri, 09 Nov 2007) | 1 line major update wrt. new range concepts ........ r40963 | johnmaddock | 2007-11-09 03:01:45 -0800 (Fri, 09 Nov 2007) | 1 line Improved error messages and added tentative fixes for HP Tru64: the compiler appears to store constants that should underflow to zero as a small non-zero values which messes up the logic used in the test cases. ........ r40964 | nesotto | 2007-11-09 05:13:06 -0800 (Fri, 09 Nov 2007) | 1 line minor editorial issue ........ r40965 | nesotto | 2007-11-09 05:30:57 -0800 (Fri, 09 Nov 2007) | 1 line update of new concepts, and replacement of range_size<T>::type with range_difference<T>::type throughut the library ........ r40966 | nesotto | 2007-11-09 05:31:43 -0800 (Fri, 09 Nov 2007) | 1 line minor tweaks to avoid warnings ... extension mechanism updated to follow new protocol ........ r40967 | schoepflin | 2007-11-09 06:25:44 -0800 (Fri, 09 Nov 2007) | 1 line Added memory barriers to Tru64 atomic ops. ........ r40968 | nesotto | 2007-11-09 07:15:28 -0800 (Fri, 09 Nov 2007) | 1 line improved reference ........ r40969 | johnmaddock | 2007-11-09 08:57:42 -0800 (Fri, 09 Nov 2007) | 1 line Added needed macro suppression to use of isfinite. ........ [SVN r40970]
2007-11-09 17:28:34 +00:00
parent de8f941720
commit e9a4a0d7aa
16 changed files with 539 additions and 460 deletions
@@ -70,6 +70,10 @@ class=identifier>range_iterator</span></a><span class=special>;
    </span><span class=keyword>struct </span><a href="#range_value"><span 
 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="#range_reference"><span 
+class=identifier>range_reference</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="#range_pointer"><span 
 class=identifier>range_pointer</span></a><span class=special>;
@@ -94,14 +98,6 @@ class=identifier>range_difference</span></a><span class=special>;
    </span><span class=keyword>struct </span><a 
 href="#range_reverse_iterator"><span
 class=identifier>range_reverse_iterator</span></a><span class=special>;
-
-    </span><span class=comment>//
-    // Random Access 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="#range_size"><span 
-class=identifier>range_size</span></a><span class=special>;
    
    </span><span class=comment>//
    // Single Pass Range functions
@@ -109,23 +105,23 @@ class=identifier>range_size</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>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><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>r </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>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=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></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>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>r </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>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><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>r </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>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=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></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>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>r </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>bool
-    </span><a href="#empty"><span class=identifier>empty</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><a href="#empty"><span class=identifier>empty</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
               
    </span><span class=comment>//
    // Forward Range functions
@@ -133,7 +129,7 @@ class=identifier>range_size</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>range_difference</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>distance</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><a href="#size"><span class=identifier>distance</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
                            
    </span><span class=comment>//
    // Bidirectional Range functions
@@ -141,30 +137,29 @@ class=identifier>range_size</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>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><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>r </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>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=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></span><span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=keyword>const </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>r </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>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><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>r </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>range_reverse_iterator</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=keyword>const </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>);
+class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
    </span>
-	               
    </span><span class=comment>//
    // Random Access 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>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><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>r </span><span class=special>);</span>
+    
    <span class=comment>//
    // Special const Range functions
    // 
@@ -185,6 +180,26 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
    <span class=keyword>typename </span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type </span>
    <a href="#const_rend"><span class=identifier>const_rend</span></a><span class=special>( </span><span class=keyword>const </span><span class=identifier>T</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);</span>

+    <span class=comment>//
+    // String utilities
+    //</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=identifier>iterator_range</span><span class=special>&lt;...</span><span class=identifier>see</span> <span class=identifier>below</span><span class=special>...&gt;</span> 
+    <span class=identifier><a href="#as_literal">as_literal</a></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>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</span>
+    <span class=identifier>iterator_range</span><span class=special>&lt;...</span><span class=identifier>see</span> <span class=identifier>below</span><span class=special>...&gt;</span> 
+    <span class=identifier><a href="#as_array">as_literal</a></span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>T</span><span class=special>&amp;</span> <span class=identifier>r</span> <span class=special>);</span>
+
+    <span class=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=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>T</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=special>&gt;</span> 
+    <span class=identifier><a href="#as_array">as_array</a></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>template</span><span class=special>&lt;</span> <span class=keyword>class</span> <span class=identifier>T</span> <span class=special>&gt;</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=keyword>const</span> <span class=identifier>T</span><span class=special>&gt;::</span><span class=identifier>type</span> <span class=special>&gt;</span> 
+    <span class=identifier><a href="#as_literal">as_array</a></span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>T</span><span class=special>&amp;</span> <span class=identifier>r</span> <span class=special>);</span>
+
 <span class=special>} </span><span class=comment>// namespace 'boost' 
 </span>
 </pre>
@@ -244,88 +259,79 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    <th>
                        Complexity</th>
                </tr>
-                <tr>
-                    <a name="range_value"></a>
-                    <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> <!--if <code>P</code> is an instantiation of <code>std::pair</code>--><br>
-                        <code>A</code><br>
-                        <code>Char</code>
-                    <td>compile time</td>
-                </tr>
                <tr>
                    <a name="range_iterator"></a>
                    <td><code>range_iterator&lt;X&gt;::type</code></td>
                    <td><code>T::iterator</code><br>
                        <code>P::first_type</code><br>
                        <code>A*</code><br>
-                        <code>Char*</code>
+
                    <td>compile time</td>
                </tr>
                <tr>
                    <a name="range_const_iterator"></a>
-                    <td><code>range_const_iterator&lt;X&gt;::type</code></td>
+                    <td><code>range_iterator&lt;const X&gt;::type</code></td>
                    <td><code>T::const_iterator</code><br>
                        <code>P::first_type</code><br>
                        <code>const A*</code><br>
-                        <code>const Char*</code>
+
+                    <td>compile time</td>
+                </tr>
+                <tr>
+                    <a name="range_value"></a>
+                    <td><code>range_value&lt;X&gt;::type</code></td>
+                    <td><code>boost::iterator_value&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
+                     </td>  
+                    <td>compile time</td>
+                </tr>
+                <tr>
+                    <a name="range_reference"></a>
+                    <td><code>range_reference&lt;X&gt;::type</code></td>
+                    <td><code>boost::iterator_reference&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
+                     </td>  
+                    <td>compile time</td>
+                </tr>
+
+                                <tr>
+                    <a name="range_pointer"></a>
+                    <td><code>range_pointer&lt;X&gt;::type</code></td>
+                    <td><code>boost::iterator_pointer&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
+                     </td>  
+                    <td>compile time</td>
+                </tr>
+                
+                                <tr>
+                    <a name="range_category"></a>
+                    <td><code>range_category&lt;X&gt;::type</code></td>
+                    <td><code>boost::iterator_category&lt;range_iterator&lt;X&gt;::type&gt;::type</code>
+                     </td>  
                    <td>compile time</td>
                </tr>
                <tr>
                    <a name="range_difference"></a>
                    <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>
-                        <code>std::ptrdiff_t</code><br>
-                        <code>std::ptrdiff_t</code><br>
+                    <td>
+                        <code>boost::iterator_difference&lt;range_iterator&lt;X&gt;::type&gt;::type</code></td>
+                        
                    <td>compile time</td>
                </tr>
-                <tr>
-                    <a name="range_size"></a>
-                    <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>
-                        <code>std::size_t</code><br>
-                    <td>compile time</td>
-                </tr>
-                <tr>
-                    <a name="range_result_iterator"></a>
-                    <td><code>range_result_iterator&lt;X&gt;::type</code></td>
-                    <td><code>range_const_iterator&lt;X&gt;::type</code> if <code>X</code> is <code>const</code>
-                        <br>
-                        <code>range_iterator&lt;X&gt;::type</code> otherwise
-                    </td>
-                    <td>compile time</td>
                </tr>
+
                <tr>
                    <a name="range_reverse_iterator"></a>
                    <td><code>range_reverse_iterator&lt;X&gt;::type</code></td>
-                    <td><code>boost::reverse_iterator&lt; typename range_iterator&lt;T&gt;::type &gt;</code><br>
+                    <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_const_reverse_iterator&lt;X&gt;::type</code></td>
-                    <td><code>boost::reverse_iterator&lt; typename range_const_iterator&lt;T&gt;::type &gt;</code>
+                    <td><code>range_reverse_iterator&lt;const X&gt;::type</code></td>
+                    <td><code>boost::reverse_iterator&lt;range_iterator&lt;const X&gt;::type&gt;</code>
                        <br>
                    <td>compile time</td>
                </tr>
-                <tr>
-                    <a name="range_reverse_result_iterator"></a>
-                    <td><code>range_reverse_result_iterator&lt;X&gt;::type</code></td>
-                    <td><code>boost::reverse_iterator&lt; typename range_result_iterator&lt;T&gt;::type 
-                            &gt;</code>
-                    <td>compile time</td>
-                </tr>
            </table>
        </p>
-        <p>
-            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 ability to select iterators based on constness.
-        </p>
        <h4>Functions</h4>
        <p>
            <table border="1" cellpadding="5">
@@ -342,12 +348,11 @@ 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>range_result_iterator&lt;X&gt;::type</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>a</code> if <code>a</code> is an array <br>
-                        <code>s</code> if <code>s</code> is a string literal<br>
-                        <code>boost_range_begin(x)</code> if that expression would invoke a function found by ADL <br>
+                        <code>range_begin(x)</code> if that expression would invoke a function found by ADL <br>
                        <code>t.begin()</code> otherwise
   
                    <td>constant time</td>
@@ -355,106 +360,133 @@ 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>range_result_iterator&lt;X&gt;::type</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>a + sz</code> if <code>a</code> is an array of size <code>sz</code><br>
-                        <code>s + std::char_traits&lt;X&gt;::length( s )</code> if <code>s</code> is a <code>Char*</code>
+                        <code>a + sz</code> if <code>a</code> is an array of size <code>sz</code>
+                        
                        <br>
-                        <code>s + sz - 1</code> if <code>s</code> is a string literal of size <code>sz</code>
-                        <br>
-                        <code>boost_range_end(x)</code> if that expression would invoke a function found by ADL <br>
+                        <code>range_end(x)</code> if that expression would invoke a function found by ADL <br>
                        <code>t.end()</code> otherwise
                        
-                    <td>linear if <code>X</code> is <code>Char*</code>
-                        <br>
-                        constant time otherwise</td>
+                    <td>
+                        constant time </td>
                </tr>
                <tr>
                    <a name="empty"></a>
                    <td><code>empty(x)</code></td>
                    <td><code>bool</code></td>
-                    <td><code>begin(x) == end( x )</code><br>
-                    <td>linear if <code>X</code> is <code>Char*</code>
-                        <br>
-                        constant time otherwise<br>
+                    <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><code>range_difference&lt;X&gt;::type</code></td>
+                    <td>
+                        <code>
+                            std::distance(boost::begin(x),boost::end(x))
+                        </code>
+                         </td>
+                    <td>-</td>     
+
+                </tr>
+
                <tr>
                    <a name="size"></a>
                    <td><code>size(x)</code></td>
-                    <td><code>range_size&lt;X&gt;::type</code></td>
-                    <td>
-                        <code>std::distance(p.first,p.second)</code> if <code>p</code> is of type <code>std::pair&ltT&gt;<code><br>
-                        <code>sz</code> if <code>a</code> is an array of size <code>sz</code><br>
-                        <code>end(s) - s</code> if <code>s</code> is a string literal or a <code>Char*</code><br>
-                        <code>boost_range_size(x)</code> if that expression would invoke a function found by ADL <br>
-                        <code>t.size()</code> otherwise
-                    <td>linear if <code>X</code> is <code>Char*</code>
-                        <br>
-                        or if <code>std::distance()</code> is linear
-                        <br>
-                        constant time otherwise</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><code>range_reverse_result_iterator&lt;X&gt;::type</code></td>
-                    <td><code>range_reverse_result_iterator&lt;X&gt;::type( end(x) )</code>
+                    <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>
-                    <td>same as <code>end(x)</code>
+                    <td>constant time
                    </td>
                </tr>
                <tr>
                    <a name="rend"></a>
                    <td><code>rend(x)</code></td>
-                    <td><code>range_reverse_result_iterator&lt;X&gt;::type</code></td>
-                    <td><code>range_reverse_result_iterator&lt;X&gt;::type( begin(x) )</code>
-                    <td>same as <code>begin(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><code>range_const_iterator&lt;X&gt;::type</code></td>
-                    <td><code>range_const_iterator&lt;X&gt;::type( begin(x) )</code>
+                    <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>
-                    <td>same as <code>begin(x)</code>
+                    <td>constant time
                    </td>
                </tr>
                <tr>
                    <a name="const_end"></a>
                    <td><code>const_end(x)</code></td>
-                    <td><code>range_const_iterator&lt;X&gt;::type</code></td>
-                    <td><code>range_const_iterator&lt;X&gt;::type( end(x) )</code>
-                    <td>same as <code>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><code>range_const_reverse_iterator&lt;X&gt;::type</code></td>
-                    <td><code>range_const_reverse_iterator&lt;X&gt;::type( rbegin(x) )</code>
+                    <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>
-                    <td>same as <code>rbegin(x)</code>
+                    <td>constant time
                    </td>
                </tr>
                <tr>
                    <a name="const_rend"></a>
                    <td><code>const_rend(x)</code></td>
-                    <td><code>range_const_reverse_iterator&lt;X&gt;::type</code></td>
-                    <td><code>range_const_reverse_iterator&lt;X&gt;::type( rend(x) )</code>
-                    <td>same as <code>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><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
+                        <code>range_iterator&lt;X>::type</code> otherwise
+                        </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>
+                                <br>
+                                    <code>[boost::begin(x),boost::end(x))</code> otherwise
+
+
+                         
+                         </td>   
+                    <td>linear time for pointers to a string, constant time 
+                        otherwise</td>
                </tr>
            </table>
        </p>
        <p>
-            The special <code>const</code> functions are not part of any Range concept, but 
-            are very useful when you want to document clearly that your code is read-only.
+            The special <code>const_</code>-named functions are useful when you 
+            want to document clearly that your code is read-only.
        </p>
+            <p>Notice that the above functions should always be called with 
+                qualification (<code>boost::</code>) to prevent <i>unintended</i> 
+                Argument Dependent Lookup (ADL).
+                </p>
        <hr>
        <a name="minimal_interface"></a>
        <h3>Extending the library</h3>
        <ul>
        <li><a href="#method1">Method 1: provide member functions and nested types</a></li>
+            
        <li><a href="#method2">Method 2: provide free-standing functions and specialize metafunctions</a></li>
        </ul>

@@ -491,10 +523,6 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    </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.html#forward_range">Forward Range</a></td>
-                </tr>
            </table>
        </p>
        <p>
@@ -520,10 +548,6 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    <td><code>const_iterator</code></td>
                    <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
                </tr>
-                <tr>
-                    <td><code>size_type</code></td>
-                    <td><a href="range.html#forward_range">Forward Range</a></td>
-                </tr>
            </table>
        </p>
        <p>
@@ -554,26 +578,23 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    <th>
                        Related concept</th>
                <tr>
-                    <td><code>boost_range_begin(x)</code></td>
+                    <td><code>range_begin(x)</code></td>
                    <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
                </tr>
                <tr>
-                    <td><code>boost_range_end(x)</code>
+                    <td><code>range_end(x)</code>
                    </td>
                    <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
                </tr>
-                <tr>
-                    <td><code>boost_range_size(x)</code></td>
-                    <td><a href="range.html#forward_range">Forward Range</a></td>
-                </tr>
+
            </table>        
        </p>
-        <p><code>boost_range_begin()</code> and <code>boost_range_end()</code> must be
+        <p><code>range_begin()</code> and <code>range_end()</code> must be
        overloaded for both <code>const</code> and mutable reference arguments.
        </p>
        
        <p>
-        You must also specialize 3 metafunctions for your type <code>X</code>:
+        You must also specialize two metafunctions for your type <code>X</code>:
        </p>
        <p>
            <table cellpadding="5" border="1" ID="Table2">
@@ -583,17 +604,14 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
                    <th>
                        Related concept</th>
                <tr>
-                    <td><code>boost::range_iterator</code></td>
+                    <td><code>boost::range_mutable_iterator</code></td>
                    <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
                </tr>
                <tr>
                    <td><code>boost::range_const_iterator</code></td>
                    <td><a href="range.html#single_pass_range">Single Pass Range</a></td>
                </tr>
-                <tr>
-                    <td><code>boost::range_size</code></td>
-                    <td><a href="range.html#forward_range">Forward Range</a></td>
-                </tr>
+
            </table>
        </p>
        <p>
@@ -627,7 +645,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
    //</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> <span class=identifier>range_iterator</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;</span> <span class=special>&gt;</span>
+    <span class=keyword>struct</span> <span class=identifier>range_mutable_iterator</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;</span> <span class=special>&gt;</span>
    <span class=special>{</span>
        <span class=keyword>typedef</span> <span class=identifier>T</span> <span class=identifier>type</span><span class=special>;</span>
    <span class=special>};</span>
@@ -636,20 +654,13 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
    <span class=keyword>struct</span> <span class=identifier>range_const_iterator</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;</span> <span class=special>&gt;</span>
    <span class=special>{</span>
        <span class=comment>//
-        // Remark: this is defined similar to 'range_iterator'
+        // Remark: this is defined similar to 'range_mutable_iterator'
        //         because the 'Pair' type does not distinguish
        //         between an iterator and a const_iterator.
        //</span>
        <span class=keyword>typedef</span> <span class=identifier>T</span> <span class=identifier>type</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>struct</span> <span class=identifier>range_size</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;</span> <span class=special>&gt;</span>
-    <span class=special>{</span>
-
-        <span class=keyword>typedef</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>size_t</span> <span class=identifier>type</span><span class=special>;</span>
-    <span class=special>};</span>
-
 <span class=special>}</span> <span class=comment>// namespace 'boost'</span>

 <span class=keyword>namespace</span> <span class=identifier>Foo</span>
@@ -661,36 +672,29 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
    //</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>inline</span> <span class=identifier>T</span> <span class=identifier>boost_range_begin</span><span class=special>(</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
+    <span class=keyword>inline</span> <span class=identifier>T</span> <span class=identifier>range_begin</span><span class=special>(</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
    <span class=special>{</span> 
        <span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>first</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>inline</span> <span class=identifier>T</span> <span class=identifier>boost_range_begin</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
+    <span class=keyword>inline</span> <span class=identifier>T</span> <span class=identifier>range_begin</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
    <span class=special>{</span> 
        <span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>first</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>inline</span> <span class=identifier>T</span> <span class=identifier>boost_range_end</span><span class=special>(</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
+    <span class=keyword>inline</span> <span class=identifier>T</span> <span class=identifier>range_end</span><span class=special>(</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
    <span class=special>{</span> 
        <span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>last</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>inline</span> <span class=identifier>T</span> <span class=identifier>boost_range_end</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
+    <span class=keyword>inline</span> <span class=identifier>T</span> <span class=identifier>range_end</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</span> <span class=special>)</span>
    <span class=special>{</span> 
        <span class=keyword>return</span> <span class=identifier>x</span><span class=special>.</span><span class=identifier>last</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>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>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;</span> <span class=special>&gt;::</span><span class=identifier>type</span>
-    <span class=identifier>boost_range_size</span><span class=special>(</span> <span class=keyword>const</span> <span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>T</span><span class=special>&gt;&amp;</span> <span class=identifier>x</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>distance</span><span class=special>(</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>first</span><span class=special>,</span><span class=identifier>x</span><span class=special>.</span><span class=identifier>last</span><span class=special>);</span>
-    <span class=special>}</span>
-
 <span class=special>}</span> <span class=comment>// namespace 'Foo'</span>

 <span class=preprocessor>#include</span> <span class=special>&lt;</span><span class=identifier>vector</span><span class=special>&gt;</span>
@@ -699,7 +703,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
 <span class=special>{</span>
    <span class=keyword>typedef</span> <span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;::</span><span class=identifier>iterator</span>  <span class=identifier>iter</span><span class=special>;</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>vec</span><span class=special>;</span>
-    <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;</span>                     <span class=identifier>pair</span> <span class=special>=</span> <span class=special>{</span> <span class=identifier>vec</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span> <span class=identifier>vec</span><span class=special>.</span><span class=identifier>end</span><span class=special>()</span> <span class=special>};</span>
+    <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;</span>                     <span class=identifier>pair</span>  <span class=special>=</span> <span class=special>{</span> <span class=identifier>vec</span><span class=special>.</span><span class=identifier>begin</span><span class=special>(),</span> <span class=identifier>vec</span><span class=special>.</span><span class=identifier>end</span><span class=special>()</span> <span class=special>};</span>
    <span class=keyword>const</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;&amp;</span>              <span class=identifier>cpair</span> <span class=special>=</span> <span class=identifier>pair</span><span class=special>;</span> 
    <span class=comment>//
    // Notice that we call 'begin' etc with qualification. 
@@ -708,9 +712,9 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
    <span class=identifier>iter</span> <span class=identifier>e</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>pair</span> <span class=special>);</span>
    <span class=identifier>i</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>cpair</span> <span class=special>);</span>
    <span class=identifier>e</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>cpair</span> <span class=special>);</span>
-    <span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_size</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;</span> <span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>s</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>size</span><span class=special>(</span> <span class=identifier>pair</span> <span class=special>);</span>
+    <span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_difference</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;</span> <span class=special>&gt;::</span><span class=identifier>type</span> <span class=identifier>s</span> <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>size</span><span class=special>(</span> <span class=identifier>pair</span> <span class=special>);</span>
    <span class=identifier>s</span>      <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>size</span><span class=special>(</span> <span class=identifier>cpair</span> <span class=special>);</span>
-    <span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_const_reverse_iterator</span><span class=special>&lt;</span> <span class=identifier>Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;</span> <span class=special>&gt;::</span><span class=identifier>type</span>
+    <span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_reverse_iterator</span><span class=special>&lt;</span> <span class=identifier>const Foo</span><span class=special>::</span><span class=identifier>Pair</span><span class=special>&lt;</span><span class=identifier>iter</span><span class=special>&gt;</span> <span class=special>&gt;::</span><span class=identifier>type</span>
    <span class=identifier>ri</span>     <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>rbegin</span><span class=special>(</span> <span class=identifier>cpair</span> <span class=special>),</span>
    <span class=identifier>re</span>     <span class=special>=</span> <span class=identifier>boost</span><span class=special>::</span><span class=identifier>rend</span><span class=special>(</span> <span class=identifier>cpair</span> <span class=special>);</span>
 <span class=special>}</span>    
@@ -719,7 +723,7 @@ class=identifier>T</span><span class=special>&amp; </span><span class=identifier
        
        <hr>
        <p>
-            (C) Copyright Thorsten Ottosen 2003-2004
+            (C) Copyright Thorsten Ottosen 2003-2007
        </p>
        <br>
        <br>