Full merge from trunk at revision 41356 of entire boost-root tree.

[SVN r41370]

doc/Jamfile.v2

@@ -0,0 +1,22 @@
+
+use-project boost : $(BOOST_ROOT) ;
+
+
+import boostbook : boostbook ;
+import quickbook ;
+
+xml boost_range : boost_range.qbk ;
+
+boostbook standalone
+  :
+    boost_range
+  :
+    <xsl:param>toc.max.depth=2
+    <xsl:param>toc.section.depth=4
+    <xsl:param>chunk.section.depth=2
+ 
+#    <xsl:param>generate.section.toc.level=4
+#    <xsl:param>chunk.first.sections=7
+#    <xsl:param>toc.section.depth=10
+  ;
+

doc/example.cpp

@@ -1,10 +1,3 @@
-/*
-//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-//  distribution is subject to the Boost Software License, Version
-//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt)
-*/
-
 #include <boost/range.hpp>
 #include <iterator>         // for std::iterator_traits, std::distance()
 

doc/examples.html

@@ -26,10 +26,6 @@
         </li>
         shows how to implement a container version of <code  >std::find()</code> that
         works with <code  >char[],wchar_t[],char*,wchar_t*.</code>
-        <p>
-         <b>Warning:</b><i> support for null-terminated strings is deprecated and will
-              disappear in the next Boost release (1.34). </i>
-        </p>
 
         <li  >
             <a href="../test/algorithm_example.cpp" target="_self" ><code  >algorithm_example.cpp</code></a>
@@ -47,7 +43,7 @@
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
     </p>
 
     <br>

doc/faq.html

@@ -116,7 +116,7 @@ Cool indeed!
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
     </p>
 
     <br>

doc/headers.html

@@ -50,6 +50,12 @@
                                                 >range_iterator</a></td>
             <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
         </tr>
+        <tr  >
+            <td  ><code  >&lt;boost/range/mutable_iterator.hpp&gt;</code></td>
+            <td  ><a href="boost_range.html#range_mutable_iterator"
+                                                >range_mutable_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#range_const_iterator"
@@ -63,31 +69,23 @@
             <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#range_size" >range_size</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#range_result_iterator"
-                >range_result_iterator</a></td>
+            <td  ><code  >&lt;boost/range/pointer.hpp&gt;</code></td>
+            <td  ><a href="boost_range.html#range_pointer" 
+                >range_pointer</a></td>
             <td>- </td>
         </tr>
+        <tr  >
+            <td  ><code  >&lt;boost/range/category.hpp&gt;</code></td>
+            <td  ><a href="boost_range.html#range_category" 
+                >range_category</a></td>
+            <td>- </td>
+        </tr>
+
         <tr  >
             <td  ><code  >&lt;boost/range/reverse_iterator.hpp&gt;</code></td>
             <td  ><a href="boost_range.html#range_reverse_iterator" >range_reverse_iterator</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#range_const_reverse_iterator" >range_const_reverse_iterator</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#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  >
@@ -109,10 +107,16 @@
             <td  ><a href="boost_range.html#empty" >empty</a></td>
             <td><a href="range.html#single_pass_range">Single Pass Range</a> </td>
         </tr>
+        <tr  >
+            <td  ><code  >&lt;boost/range/distance.hpp&gt;</code></td>
+            <td  ><a href="boost_range.html#distance" >distance</a></td>
+            <td><a href="range.html#forward_range">Forward 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.html#forward_range">Forward Range</a> </td>
+            <td><a href="range.html#random_access_range">Random Access Range</a> 
+                </td>
         </tr>
         <tr  >
             <td  ><code  >&lt;boost/range/rbegin.hpp&gt;</code></td>
@@ -130,6 +134,21 @@
             </td>
             <td><a href="range.html#bidirectional_range">Bidirectional Range</a> </td>
         </tr>
+        <tr  >
+            <td  ><code  >&lt;boost/range/as_array.hpp&gt;</code></td>
+            <td  >
+                 <a href="boost_range.html#as_array" >as_array</a>
+            </td>
+            <td>-</td>
+        </tr>
+        <tr  >
+            <td  ><code  >&lt;boost/range/as_literal.hpp&gt;</code></td>
+            <td  >
+                 <a href="boost_range.html#as_literal" >as_literal</a>
+            </td>
+            <td>-</td>
+        </tr>
+
         <tr  >
             <td  ><code >&lt;boost/range/iterator_range.hpp&gt;</code></td>
             <td  ><a href="utility_class.html#iter_range"
@@ -154,7 +173,7 @@
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2007
     </p>
 
     <br>

doc/history_ack.html

@@ -61,7 +61,7 @@ C++ standard: <blockquote>
     
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2006
     </p>
 
     <br>

doc/intro.html

@@ -35,16 +35,14 @@
     enough functionality to satisfy the needs of the generic code
     <i>if a suitable layer of indirection is applied </i>.  For
     example, raw arrays are often suitable for use with generic code that
-    works with containers, provided a suitable adapter is used. Likewise, null
-    terminated strings can be treated as containers of characters, if suitably
-    adapted.
+    works with containers, provided a suitable adapter is used. 
     </p>
 
     <p>
      This library therefore provides the means to adapt standard-like
-     containers,
-    null terminated strings, <code>std::pairs</code> of iterators, and raw
-    arrays (and more), such that the same generic code can work with them all.
+     containers, <code>std::pairs</code> of iterators, and raw arrays (and 
+     more), such that
+    the same generic code can work with them all.
 The basic idea is to add another layer of indirection using <a
 href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a> and
 free-standing functions so syntactic and/or semantic differences can be removed.
@@ -60,22 +58,14 @@ free-standing functions so syntactic and/or semantic differences can be removed.
             more flexible, compact and maintainable client code
         </li>
         <li  >
-            correct handling of null-terminated strings
-            <p>
-            <b>Warning:</b><i> support for null-terminated strings is deprecated and will
-              disappear in the next Boost release (1.34). </i>
-             </p>
+        safe use of built-in arrays
         </li>
-        <li  >
-        safe use of built-in arrays (for legacy code; why else would you use
-        built-in arrays?) </li>
 
     </ul>
     </p>
     <p  >
-    Below are given a small example (the complete example can be found <a href="../test/algorithm_example.cpp" target="_self" >here</a>
-    ):
-    <blockquote>
+    Below are given a small example (the complete example can be found <a 
+    href="../test/algorithm_example.cpp" target="_self" >here</a>): <blockquote>
         <pre  >
 <span class=comment>
     //
@@ -89,7 +79,7 @@ free-standing functions so syntactic and/or semantic differences can be removed.
     </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>range_const_iterator</span><span class=special>&lt; </span><span
+    </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=keyword>const </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>{
@@ -100,7 +90,7 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
     // 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>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=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_difference</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>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>);
@@ -146,7 +136,7 @@ Notice that we have to
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2007
     </p>
 
     <br>

doc/mfc_atl.html

@@ -0,0 +1,581 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+<meta name="generator" content="Docutils 0.3.10: http://docutils.sourceforge.net/" />
+<title>Boost Range MFC/ATL Extension</title>
+<meta name="author" content="Shunsuke Sogame" />
+<meta name="date" content="26th of May 2006" />
+<meta name="copyright" content="Shunsuke Sogame 2005-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see LICENSE_1_0.txt)." />
+<style type="text/css">
+
+/*
+:Author: David Goodger
+:Contact: goodger@users.sourceforge.net
+:Date: $Date: 2005-09-25 17:49:54 +0200 (Sun, 25 Sep 2005) $
+:Revision: $Revision: 3901 $
+:Copyright: This stylesheet has been placed in the public domain.
+
+Default cascading style sheet for the HTML output of Docutils.
+
+See http://docutils.sf.net/docs/howto/html-stylesheets.html for how to
+customize this style sheet.
+*/
+
+/* "! important" is used here to override other ``margin-top`` and
+   ``margin-bottom`` styles that are later in the stylesheet or 
+   more specific.  See http://www.w3.org/TR/CSS1#the-cascade */
+.first {
+  margin-top: 0 ! important }
+
+.last, .with-subtitle {
+  margin-bottom: 0 ! important }
+
+.hidden {
+  display: none }
+
+a.toc-backref {
+  text-decoration: none ;
+  color: black }
+
+blockquote.epigraph {
+  margin: 2em 5em ; }
+
+dl.docutils dd {
+  margin-bottom: 0.5em }
+
+/* Uncomment (and remove this text!) to get bold-faced definition list terms
+dl.docutils dt {
+  font-weight: bold }
+*/
+
+div.abstract {
+  margin: 2em 5em }
+
+div.abstract p.topic-title {
+  font-weight: bold ;
+  text-align: center }
+
+div.admonition, div.attention, div.caution, div.danger, div.error,
+div.hint, div.important, div.note, div.tip, div.warning {
+  margin: 2em ;
+  border: medium outset ;
+  padding: 1em }
+
+div.admonition p.admonition-title, div.hint p.admonition-title,
+div.important p.admonition-title, div.note p.admonition-title,
+div.tip p.admonition-title {
+  font-weight: bold ;
+  font-family: sans-serif }
+
+div.attention p.admonition-title, div.caution p.admonition-title,
+div.danger p.admonition-title, div.error p.admonition-title,
+div.warning p.admonition-title {
+  color: red ;
+  font-weight: bold ;
+  font-family: sans-serif }
+
+/* Uncomment (and remove this text!) to get reduced vertical space in
+   compound paragraphs.
+div.compound .compound-first, div.compound .compound-middle {
+  margin-bottom: 0.5em }
+
+div.compound .compound-last, div.compound .compound-middle {
+  margin-top: 0.5em }
+*/
+
+div.dedication {
+  margin: 2em 5em ;
+  text-align: center ;
+  font-style: italic }
+
+div.dedication p.topic-title {
+  font-weight: bold ;
+  font-style: normal }
+
+div.figure {
+  margin-left: 2em }
+
+div.footer, div.header {
+  clear: both;
+  font-size: smaller }
+
+div.line-block {
+  display: block ;
+  margin-top: 1em ;
+  margin-bottom: 1em }
+
+div.line-block div.line-block {
+  margin-top: 0 ;
+  margin-bottom: 0 ;
+  margin-left: 1.5em }
+
+div.sidebar {
+  margin-left: 1em ;
+  border: medium outset ;
+  padding: 1em ;
+  background-color: #ffffee ;
+  width: 40% ;
+  float: right ;
+  clear: right }
+
+div.sidebar p.rubric {
+  font-family: sans-serif ;
+  font-size: medium }
+
+div.system-messages {
+  margin: 5em }
+
+div.system-messages h1 {
+  color: red }
+
+div.system-message {
+  border: medium outset ;
+  padding: 1em }
+
+div.system-message p.system-message-title {
+  color: red ;
+  font-weight: bold }
+
+div.topic {
+  margin: 2em }
+
+h1.section-subtitle, h2.section-subtitle, h3.section-subtitle,
+h4.section-subtitle, h5.section-subtitle, h6.section-subtitle {
+  margin-top: 0.4em }
+
+h1.title {
+  text-align: center }
+
+h2.subtitle {
+  text-align: center }
+
+hr.docutils {
+  width: 75% }
+
+img.align-left {
+  clear: left }
+
+img.align-right {
+  clear: right }
+
+img.borderless {
+  border: 0 }
+
+ol.simple, ul.simple {
+  margin-bottom: 1em }
+
+ol.arabic {
+  list-style: decimal }
+
+ol.loweralpha {
+  list-style: lower-alpha }
+
+ol.upperalpha {
+  list-style: upper-alpha }
+
+ol.lowerroman {
+  list-style: lower-roman }
+
+ol.upperroman {
+  list-style: upper-roman }
+
+p.attribution {
+  text-align: right ;
+  margin-left: 50% }
+
+p.caption {
+  font-style: italic }
+
+p.credits {
+  font-style: italic ;
+  font-size: smaller }
+
+p.label {
+  white-space: nowrap }
+
+p.rubric {
+  font-weight: bold ;
+  font-size: larger ;
+  color: maroon ;
+  text-align: center }
+
+p.sidebar-title {
+  font-family: sans-serif ;
+  font-weight: bold ;
+  font-size: larger }
+
+p.sidebar-subtitle {
+  font-family: sans-serif ;
+  font-weight: bold }
+
+p.topic-title {
+  font-weight: bold }
+
+pre.address {
+  margin-bottom: 0 ;
+  margin-top: 0 ;
+  font-family: serif ;
+  font-size: 100% }
+
+pre.line-block {
+  font-family: serif ;
+  font-size: 100% }
+
+pre.literal-block, pre.doctest-block {
+  margin-left: 2em ;
+  margin-right: 2em ;
+  background-color: #eeeeee }
+
+span.classifier {
+  font-family: sans-serif ;
+  font-style: oblique }
+
+span.classifier-delimiter {
+  font-family: sans-serif ;
+  font-weight: bold }
+
+span.interpreted {
+  font-family: sans-serif }
+
+span.option {
+  white-space: nowrap }
+
+span.pre {
+  white-space: pre }
+
+span.problematic {
+  color: red }
+
+span.section-subtitle {
+  /* font-size relative to parent (h1..h6 element) */
+  font-size: 80% }
+
+table.citation {
+  border-left: solid thin gray }
+
+table.docinfo {
+  margin: 2em 4em }
+
+table.docutils {
+  margin-top: 0.5em ;
+  margin-bottom: 0.5em }
+
+table.footnote {
+  border-left: solid thin black }
+
+table.docutils td, table.docutils th,
+table.docinfo td, table.docinfo th {
+  padding-left: 0.5em ;
+  padding-right: 0.5em ;
+  vertical-align: top }
+
+table.docutils th.field-name, table.docinfo th.docinfo-name {
+  font-weight: bold ;
+  text-align: left ;
+  white-space: nowrap ;
+  padding-left: 0 }
+
+h1 tt.docutils, h2 tt.docutils, h3 tt.docutils,
+h4 tt.docutils, h5 tt.docutils, h6 tt.docutils {
+  font-size: 100% }
+
+tt.docutils {
+  background-color: #eeeeee }
+
+ul.auto-toc {
+  list-style-type: none }
+
+</style>
+</head>
+<body>
+<div class="document" id="boost-range-mfc-atl-extension">
+<h1 class="title"><img alt="Boost" src="http://www.boost.org/libs/ptr_container/doc/boost.png" /> Range MFC/ATL Extension</h1>
+<table class="docinfo" frame="void" rules="none">
+<col class="docinfo-name" />
+<col class="docinfo-content" />
+<tbody valign="top">
+<tr><th class="docinfo-name">Author:</th>
+<td>Shunsuke Sogame</td></tr>
+<tr><th class="docinfo-name">Contact:</th>
+<td><a class="first last reference" href="mailto:mb2act&#64;yahoo.co.jp">mb2act&#64;yahoo.co.jp</a></td></tr>
+<tr><th class="docinfo-name">Date:</th>
+<td>26th of May 2006</td></tr>
+<tr><th class="docinfo-name">Copyright:</th>
+<td>Shunsuke Sogame 2005-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see <a class="reference" href="http://www.boost.org/LICENSE_1_0.txt">LICENSE_1_0.txt</a>).</td></tr>
+</tbody>
+</table>
+<div class="section">
+<h1><a id="overview" name="overview">Overview</a></h1>
+<p>Boost.Range MFC/ATL Extension provides <a class="reference" href="../index.html">Boost.Range</a> support for MFC/ATL collection and string types.</p>
+<pre class="literal-block">
+CTypedPtrArray&lt;CPtrArray, CList&lt;CString&gt; *&gt; myArray;
+...
+BOOST_FOREACH (CList&lt;CString&gt; *theList, myArray)
+{
+    BOOST_FOREACH (CString&amp; str, *theList)
+    {
+        boost::to_upper(str);
+        std::sort(boost::begin(str), boost::end(str));
+        ...
+    }
+}
+</pre>
+<ul class="simple">
+<li><a class="reference" href="#requirements">Requirements</a></li>
+<li><a class="reference" href="#mfc-ranges">MFC Ranges</a></li>
+<li><a class="reference" href="#atl-ranges">ATL Ranges</a></li>
+<li><a class="reference" href="#const-ranges">const Ranges</a></li>
+<li><a class="reference" href="#references">References</a></li>
+</ul>
+</div>
+<div class="section">
+<h1><a id="requirements" name="requirements">Requirements</a></h1>
+<ul class="simple">
+<li><a class="reference" href="http://www.boost.org/">Boost C++ Libraries Version 1.34.0</a> or later (no compilation required)</li>
+<li>Visual C++ 7.1 or Visual C++ 8.0</li>
+</ul>
+</div>
+<div class="section">
+<h1><a id="mfc-ranges" name="mfc-ranges">MFC Ranges</a></h1>
+<p>If the <tt class="docutils literal"><span class="pre">&lt;boost/range/mfc.hpp&gt;</span></tt> is included before or after <a class="reference" href="../index.html">Boost.Range</a> headers,
+the MFC collections and strings become models of Range.
+The table below lists the Traversal Category and <tt class="docutils literal"><span class="pre">range_reference</span></tt> of MFC ranges.</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="34%" />
+<col width="21%" />
+<col width="45%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th class="head"><tt class="docutils literal"><span class="pre">Range</span></tt></th>
+<th class="head">Traversal Category</th>
+<th class="head"><tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt></th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="docutils literal"><span class="pre">CArray&lt;T,A&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">T&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CList&lt;T,A&gt;</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">T&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CMap&lt;K,AK,M,AM&gt;</span></tt></td>
+<td>Forward</td>
+<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CTypedPtrArray&lt;B,T*&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">T*</span> <span class="pre">const</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CTypedPtrList&lt;B,T*&gt;</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">T*</span> <span class="pre">const</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CTypedPtrMap&lt;B,T*,V*&gt;</span></tt></td>
+<td>Forward</td>
+<td><tt class="docutils literal"><span class="pre">std::pair&lt;T*,V*&gt;</span> <span class="pre">const</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CByteArray</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">BYTE&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CDWordArray</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">DWORD&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CObArray</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">CObject*</span> <span class="pre">&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CPtrArray</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">void*</span> <span class="pre">&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CStringArray</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">CString&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CUIntArray</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">UINT&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CWordArray</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">WORD&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CObList</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">CObject*</span> <span class="pre">&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CPtrList</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">void*</span> <span class="pre">&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CStringList</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">CString&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CMapPtrToWord</span></tt></td>
+<td>Forward</td>
+<td><tt class="docutils literal"><span class="pre">std::pair&lt;void*,WORD&gt;</span> <span class="pre">const</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CMapPtrToPtr</span></tt></td>
+<td>Forward</td>
+<td><tt class="docutils literal"><span class="pre">std::pair&lt;void*,void*&gt;</span> <span class="pre">const</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CMapStringToOb</span></tt></td>
+<td>Forward</td>
+<td><tt class="docutils literal"><span class="pre">std::pair&lt;String,CObject*&gt;</span> <span class="pre">const</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CMapStringToString</span></tt></td>
+<td>Forward</td>
+<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CMapWordToOb</span></tt></td>
+<td>Forward</td>
+<td><tt class="docutils literal"><span class="pre">std::pair&lt;WORD,CObject*&gt;</span> <span class="pre">const</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CMapWordToPtr</span></tt></td>
+<td>Forward</td>
+<td><tt class="docutils literal"><span class="pre">std::pair&lt;WORD,void*&gt;</span> <span class="pre">const</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p>Other <a class="reference" href="../index.html">Boost.Range</a> metafunctions are defined by the following.
+Let <tt class="docutils literal"><span class="pre">Range</span></tt> be any type listed above and <tt class="docutils literal"><span class="pre">ReF</span></tt> be the same as <tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt>.
+<tt class="docutils literal"><span class="pre">range_value&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">remove_reference&lt;remove_const&lt;Ref&gt;::type&gt;::type</span></tt>,
+<tt class="docutils literal"><span class="pre">range_difference&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">std::ptrdiff_t</span></tt>, and
+<tt class="docutils literal"><span class="pre">range_pointer&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">add_pointer&lt;remove_reference&lt;Ref&gt;::type&gt;::type</span></tt>.
+As for <tt class="docutils literal"><span class="pre">const</span> <span class="pre">Range</span></tt>, see <a class="reference" href="#const-ranges">const Ranges</a>.</p>
+</div>
+<div class="section">
+<h1><a id="atl-ranges" name="atl-ranges">ATL Ranges</a></h1>
+<p>If the <tt class="docutils literal"><span class="pre">&lt;boost/range/atl.hpp&gt;</span></tt> is included before or after <a class="reference" href="../index.html">Boost.Range</a> headers,
+the ATL collections and strings become models of Range.
+The table below lists the Traversal Category and <tt class="docutils literal"><span class="pre">range_reference</span></tt> of ATL ranges.</p>
+<table border="1" class="docutils">
+<colgroup>
+<col width="34%" />
+<col width="21%" />
+<col width="45%" />
+</colgroup>
+<thead valign="bottom">
+<tr><th class="head"><tt class="docutils literal"><span class="pre">Range</span></tt></th>
+<th class="head">Traversal Category</th>
+<th class="head"><tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt></th>
+</tr>
+</thead>
+<tbody valign="top">
+<tr><td><tt class="docutils literal"><span class="pre">CAtlArray&lt;E,ET&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CAutoPtrArray&lt;E&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CInterfaceArray&lt;I,pi&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">CComQIPtr&lt;I,pi&gt;&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CAtlList&lt;E,ET&gt;</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CAutoPtrList&lt;E&gt;</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CHeapPtrList&lt;E,A&gt;</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">E&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CInterfaceList&lt;I,pi&gt;</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">CComQIPtr&lt;I,pi&gt;&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CAtlMap&lt;K,V,KT,VT&gt;</span></tt></td>
+<td>Forward</td>
+<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CRBTree&lt;K,V,KT,VT&gt;</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CRBMap&lt;K,V,KT,VT&gt;</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CRBMultiMap&lt;K,V,KT,VT&gt;</span></tt></td>
+<td>Bidirectional</td>
+<td><tt class="docutils literal"><span class="pre">Range::CPair&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CSimpleStringT&lt;B,b&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">B&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CStringT&lt;B,ST&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">B&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CFixedStringT&lt;S,n&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">range_reference&lt;S&gt;::type</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CStringT&lt;B,ST&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">B&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CComBSTR</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">OLECHAR&amp;</span></tt></td>
+</tr>
+<tr><td><tt class="docutils literal"><span class="pre">CSimpleArray&lt;T,TE&gt;</span></tt></td>
+<td>Random Access</td>
+<td><tt class="docutils literal"><span class="pre">T&amp;</span></tt></td>
+</tr>
+</tbody>
+</table>
+<p>Other <a class="reference" href="../index.html">Boost.Range</a> metafunctions are defined by the following.
+Let <tt class="docutils literal"><span class="pre">Range</span></tt> be any type listed above and <tt class="docutils literal"><span class="pre">ReF</span></tt> be the same as <tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt>.
+<tt class="docutils literal"><span class="pre">range_value&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">remove_reference&lt;Ref&gt;::type</span></tt>,
+<tt class="docutils literal"><span class="pre">range_difference&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">std::ptrdiff_t</span></tt>, and
+<tt class="docutils literal"><span class="pre">range_pointer&lt;Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">add_pointer&lt;remove_reference&lt;Ref&gt;::type&gt;::type</span></tt>.
+As for <tt class="docutils literal"><span class="pre">const</span> <span class="pre">Range</span></tt>, see <a class="reference" href="#const-ranges">const Ranges</a>.</p>
+</div>
+<div class="section">
+<h1><a id="const-ranges" name="const-ranges">const Ranges</a></h1>
+<p><tt class="docutils literal"><span class="pre">range_reference&lt;const</span> <span class="pre">Range&gt;::type</span></tt> is defined by the following algorithm.
+Let <tt class="docutils literal"><span class="pre">Range</span></tt> be any type listed above and <tt class="docutils literal"><span class="pre">ReF</span></tt> be the same as <tt class="docutils literal"><span class="pre">range_reference&lt;Range&gt;::type</span></tt>.</p>
+<pre class="literal-block">
+if (Range is CObArray || Range is CObList)
+    return CObject const * &amp;
+else if (Range is CPtrArray || Range is CPtrList)
+    return void const * &amp;
+else if (there is a type X such that X&amp; is the same as ReF)
+    return X const &amp;
+else if (there is a type X such that X* const is the same as ReF)
+    return X const * const
+else
+    return ReF
+</pre>
+<p>Other <a class="reference" href="../index.html">Boost.Range</a> metafunctions are defined by the following.
+<tt class="docutils literal"><span class="pre">range_value&lt;const</span> <span class="pre">Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">range_value&lt;Range&gt;::type</span></tt>,
+<tt class="docutils literal"><span class="pre">range_difference&lt;const</span> <span class="pre">Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">std::ptrdiff_t</span></tt>, and
+<tt class="docutils literal"><span class="pre">range_pointer&lt;const</span> <span class="pre">Range&gt;::type</span></tt> is the same as <tt class="docutils literal"><span class="pre">add_pointer&lt;remove_reference&lt;range_reference&lt;const</span> <span class="pre">Range&gt;::type&gt;::type&gt;::type</span></tt>.</p>
+</div>
+<div class="section">
+<h1><a id="references" name="references">References</a></h1>
+<ul class="simple">
+<li><a class="reference" href="../index.html">Boost.Range</a></li>
+<li><a class="reference" href="http://msdn2.microsoft.com/en-us/library/942860sh.aspx">MFC Collections</a></li>
+<li><a class="reference" href="http://msdn2.microsoft.com/en-US/library/15e672bd.aspx">ATL Collection Classes</a></li>
+</ul>
+</div>
+</div>
+</body>
+</html>

doc/mfc_atl.rst

@@ -0,0 +1,232 @@
+
+++++++++++++++++++++++++++++++++
+ |Boost| Range MFC/ATL Extension
+++++++++++++++++++++++++++++++++
+
+.. |Boost| image:: http://www.boost.org/libs/ptr_container/doc/boost.png
+
+
+
+:Author:        Shunsuke Sogame
+:Contact:       mb2act@yahoo.co.jp
+:date:          26th of May 2006
+:copyright:     Shunsuke Sogame 2005-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0 (see LICENSE_1_0.txt__).
+
+__ http://www.boost.org/LICENSE_1_0.txt
+
+
+
+========
+Overview
+========
+
+Boost.Range MFC/ATL Extension provides `Boost.Range`_ support for MFC/ATL collection and string types.
+
+
+.. parsed-literal::
+
+        CTypedPtrArray<CPtrArray, CList<CString> \*> myArray;
+        ...
+        BOOST_FOREACH (CList<CString> \*theList, myArray)
+        {
+            BOOST_FOREACH (CString& str, \*theList)
+            {
+                boost::to_upper(str);
+                std::sort(boost::begin(str), boost::end(str));
+                ...
+            }
+        }
+
+
+
+* `Requirements`_
+* `MFC Ranges`_
+* `ATL Ranges`_
+* `const Ranges`_
+* `References`_
+
+
+
+============
+Requirements
+============
+
+- `Boost C++ Libraries Version 1.34.0`__ or later (no compilation required)
+- Visual C++ 7.1 or Visual C++ 8.0
+
+__ Boost_
+
+
+
+==========
+MFC Ranges
+==========
+
+If the ``<boost/range/mfc.hpp>`` is included before or after `Boost.Range`_ headers,
+the MFC collections and strings become models of Range.
+The table below lists the Traversal Category and ``range_reference`` of MFC ranges.
+
+
+============================= ================== =======================================
+``Range``                     Traversal Category ``range_reference<Range>::type``
+============================= ================== =======================================
+``CArray<T,A>``               Random Access      ``T&``
+----------------------------- ------------------ ---------------------------------------
+``CList<T,A>``                Bidirectional      ``T&``
+----------------------------- ------------------ ---------------------------------------
+``CMap<K,AK,M,AM>``           Forward            ``Range::CPair&``
+----------------------------- ------------------ ---------------------------------------
+``CTypedPtrArray<B,T*>``      Random Access      ``T* const``
+----------------------------- ------------------ ---------------------------------------
+``CTypedPtrList<B,T*>``       Bidirectional      ``T* const``
+----------------------------- ------------------ ---------------------------------------
+``CTypedPtrMap<B,T*,V*>``     Forward            ``std::pair<T*,V*> const``
+----------------------------- ------------------ ---------------------------------------
+``CByteArray``                Random Access      ``BYTE&``
+----------------------------- ------------------ ---------------------------------------
+``CDWordArray``               Random Access      ``DWORD&``
+----------------------------- ------------------ ---------------------------------------
+``CObArray``                  Random Access      ``CObject* &``
+----------------------------- ------------------ ---------------------------------------
+``CPtrArray``                 Random Access      ``void* &``
+----------------------------- ------------------ ---------------------------------------
+``CStringArray``              Random Access      ``CString&``
+----------------------------- ------------------ ---------------------------------------
+``CUIntArray``                Random Access      ``UINT&``
+----------------------------- ------------------ ---------------------------------------
+``CWordArray``                Random Access      ``WORD&``
+----------------------------- ------------------ ---------------------------------------
+``CObList``                   Bidirectional      ``CObject* &``
+----------------------------- ------------------ ---------------------------------------
+``CPtrList``                  Bidirectional      ``void* &``
+----------------------------- ------------------ ---------------------------------------
+``CStringList``               Bidirectional      ``CString&``
+----------------------------- ------------------ ---------------------------------------
+``CMapPtrToWord``             Forward            ``std::pair<void*,WORD> const``
+----------------------------- ------------------ ---------------------------------------
+``CMapPtrToPtr``              Forward            ``std::pair<void*,void*> const``
+----------------------------- ------------------ ---------------------------------------
+``CMapStringToOb``            Forward            ``std::pair<String,CObject*> const``
+----------------------------- ------------------ ---------------------------------------
+``CMapStringToString``        Forward            ``Range::CPair&``
+----------------------------- ------------------ ---------------------------------------
+``CMapWordToOb``              Forward            ``std::pair<WORD,CObject*> const``
+----------------------------- ------------------ ---------------------------------------
+``CMapWordToPtr``             Forward            ``std::pair<WORD,void*> const``
+============================= ================== =======================================
+
+
+Other `Boost.Range`_ metafunctions are defined by the following.
+Let ``Range`` be any type listed above and ``ReF`` be the same as ``range_reference<Range>::type``.
+``range_value<Range>::type`` is the same as ``remove_reference<remove_const<Ref>::type>::type``,
+``range_difference<Range>::type`` is the same as ``std::ptrdiff_t``, and
+``range_pointer<Range>::type`` is the same as ``add_pointer<remove_reference<Ref>::type>::type``.
+As for ``const Range``, see `const Ranges`_.
+
+
+
+==========
+ATL Ranges
+==========
+
+If the ``<boost/range/atl.hpp>`` is included before or after `Boost.Range`_ headers,
+the ATL collections and strings become models of Range.
+The table below lists the Traversal Category and ``range_reference`` of ATL ranges.
+
+
+============================= ================== =======================================
+``Range``                     Traversal Category ``range_reference<Range>::type``
+============================= ================== =======================================
+``CAtlArray<E,ET>``           Random Access      ``E&``
+----------------------------- ------------------ ---------------------------------------
+``CAutoPtrArray<E>``          Random Access      ``E&``
+----------------------------- ------------------ ---------------------------------------
+``CInterfaceArray<I,pi>``     Random Access      ``CComQIPtr<I,pi>&``
+----------------------------- ------------------ ---------------------------------------
+``CAtlList<E,ET>``            Bidirectional      ``E&``
+----------------------------- ------------------ ---------------------------------------
+``CAutoPtrList<E>``           Bidirectional      ``E&``
+----------------------------- ------------------ ---------------------------------------
+``CHeapPtrList<E,A>``         Bidirectional      ``E&``
+----------------------------- ------------------ ---------------------------------------
+``CInterfaceList<I,pi>``      Bidirectional      ``CComQIPtr<I,pi>&``
+----------------------------- ------------------ ---------------------------------------
+``CAtlMap<K,V,KT,VT>``        Forward            ``Range::CPair&``
+----------------------------- ------------------ ---------------------------------------
+``CRBTree<K,V,KT,VT>``        Bidirectional      ``Range::CPair&``
+----------------------------- ------------------ ---------------------------------------
+``CRBMap<K,V,KT,VT>``         Bidirectional      ``Range::CPair&``
+----------------------------- ------------------ ---------------------------------------
+``CRBMultiMap<K,V,KT,VT>``    Bidirectional      ``Range::CPair&``
+----------------------------- ------------------ ---------------------------------------
+``CSimpleStringT<B,b>``       Random Access      ``B&``
+----------------------------- ------------------ ---------------------------------------
+``CStringT<B,ST>``            Random Access      ``B&``
+----------------------------- ------------------ ---------------------------------------
+``CFixedStringT<S,n>``        Random Access      ``range_reference<S>::type``
+----------------------------- ------------------ ---------------------------------------
+``CStringT<B,ST>``            Random Access      ``B&``
+----------------------------- ------------------ ---------------------------------------
+``CComBSTR``                  Random Access      ``OLECHAR&``
+----------------------------- ------------------ ---------------------------------------
+``CSimpleArray<T,TE>``        Random Access      ``T&``
+============================= ================== =======================================
+
+
+Other `Boost.Range`_ metafunctions are defined by the following.
+Let ``Range`` be any type listed above and ``ReF`` be the same as ``range_reference<Range>::type``.
+``range_value<Range>::type`` is the same as ``remove_reference<Ref>::type``,
+``range_difference<Range>::type`` is the same as ``std::ptrdiff_t``, and
+``range_pointer<Range>::type`` is the same as ``add_pointer<remove_reference<Ref>::type>::type``.
+As for ``const Range``, see `const Ranges`_.
+
+
+
+============
+const Ranges
+============
+
+``range_reference<const Range>::type`` is defined by the following algorithm.
+Let ``Range`` be any type listed above and ``ReF`` be the same as ``range_reference<Range>::type``.
+
+
+.. parsed-literal::
+
+    if (Range is CObArray || Range is CObList)
+        return CObject const \* &
+    else if (Range is CPtrArray || Range is CPtrList)
+        return void const \* &
+    else if (there is a type X such that X& is the same as ReF)
+        return X const &
+    else if (there is a type X such that X* const is the same as ReF)
+        return X const \* const
+    else
+        return ReF
+
+
+Other `Boost.Range`_ metafunctions are defined by the following.
+``range_value<const Range>::type`` is the same as ``range_value<Range>::type``,
+``range_difference<const Range>::type`` is the same as ``std::ptrdiff_t``, and
+``range_pointer<const Range>::type`` is the same as ``add_pointer<remove_reference<range_reference<const Range>::type>::type>::type``.
+
+
+
+==========
+References
+==========
+- `Boost.Range`_
+- `MFC Collections`__
+- `ATL Collection Classes`__
+
+__ http://msdn2.microsoft.com/en-us/library/942860sh.aspx
+__ http://msdn2.microsoft.com/en-US/library/15e672bd.aspx
+
+
+
+.. _Boost C++ Libraries: http://www.boost.org/
+.. _Boost: `Boost C++ Libraries`_
+.. _Boost.Range: ../index.html
+.. _forward: range.html#forward_range
+.. _bidirectional: range.html#forward_range
+.. _random access: range.html#random_access_range
+

doc/portability.html

@@ -36,7 +36,7 @@ href="http://boost.sourceforge.net/regression-logs/developer/range.html">here</a
     <p  >
     Notice also that some compilers cannot do function template ordering properly. 
     In that case one must rely of <a
-      href="boost_range.html#range_result_iterator"><code >range_result_iterator</code></a> 
+      href="boost_range.html#range_iterator"><code >range_iterator</code></a> 
       and a single function definition instead of overloaded versions for const and 
       non-const arguments.
 
@@ -75,7 +75,7 @@ href="http://boost.sourceforge.net/regression-logs/developer/range.html">here</a
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
     </p>
 
     <br>

doc/range.html

@@ -50,7 +50,7 @@
                Range provides iterators for accessing a half-open range
 <code>[first,one_past_last)</code> of elements and provides
                information about the number of elements in the Range.  However, a Range has
-               fewer requirements than a Container.
+               <i>much</i> fewer requirements than a Container.
               </p>
               <p>
                The motivation for the Range concept is
@@ -78,9 +78,9 @@
     The operations that can be performed on a Range is dependent on the
     <a href="../../iterator/doc/new-iter-concepts.html#iterator-traversal-concepts-lib-iterator-traversal">traversal
 category</a> of the underlying iterator type. Therefore
-    the range concepts are named to reflect which traversal category its
-    iterators support. See also <a href="style.html">terminology and style guidelines.</a>
-    for more information about naming of ranges.</p>
+    the range concepts are named to reflect which traversal category their 
+    iterators support. See also <a href="style.html">terminology and style 
+    guidelines.</a> for more information about naming of ranges.</p>
 
     <p> The concepts described below specifies associated types as
 <a href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a> and all
@@ -118,11 +118,7 @@ Single Pass Iterator</a>
     <h3>Associated types</h3>
 
     <table border="1" cellpadding="5">
-        <TR>
-            <TD VAlign="top">Value type</TD>
-            <TD VAlign="top"><code>boost::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>boost::range_iterator&lt;X>::type</code></TD>
@@ -132,7 +128,7 @@ Single Pass Iterator</a>
         </TR>
         <TR>
             <TD VAlign="top">Const iterator type</TD>
-            <TD VAlign="top"><code>boost::range_const_iterator&lt;X>::type</code></TD>
+            <TD VAlign="top"><code>boost::range_iterator&lt;const 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>
@@ -161,20 +157,16 @@ Single Pass Iterator</a>
             <TD VAlign="top">Beginning of range</TD>
             <TD VAlign="top"><code>boost::begin(a)</code></TD>
             <TD VAlign="top"><code>boost::range_iterator&lt;X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_const_iterator&lt;X>::type</code>
+<code>a</code> is mutable, <code>boost::range_iterator&lt;const X>::type</code>
 otherwise</TD> </TR>
         <TR>
             <TD VAlign="top">End of range</TD>
             <TD VAlign="top"><code>boost::end(a)</code></TD>
             <TD VAlign="top"><code>boost::range_iterator&lt;X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_const_iterator&lt;X>::type</code>
+<code>a</code> is mutable, <code>boost::range_iterator&lt;const X>::type</code>
 otherwise</TD>
         </TR>
-        <tr>
-            <TD VAlign="top">Is range empty?</TD>
-            <TD VAlign="top"><code>boost::empty(a)</code></TD>
-            <TD VAlign="top">Convertible to <code>bool</code></TD>
-        </TR>
+
     </table>
     <h3>Expression semantics</h3>
 
@@ -188,7 +180,7 @@ otherwise</TD>
             <TD VAlign="top"><code>boost::begin(a)</code></TD>
             <TD VAlign="top">Returns an iterator pointing to the first element in the Range.</TD>
             <TD VAlign="top"><code>boost::begin(a)</code> is either dereferenceable or past-the-end. 
-            It is past-the-end if and only if <code>boost::size(a) == 0</code>.</TD>
+            It is past-the-end if and only if <code>boost::distance(a) == 0</code>.</TD>
         </TR>
         <TR>
             <TD VAlign="top"><code>boost::end(a)</code></TD>
@@ -196,19 +188,14 @@ otherwise</TD>
             Range.</TD>
             <TD VAlign="top"><code>boost::end(a)</code> is past-the-end.</TD>
         </TR>
-        <TR>
-            <TD VAlign="top"><code>boost::empty(a)</code></TD>
-            <TD VAlign="top">Equivalent to <code>boost::begin(a) == boost::end(a)</code>. (But possibly 
-            faster.)</TD>
-            <TD VAlign="top">&nbsp;-&nbsp;</TD>
-        </TR>
+ 
     </table>
 
     <h3>Complexity guarantees</h3>
 
-    All three functions are at most amortized linear time. For most practical 
-    purposes, one can expect <code>boost::begin(a)</code>, <code>boost::end(a)</code> and <code>boost::empty(a)</code> 
-    to be amortized constant time.
+    <code>boost::end(a)</code> is at most amortized linear time, <code>boost::begin(a)</code> is
+                                         amortized constant time. For most practical 
+        purposes, one can expect both to be amortized constant time.
 
     <h3>Invariants</h3>
     <Table border>
@@ -227,14 +214,17 @@ otherwise</TD>
 
 
     <h3>See also</h3> 
-            <p>
-            <A href="http://www.sgi.com/Technology/STL/Container.html">Container</A>
-            </p>
-            <p> <a href="boost_range.html#boost::range_value">implementation of
+                                                                     <p><a 
+                                                                     href="boost_range.html#minimal_interface">Extending the library for UDTs </a></p>
+            <p> <a href="boost_range.html#boost::rang_difference">Implementation of
                    metafunctions </a></p>
 
-            <p> <a href="boost_range.html#begin">implementation of 
+            <p> <a href="boost_range.html#begin">Implementation of 
                    functions </a></p>
+                        <p>
+            <A href="http://www.sgi.com/Technology/STL/Container.html">Container</A>
+            </p>
+       
 
     <hr>
     <a  name=forward_range><h2>Forward Range</h2>
@@ -261,76 +251,8 @@ href="../../iterator/doc/new-iter-concepts.html#forward-traversal-iterators-lib-
     <h3>Refinement of</h3> <a href="#single_pass_range">Single Pass 
 Range</a>
             
-    <h3>Associated types</h3>
-
-    <table cellpadding="5" border="1">
-        <TR>
-            <TD VAlign="top">Distance type</TD>
-            <TD VAlign="top"><code>boost::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>boost::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>
-    </table>
-
-    <h3>Valid expressions</h3>
-
-    <table border="1" cellpadding="5">
-        <tr>
-            <th>Name</th>
-            <th>Expression</th>
-            <th>Return type</th>
-        </tr>
-        <TR>
-            <TD VAlign="top">Size of range</TD>
-            <TD VAlign="top"><code>boost::size(a)</code></TD>
-            <TD VAlign="top"><code>boost::range_size&lt;X>::type</code></TD>
-        </TR>
-    </table>
-
-    <h3>Expression semantics </h3>
-
-    <table border="1" cellpadding="5">
-        <TR>
-            <TH>Expression</TH>
-            <TH>Semantics</TH>
-            <TH>Postcondition</TH>
-        </TR>
-        <tr>
-            <TD VAlign="top"><code>boost::size(a)</code></TD>
-            <TD VAlign="top">Returns the size of the Range, that is, its number 
-of elements. Note <code>boost::size(a) == 0u</code> is equivalent to 
-<code>boost::empty(a).</code></TD>
-            <TD VAlign="top"><code>boost::size(a) &gt;= 0</TD>
-        </TR>
-    </table>
-
-   <h3>Complexity guarantees</h3>
-
-    <p><code>boost::size(a)</code> is at most amortized linear time.</p>
-
-    <h3>Invariants</h3>
-    <p>
-    <Table border="1" cellpadding="5">
-        <TR>
-            <TD VAlign="top">Range size</TD>
-            <TD VAlign="top"><code>boost::size(a)</code> is equal to the distance from <code>boost::begin(a)</code>
-            to <code>boost::end(a)</code>.</TD> </table>
-    </p>
-    
-        <h3>See also</h3> 
-            <p> <a href="boost_range.html#boost::range_difference">implementation of
-                   metafunctions </a></p>
-
-            <p> <a href="boost_range.html#size">implementation of 
-                   functions </a></p>
-
+  </p>
+  
     <hr>
 
     <a name="bidirectional_range"><h2>Bidirectional Range</h2>
@@ -356,83 +278,8 @@ s-lib-bidirectional-traversal-iterators">Bidirectional Traversal Iterator.</a>
       
     <h3>Refinement of</h3> <a href="#forward_range">Forward Range</a>
 
-    <h3>Associated types</h3>
-
-    <Table border>
-        <TR>
-            <TD VAlign="top">Reverse Iterator type</TD>
-            <TD VAlign="top"><code>boost::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 
-            type must exist. </TD>
-        </TR>
-        <TR>
-            <TD VAlign="top">Const reverse iterator type</TD>
-            <TD 
-VAlign="top"><code>boost::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>
-    </table>
-
-
-    <h3>Valid expressions</h3>
-
-    <Table border>
-        <TR>
-            <TH>Name</TH>
-            <TH>Expression</TH>
-            <TH>Return type</TH>
-            <TH>Semantics</TH>
-        </TR>
-        <TR>
-            <TD VAlign="top">Beginning of range</TD>
-            <TD VAlign="top"><code>boost::rbegin(a)</code></TD>
-            <TD VAlign="top"><code>boost::range_reverse_iterator&lt;X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_const_reverse_iterator&lt;X>::type</code>
-otherwise.</TD>
-            <TD VAlign="top">Equivalent to 
-<code>boost::range_reverse_iterator&lt;X>::type(boost::end(a))</code>.</TD> </TR>
-        <TR>
-            <TD VAlign="top">End of range</TD>
-            <TD VAlign="top"><code>boost::rend(a)</code></TD>
-            <TD VAlign="top"><code>boost::range_reverse_iterator&lt;X>::type</code> if
-<code>a</code> is mutable, <code>boost::range_const_reverse_iterator&lt;X>::type</code>
-otherwise.</TD>
-            <TD VAlign="top">Equivalent to 
-<code>boost::range_reverse_iterator&lt;X>::type(boost::begin(a))</code>.</TD> </tr>
-
-    </table>
-
-    <h3>Complexity guarantees</h3>
-
-    <code>boost::rbegin(a)</code> has the same complexity as <code>boost::end(a)</code> and <code>boost::rend(a)</code> 
-    has the same complexity as <code>boost::begin(a)</code> from <a
-         href="#forward_range">Forward Range</a>.
-
-    <h3>Invariants</h3>
-    <p>
-    <Table border="1" cellpadding="5">
-        <TR>
-            <TD VAlign="top">Valid reverse range</TD>
-            <TD VAlign="top">For any Bidirectional Range <code>a</code>, <code>[boost::rbegin(a),boost::rend(a))</code> 
-            is a valid range, that is, <code>boost::rend(a)</code> is reachable from <code>boost::rbegin(a)</code> 
-            in a finite number of increments.</TD>
-        </TR>
-        <TR>
-            <TD VAlign="top">Completeness</TD>
-            <TD VAlign="top">An algorithm that iterates through the range <code>[boost::rbegin(a),boost::rend(a))</code>
-            will pass through every element of <code>a</code>.</TD>
-        </tr>
-    </table>
-   </p>
-   
-           <h3>See also</h3> 
-            <p> <a href="boost_range.html#boost::range_reverse_iterator">implementation of metafunctions </a></p>
-
-            <p> <a href="boost_range.html#rbegin">implementation of 
-                   functions </a></p>
+  
+</p>
 
     <hr>
 
@@ -455,7 +302,7 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator
     <a name=concept_checking><h2>Concept Checking</h2>
 
     Each of the range concepts has a corresponding concept checking
-    class in the file boost/range/concepts.hpp. These classes may be
+    class in the file <code><boost/range/concepts.hpp></codE>. These classes may be
     used in conjunction with the <a
     href="../../concept_check/concept_check.htm">Boost Concept
     Check</a> library to insure that the type of a template parameter
@@ -529,8 +376,8 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator
             <TD><A HREF=http://www.boost.org/people/jeremy_siek.htm>Jeremy Siek</A>
         </TR>
         <tr >
-            <TD nowrap>Copyright &copy 2004</TD>
-            <TD>Thorsten Ottosen. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+            <TD nowrap>Copyright &copy 2004-2007</TD>
+            <TD>Thorsten Ottosen.
     </TABLE>
 
     <br>

doc/style.css

@@ -1,10 +1,3 @@
-/*
-#//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
-#//  distribution is subject to the Boost Software License, Version
-#//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-#//  http://www.boost.org/LICENSE_1_0.txt)
-*/
-
 pre{
   BORDER-RIGHT: gray 1pt solid;
   PADDING-RIGHT: 2pt;

doc/style.html

@@ -104,7 +104,7 @@
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2004
     </p>
 
     <br>

doc/utility_class.html

@@ -59,19 +59,16 @@ corresponding <code>const_iterator</code> is. </p>
     <p>
     If the template argument is not a model of Forward Traversal Iterator, one can 
     still use a subset of the interface. In particular, <code>size()</code> requires 
-    Forward Traversal Iterators whereas <code>empty()</code> only requires Single 
+    Random Access Iterators whereas <code>empty()</code> only requires Single 
     Pass Iterators.
     </p>
 
     <p>
     Recall that many default constructed iterators 
     are <i>singular</i> and hence can only be assigned, but not compared or 
-    incremented or anything. However, if one creates a default constructed 
-    <code>iterator_range</code>, then one
-    can still call all its member functions. This means that the 
-    <code>iterator_range</code> will still be usable in many contexts even 
-    though the iterators underneath are not. 
-    </p>
+    incremented or anything. Likewise, if one creates a default constructed 
+    <code>iterator_range</code>, then one have to be careful about not doing
+    anything besides copying.    </p>
     
     <h3>Synopsis</h3>
 
@@ -82,12 +79,10 @@ corresponding <code>const_iterator</code> is. </p>
     </span><span class=keyword>class </span><span class=identifier>iterator_range
     </span><span class=special>{
     </span><span class=keyword>public</span><span class=special>: </span><span class=comment>// Forward Range types
-        </span><span class=keyword>typedef </span><span class=special>...                        </span><span class=identifier>value_type</span><span class=special>;
-        </span><span class=keyword>typedef </span><span class=special>...                        </span><span class=identifier>difference_type</span><span class=special>;
-        </span><span class=keyword>typedef </span><span class=special>...                        </span><span class=identifier>size_type</span><span class=special>;
-        </span><span class=keyword>typedef </span><span class=identifier>ForwardTraversalIterator   </span><span class=identifier>iterator</span><span class=special>;
-        </span><span class=keyword>typedef </span><span class=identifier>ForwardTraversalIterator   </span><span class=identifier>const_iterator</span><span class=special>;
-
+        </span><span class=keyword>typedef </span><span class=identifier>ForwardTraversalIterator             </span><span class=identifier>iterator</span><span class=special>;
+        </span><span class=keyword>typedef </span><span class=identifier>ForwardTraversalIterator             </span><span class=identifier>const_iterator</span><span class=special>;</span>
+        <span class=keyword>typedef </span><span class=identifier>iterator_difference</span><span class=special>&lt;</span><span class=identifier>iterator</span><span class=special>&gt;::</span><span class=identifier>type  </span><span class=identifier>difference_type</span><span class=special>;</span>
+ 
     </span><span class=keyword>public</span><span class=special>: </span><span class=comment>// construction, assignment
         </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator2 </span><span class=special>&gt;
         </span><span class=identifier>iterator_range</span><span class=special>( </span><span class=identifier>ForwardTraversalIterator2 </span><span class=identifier>Begin</span><span class=special>, </span><span class=identifier>ForwardTraversalIterator2 </span><span class=identifier>End </span><span class=special>);
@@ -105,22 +100,24 @@ corresponding <code>const_iterator</code> is. </p>
         </span><span class=identifier>iterator_range</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>=( </span><span class=keyword>const </span><span class=identifier>ForwardRange</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
     
     </span><span class=keyword>public</span><span class=special>: </span><span class=comment>// Forward Range functions
-        </span><span class=identifier>iterator  </span><span class=identifier>begin</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
-        </span><span class=identifier>iterator  </span><span class=identifier>end</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
-        </span><span class=identifier>size_type </span><span class=identifier>size</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
-        </span><span class=keyword>bool      </span><span class=identifier>empty</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
+        </span><span class=identifier>iterator        </span><span class=identifier>begin</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
+        </span><span class=identifier>iterator        </span><span class=identifier>end</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
+        </span><span class=identifier>difference_type </span><span class=identifier>size</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
+        </span><span class=keyword>bool            </span><span class=identifier>empty</span><span class=special>() </span><span class=keyword>const</span><span class=special>;
         
     </span><span class=keyword>public</span><span class=special>: </span><span class=comment>// convenience
-        </span><span class=keyword>operator    </span><a href="#unspecified_bool"><span class=identifier>unspecified_bool_type</span></a><span class=special>() </span><span class=keyword>const</span><span class=special>;
-    </span>    <span class=keyword>bool</span>        <span 
+        </span><span class=keyword>operator        </span><a href="#unspecified_bool"><span class=identifier>unspecified_bool_type</span></a><span class=special>() </span><span class=keyword>const</span><span class=special>;
+    </span>    <span class=keyword>bool</span>            <span 
 class=identifier><a href="#equal">equal</a></span><span
-class=special>( </span><span class=keyword>const <span 
-class=identifier>iterator_range</span><span class=special>& ) </span><span 
+class=special>( </span><span class=keyword>const</span> <span class=identifier>iterator_range</span><span class=special>& ) </span><span 
 class=keyword>const;</span>
-        <span class=identifier>value_type</span><span class=special>&amp; </span><span class=identifier>front</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
-        <span class=identifier>value_type</span><span class=special>&amp; </span><span class=identifier>back</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
+        <span class=identifier>reference       </span><span class=identifier>front</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
+        <span class=identifier>reference       </span><span class=identifier>back</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
+        <span class=identifier>iterator_range</span><span class=special>&amp;</span> <span class=identifier>advance_begin</span><span class=special>(</span> <span class=identifier>difference_type</span> <span class=identifier>n</span> <span class=special>);</span>
+        <span class=identifier>iterator_range</span><span class=special>&amp;</span> <span class=identifier>advance_end</span><span class=special>(</span> <span class=identifier>difference_type</span> <span class=identifier>n</span> <span class=special>);</span>
         <span class=comment>// for Random Access Range only: </span>
-        <span class=identifier>value_type</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>size_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
+        <span class=identifier>reference       </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
+        <span class=identifier>value_type</span>      <span class=keyword>operator</span><span class=special>()( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
     </span><span class=special>};
     
     </span><span class=comment>// stream output
@@ -173,11 +170,11 @@ class=keyword>const;</span>
                          </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>End </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=identifier>iterator_range</span><span class=special>&lt; </span><span class=keyword>typename </span><span class=identifier>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=identifier>iterator_range</span><span class=special>&lt; </span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
     </span><span class=identifier>make_iterator_range</span><span class=special>( </span><span class=identifier>ForwardRange</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>ForwardRange </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>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=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>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
     </span><span class=identifier>make_iterator_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardRange</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>Range </span><span class=special>&gt;</span>
@@ -187,7 +184,7 @@ class=keyword>const;</span>
                          </span><span class=keyword>typename </span><span class=identifier>range_difference</span><span class=special>&lt;</span><span class=identifier>Range</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>advance_end </span><span class=special>);
     </span>
     <span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Range </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_const_iterator</span><span class=special>&lt;</span><span class=identifier>Range</span><span class=special>&gt;::</span><span class=identifier>type </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>Range</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;</span>
     <span class=identifier>make_iterator_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>Range</span><span class=special>&amp; </span><span class=identifier>r</span><span class=special>, 
                          </span><span class=keyword>typename </span><span class=identifier>range_difference</span><span class=special>&lt;</span><span class=identifier>Range</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>advance_begin</span><span class=special>,
                          </span><span class=keyword>typename </span><span class=identifier>range_difference</span><span class=special>&lt;</span><span class=identifier>Range</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>advance_end </span><span class=special>);</span>
@@ -291,12 +288,14 @@ 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>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=keyword>class </span><span class=identifier>sub_range </span><span class=special>: </span><span class=keyword>public </span><span class=identifier>iterator_range</span><span class=special>&lt; </span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=identifier>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type </span><span class=special>&gt;
     </span><span class=special>{
     </span><span class=keyword>public</span><span class=special>: </span>
-        <span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>range_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>
-        <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>range_iterator</span><span class=special>&lt;</span><span class=identifier>ForwardRange</span><spanclass=special>&gt;::</span><span class=identifier>type </span><span class=identifier>iterator</span><span class=special>;</span>
+        <span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type  </span><span class=identifier>const_iterator</span><span class=special>;</span>
+        <span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>iterator_difference</span><span class=special>&lt;</span><span class=identifier>iterator</span><span class=special>&gt;::</span><span class=identifier>type       </span><span class=identifier>difference_type</span><span class=special>;</span>
     
+
     <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;
         </span><span class=identifier>sub_range</span><span class=special>( </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>Begin</span><span class=special>, </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>End </span><span class=special>);
@@ -305,7 +304,7 @@ class can propagate constness since it knows what a corresponding
         </span><span class=identifier>sub_range</span><span class=special>( </span><span class=identifier>ForwardRange2</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>ForwardRange2 </span><span class=special>&gt;
-        </span><span class=identifier>sub_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>Range2</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
+        </span><span class=identifier>sub_range</span><span class=special>( </span><span class=keyword>const </span><span class=identifier>ForwardRange2</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>ForwardRange2 </span><span class=special>&gt;
         </span><span class=identifier>sub_range</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>=( </span><span class=identifier>ForwardRange2</span><span class=special>&amp; </span><span class=identifier>r </span><span class=special>);
@@ -325,8 +324,8 @@ class can propagate constness since it knows what a corresponding
         <span class=identifier>value_type</span><span class=special>&amp;       </span><span class=identifier>back</span><span class=special>();</span>
         <span class=keyword>const </span><span class=identifier>value_type</span><span class=special>&amp; </span><span class=identifier>back</span><span class=special>() </span><span class=keyword>const</span><span class=special>;</span>
         <span class=comment>// for Random Access Range only: </span>
-        <span class=identifier>value_type</span><span class=special>&amp;       </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>size_type </span><span class=identifier>at </span><span class=special>);</span>
-        <span class=keyword>const </span><span class=identifier>value_type</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>size_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
+        <span class=identifier>value_type</span><span class=special>&amp;       </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>);</span>
+        <span class=keyword>const </span><span class=identifier>value_type</span><span class=special>&amp; </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
     
     <span class=keyword>public</span><span class=special>:
         </span><span class=comment>// rest of interface inherited from <a href=#iter_range><code>iterator_range</code></a>
@@ -344,15 +343,15 @@ store the result
     from this algorithm. Here is an example of how we can do it with and without
 <code>sub_range</code>
     <pre>
-    <span class=identifier>std</span><span class=special>::</span><span class=identifier>string </span><span class=identifier>str</span><span class=special>(</span><span class=string>&quot;hello&quot;</span><span class=special>);
-    </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>::</span><span class=identifier>iterator</span><span class=special>&gt; </span><span class=identifier>ir </span><span class=special>= </span><span class=identifier>find_first</span><span class=special>( </span><span class=identifier>str</span><span class=special>, </span><span class=string>&quot;ll&quot; </span><span class=special>);
-    </span><span class=identifier>sub_range</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&gt;               </span><span class=identifier>sub </span><span class=special>= </span><span class=identifier>find_first</span><span class=special>( </span><span class=identifier>str</span><span class=special>, </span><span class=string>&quot;ll&quot; </span><span class=special>);</span>
+    <span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span> <span class=identifier>str</span><span class=special>(</span><span class=string>&quot;hello&quot;</span><span class=special>);</span>
+    <span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>::</span><span class=identifier>iterator</span><span class=special>&gt;</span> <span class=identifier>ir</span> <span class=special>=</span> <span class=identifier>find_first</span><span class=special>(</span> <span class=identifier>str</span><span class=special>,</span> <span class=identifier>as_literal</span><span class=special>(</span><span class=string>&quot;ll&quot;</span><span class=special>)</span> <span class=special>);</span>
+    <span class=identifier>sub_range</span><span class=special>&lt;</span><span class=identifier>std</span><span class=special>::</span><span class=identifier>string</span><span class=special>&gt;</span>               <span class=identifier>sub</span> <span class=special>=</span> <span class=identifier>find_first</span><span class=special>(</span> <span class=identifier>str</span><span class=special>,</span> <span class=identifier>as_literal</span><span class=special>(</span><span class=string>&quot;ll&quot;</span><span class=special>)</span> <span class=special>);</span>
 </pre>
  </p>
 
 <hr>
   <p>
-    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
+    (C) Copyright Thorsten Ottosen 2003-2007
   </p>
 
   <br>