Branch for adding initializer list support (only in the unreleased gcc 4.4 at the moment).

[SVN r48931]

doc/Jamfile.v2

@@ -0,0 +1,32 @@
+#// Boost.Range library
+#//
+#//  Copyright Thorsten Ottosen 2003-2008. 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)
+#//
+#// For more information, see http://www.boost.org/libs/range/
+#//
+
+
+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,3 +1,13 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2008. 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)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
 #include <boost/range.hpp>
 #include <iterator>         // for std::iterator_traits, std::distance()
 

doc/examples.html

@@ -23,20 +23,16 @@
     <ul  >
         <li  >
             <a href="../test/string.cpp" target="_self" ><code  >string.cpp</code></a>
-        </li>
+      
         shows how to implement a container version of <code  >std::find()</code> that
         works with <code  >char[],wchar_t[],char*,wchar_t*.</code>
-        <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>
         <li  >
             <a href="../test/algorithm_example.cpp" target="_self" ><code  >algorithm_example.cpp</code></a>
 
-        </li>
+      
         shows the replace example from the introduction.
-        
+          </li>
         <li> <a href="../test/iterator_range.cpp">iterator_range.cpp</a>
         <li> <a href="../test/sub_range.cpp">sub_range.cpp</a>
         <li> <a href="../test/iterator_pair.cpp">iterator_pair.cpp</a>     
@@ -45,9 +41,16 @@
         <li> <a href="../test/array.cpp">array.cpp</a>     
     </ul>
 
+
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+    </p>
+
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
     </p>
 
     <br>

doc/faq.html

@@ -22,7 +22,7 @@
         <li  >
             <i>Why is there no difference between <code  >range_iterator&lt;C&gt;::type</code>
             and <code  >range_const_iterator&lt;C&gt;::type</code> for <code>std::pair&lt;iterator, iterator&gt;</code></i>.
-        </li>
+
         <p  >
         In general it is not possible nor desirable to find a corresponding <code  >const_iterator</code>.
         When it is possible to come up with one, the client might choose to construct a <code  >std::pair&lt;const_iterator,const_iterator&gt;</code>
@@ -33,7 +33,7 @@
         is somewhat more convenient than a <code>pair</code> and that a <a
         href="utility_class.html#sub_range"><code>sub_range</code></a> does
        propagate const-ness. </p>
-
+        </li>
         <li  >
             <i>Why is there not supplied more types or more functions?</i>
             <p  >
@@ -114,9 +114,16 @@ Cool indeed!
     </ol>
 
 
-    <hr>
+      <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+    </p>
+
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy
+      at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
     </p>
 
     <br>

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"
@@ -148,13 +167,20 @@
         </tr>
 
     </table>
-    <br
+    <br>
       </p>
 
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+    </p>
+
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy
+      at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
     </p>
 
     <br>

doc/history_ack.html

@@ -18,10 +18,10 @@
 
     <h2  >History and Acknowledgement</h2><a name="History" ></a>
     <p  >
-    The library have been under way for a long time. Dietmar K<>hl originally 
-    intended to submit an <code  >array_traits</code> class template which 
-    had most of the functionality present now, but only for arrays and standard 
-    containers. 
+    The library was under way for a long time. Dietmar K<>hl originally intended
+    to submit an <code  >array_traits</code> class template which had most of
+    the functionality present now, but only for arrays and standard containers.
+        I believe this was back in 2001 or 2002.
     </p>
     
     <p>
@@ -61,7 +61,14 @@ C++ standard: <blockquote>
     
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2006
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+    </p>
+
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy
+      at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
     </p>
 
     <br>

doc/intro.html

@@ -24,7 +24,7 @@
     to a somewhat clumsy use of the algorithms with redundant specification
     of container names. Therefore we would like to raise the abstraction level
     for algorithms so they specify their interface in terms of <a
-    href=range.html>Ranges</a> as much as possible.
+    href="range.html">Ranges</a> as much as possible.
     </p>
 
     <p>
@@ -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,13 @@ 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>
+    <p  > Below is 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 +78,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 +89,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>);
@@ -119,7 +108,7 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
     </span>
     <span class=identifier>my_vector</span><span class=special>.</span><span
 class=identifier>assign</span><span class=special>( </span><span class=identifier>values</span><span class=special>, </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>values </span><span class=special>) </span><span class=special>);</span>
-    </span><span class=keyword>typedef </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;::</span><span class=identifier>iterator </span><span class=identifier>iterator</span><span class=special>;
+    <span class=keyword>typedef </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;::</span><span class=identifier>iterator </span><span class=identifier>iterator</span><span class=special>;
     </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>pair</span><span class=special>&lt;</span><span class=identifier>iterator</span><span class=special>,</span><span class=identifier>iterator</span><span class=special>&gt;       </span><span class=identifier>my_view</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>my_vector </span><span class=special>),
                                                 </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>my_vector </span><span class=special>) </span><span class=special>+ </span><span class=identifier>N </span><span class=special>);
     </span><span class=keyword>char  </span><span class=identifier>str_val</span><span class=special>[] </span><span class=special>= </span><span class=string>&quot;a string&quot;</span><span class=special>;
@@ -146,7 +135,14 @@ Notice that we have to
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+    </p>
+
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy
+      at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
     </p>
 
     <br>

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

@@ -29,14 +29,13 @@ href="http://boost.sourceforge.net/regression-logs/developer/range.html">here</a
     template partial specialization. For non-conforming compilers there might be a 
     chance that it works anyway thanks to workarounds in the type traits library.
     </p>
-    <pp>
-    Visual C++ 6/7.0 has a limited support for arrays: as long as the arrays are 
-    of built-in type it should work.
+    <p> Visual C++ 6/7.0 has a limited support for arrays: as long as the arrays
+    are of built-in type it should work.
     </p>
     <p  >
     Notice also that some compilers cannot do function template ordering properly. 
-    In that case one must rely of <a
-      href="boost_range.html#range_result_iterator"><code >range_result_iterator</code></a> 
+    In that case one must rely on <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.
 
@@ -73,11 +72,18 @@ href="http://boost.sourceforge.net/regression-logs/developer/range.html">here</a
     </ol>
     </p>
 
-    <hr>
+     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
     </p>
 
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy
+      at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+    </p>>
+
     <br>
     <br>
     <br>

doc/range.html

@@ -1,3 +1,4 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
 <HTML>
 <!--
   -- Copyright (c) Jeremy Siek 2000
@@ -50,7 +51,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 +79,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
@@ -90,7 +91,7 @@ functions as free-standing functions to allow for a layer of indirection. </p>
 <code>boost</code></p>-->
 
     <hr>
-    <a name="single_pass_range">
+    <a name="single_pass_range"></a>
     <H2>Single Pass Range</H2>
 
     <h3>Notation</h3>
@@ -118,11 +119,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 +129,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 +158,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 +181,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 +189,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,17 +215,20 @@ 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>
+    <a name=forward_range></a><h2>Forward Range</h2>
 
     <h3>Notation</h3>
     <Table>
@@ -261,79 +252,11 @@ 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>
+    <a name="bidirectional_range"></a><h2>Bidirectional Range</h2>
 
     <h3>Notation</h3>
     <Table>
@@ -356,87 +279,13 @@ 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>
 
-    <a name=random_access_range><h2>Random Access Range</h2> <h3>Description</h3>
+    <a name=random_access_range></a><h2>Random Access Range</h2> 
+    <h3>Description</h3>
     <p>
     A range <code>X</code> where <code>boost::range_iterator&lt;X>::type</code> is a model
 of <a
@@ -452,10 +301,10 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator
 
     <hr>
 
-    <a name=concept_checking><h2>Concept Checking</h2>
+    <a name=concept_checking></a><h2>Concept Checking</h2>
 
     Each of the range concepts has a corresponding concept checking
-    class in the file boost/range/concepts.hpp. These classes may be
+    class in the file <code>&lt;boost/range/concepts.hpp&gt;</code>. These classes may be
     used in conjunction with the <a
     href="../../concept_check/concept_check.htm">Boost Concept
     Check</a> library to insure that the type of a template parameter
@@ -505,34 +354,16 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator
     <p> <a href="../../concept_check/concept_check.htm">Boost Concept Check library</a></p>
 
     <hr>
+    <p>
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+    </p>
 
-    <!--
-    <h3>Notes</h3>
-
-    
-    <P>
-    <A name="1">[1]</A>
-
-    The reference type does not have to be a real C++ reference. The requirements of 
-    the reference type is that it <i>behaves</i> like a real reference. Hence the 
-    reference type must be convertible to the value_type and assignment through
-
-    <br>
-    <br>
-    <HR>
-    <br>
--->
-
-    <TABLE>
-        <TR valign="top">
-            <TD nowrap>Copyright &copy 2000</TD>
-            <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.
-    </TABLE>
-
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy
+      at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+    </p>
     <br>
     <br>
     <br>

doc/style.css

@@ -1,3 +1,14 @@
+/*
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2008. 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)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+*/
 pre{
   BORDER-RIGHT: gray 1pt solid;
   PADDING-RIGHT: 2pt;

doc/style.html

@@ -53,7 +53,7 @@
                     <a href="range.html#bidirectional_range">Bidirectional Range</a> <li>
                     <a href="range.html#random_access_range">Random Access Range</a> </ul>
     </ul>
-    Notice how we have used the categories from the <a href=../../iterator/doc/new-iter-concepts.html>new 
+    Notice how we have used the categories from the <a href="../../iterator/doc/new-iter-concepts.html">new 
     style iterators</a>.
 
     <p>
@@ -104,9 +104,15 @@
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
     </p>
 
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy
+      at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+    </p>
     <br>
     <br>
     <br>

doc/upgrading.html

@@ -0,0 +1,79 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2//EN">
+
+<html>
+<head>
+    <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+    <title>Boost.Range Upgrading </title> <link rel="stylesheet" 
+    href="style.css" type="text/css">
+</head>
+
+    <body>
+
+    <table border="0" >
+        <tr>
+            <td ><img src="../../../boost.png" border="0" ></td>
+            <td ><h1 align="center">Boost.Range </h1></td>
+        </tr>
+    </table>
+
+    <h2  >Upgrading from Boost v. 1.34.*</h2><a name="v1.34" ></a>
+    <p  >
+    Boost v. 1.35 introduced some larger refactorings of the library:
+    </p>
+    <ul  >
+        <li>Direct support for character arrays was abandoned in favor of 
+            uniform treatment of all arrays. Instead string algorithms can use
+            the new function <a
+            href="boost_range.html#as_literal">as_literal()</a>.</li>
+        <li><a 
+            href="boost_range.html#size">boost::size()</a> now requires a Random
+            Access Range. The old behavior is provided as <a
+            href="boost_range.html#distance">boost::distance()</a> </li>   
+        <li> <code>range_size&lt;T&gt;::type</code> has been completely removed 
+            in favor of <code>range_difference&lt;T&gt;::type</code>
+            <li>
+                <code>boost_range_begin()</code> and <code>boost_range_end()</code>
+                    have been renamed <code>range_begin()</code> and <code>range_begin()</code>, respectively.</li>
+
+
+            <li><code>range_result_iterator&lt;T&gt;::type</code> and
+            <code>range_reverse_result_iterator&lt;T&gt;::type</code> are have
+            been renamed 
+            <code>range_iterator&lt;T&gt;::type</code>    and 
+                <code>range_reverse_iterator&lt;T&gt;::type</code>. 
+            </li>     
+        <li>The procedure that makes a custom type work with the library 
+            has been greatly simplified. See <a 
+            href="boost_range.html#minimal_interface">extending the library </a> 
+            for details.</li>
+    </ul>
+
+
+    <hr>
+    <p>
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+    </p>
+
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+    </p>
+
+    <br>
+    <br>
+    <br>
+    <br>
+    <br>
+    <br>
+    <br>
+    <br>
+    <br>
+    <br>
+    <br>
+    <br>
+
+
+    </body>
+</html>
+

doc/utility_class.html

@@ -27,17 +27,17 @@
 
     <ul>
         <li>
-            Class <a href=#iter_range><code>iterator_range</code></a>
+            Class <a href="#iter_range"><code>iterator_range</code></a>
         <li>
-            Class <a href=#sub_range><code>sub_range</code></a>
-    </ul>
+            Class <a href="#sub_range"><code>sub_range</code></a>
     </ul>
 
-    The <code>iterator_range</code> class is templated on an 
-    <a href="../../iterator/doc/new-iter-concepts.html#forward-traversal-iterators-lib-forward-traversal-iterators">Forward 
+    The <code>iterator_range</code> class is templated on a <a
+    href="../../iterator/doc/new-iter-concepts.html#forward-traversal-iterators-lib-forward-traversal-iterators">Forward 
     Traversal Iterator</a> and should be used whenever fairly general code is needed. 
-    The <code>sub_range</code> class is templated on an <a href="range.html#forward_range">Forward
-    Range</a> and it is less general, but a bit easier to use since its template 
+    The <code>sub_range</code> class is templated on a <a 
+    href="range.html#forward_range">Forward Range</a> and it is less general, 
+    but a bit easier to use since its template 
     argument is easier to specify. The biggest difference is, however, that a 
     <code>sub_range</code> can propagate constness because it knows what a 
 corresponding <code>const_iterator</code> is. </p>
@@ -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,13 +79,11 @@ 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>public</span><span class=special>: </span><span class=comment>// construction, assignment
+        </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 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,23 +100,25 @@ 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>&amp; ) </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><span class=special>};
+        <span class=identifier>reference       </span><span class=keyword>operator</span><span class=special>[]( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
+        <span class=identifier>value_type</span>      <span class=keyword>operator</span><span class=special>()( </span><span class=identifier>difference_type </span><span class=identifier>at </span><span class=special>) </span><span class=keyword>const</span><span class=special>;</span>
+    <span class=special>};
     
     </span><span class=comment>// stream output
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>Traits </span><span class=special>&gt;
@@ -166,18 +163,18 @@ class=keyword>const;</span>
     </span><span class=keyword>bool </span><span class=keyword>operator</span><span class=special>&lt;( </span><span class=keyword>const </span><span class=identifier>ForwardRange</span><span class=special>&amp; </span><span class=identifier>l</span><span class=special>,
                     </span><span class=keyword>const </span><span class=identifier>iterator_range</span><span class=special>&lt;</span><span class=identifier>ForwardTraversalIterator</span><span class=special>&gt;&amp; </span><span class=identifier>r </span><span class=special>);</span>
  
-    </span><span class=comment>// external construction
+    <span class=comment>// external construction
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardTraversalIterator </span><span class=special>&gt;
     </span><span class=identifier>iterator_range</span><span class=special>&lt; </span><span class=identifier>ForwardTraversalIterator </span><span class=special>&gt;
     </span><span class=identifier>make_iterator_range</span><span class=special>( </span><span class=identifier>ForwardTraversalIterator </span><span class=identifier>Begin</span><span class=special>, 
                          </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,12 +184,12 @@ 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>
     
-    </span><span class=comment>// convenience
+    <span class=comment>// convenience
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>Sequence</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>ForwardRange </span><span class=special>&gt;
     </span><span class=identifier>Sequence </span><a href="#copy_range"><span 
 class=identifier>copy_range</span></a><span class=special>( </span><span 
@@ -228,9 +225,9 @@ non-const iterators from the same container. </p>
      
 <p>
 <a name="equal"></a>      
-<code>bool equal( iterator_range& r ) const;</code>
+<code>bool equal( iterator_range&amp; r ) const;</code>
 <blockquote>
-    <i>Returns</i> <code>begin() == r.begin() && end() == r.end();</code>
+    <i>Returns</i> <code>begin() == r.begin() &amp;&amp; end() == r.end();</code>
 </blockquote>
 </p>      
 
@@ -238,21 +235,21 @@ non-const iterators from the same container. </p>
 
 <p> 
 <a name="comparison"></a>
-<code>bool operator==( const ForwardRange1& l, const ForwardRange2& r );</code>
+<code>bool operator==( const ForwardRange1&amp; l, const ForwardRange2&amp; r );</code>
 <blockquote>
     <i>Returns</i> <code>size(l) != size(r) ? false : std::equal( begin(l), end(l), begin(r) );</code> </blockquote> </p>
-<code>bool operator!=( const ForwardRange1& l, const ForwardRange2& r );</code>
+<code>bool operator!=( const ForwardRange1&amp; l, const ForwardRange2&amp; r );</code>
 <blockquote>
     <i>Returns</i> <code>!( l == r );</code>
 </blockquote>
-<code>bool operator<( const ForwardRange1& l, const ForwardRange2& r );</code>
+<code>bool operator<( const ForwardRange1&amp; l, const ForwardRange2&amp; r );</code>
 <blockquote>
     <i>Returns</i> <code>std::lexicographical_compare( begin(l), end(l), begin(r), end(r) );</code> </blockquote>
     
 <p>    
 <a name="make_iterator_range"></a>
 <pre>
-iterator_range make_iterator_range( Range& r, 
+iterator_range make_iterator_range( Range&amp; r, 
                                     typename range_difference&lt;Range>::type advance_begin, 
                                     typename range_difference&lt;Range>::type advance_end );
 </pre>
@@ -268,7 +265,7 @@ return make_iterator_range( new_begin, new_end );
 </blockquote>
 <p> 
 <a name="copy_range"></a> 
-<code>Sequence copy_range( const ForwardRange& r );</code>
+<code>Sequence copy_range( const ForwardRange&amp; r );</code>
 <blockquote>
     <i>Returns</i> <code>Sequence( begin(r), end(r) );</code>
 </blockquote>
@@ -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><span class=special>&gt;::</span><span class=identifier>type </span><span class=identifier>iterator</span><span class=special>;</span>
+        <span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>range_iterator</span><span class=special>&lt;</span><span class=keyword>const </span><span class=identifier>ForwardRange</span><span class=special>&gt;::</span><span class=identifier>type  </span><span class=identifier>const_iterator</span><span class=special>;</span>
+        <span class=keyword>typedef </span><span class=keyword>typename </span><span class=identifier>iterator_difference</span><span class=special>&lt;</span><span class=identifier>iterator</span><span class=special>&gt;::</span><span class=identifier>type       </span><span class=identifier>difference_type</span><span class=special>;</span>
     
+
     <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,11 +324,11 @@ 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>
+        </span><span class=comment>// rest of interface inherited from <a href="#iter_range"><code>iterator_range</code></a>
     </span><span class=special>};
     </span>
 <span class=special>} </span><span class=comment>// namespace 'boost'</span>
@@ -344,16 +343,23 @@ 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
-  </p>
+    <hr>
+    <p>
+      &copy; <a name="Copyright" id="Copyright">Copyright</a> Thorsten Ottosen 2008.
+    </p>
+
+    <p>
+      Distributed under the Boost Software License, Version 1.0. (See
+      accompanying file LICENSE_1_0.txt or copy
+      at <a href=
+      "http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)
+    </p>
 
   <br>
   <br>

include/boost/range/as_literal.hpp

@@ -8,21 +8,26 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP
-#define BOOST_RANGE_DETAIL_AS_LITERAL_HPP
+#ifndef BOOST_RANGE_AS_LITERAL_HPP
+#define BOOST_RANGE_AS_LITERAL_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once
 #endif
 
-#if BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #include <boost/range/detail/as_literal.hpp>
 #else
 
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/detail/str_types.hpp>
+
+#include <boost/detail/workaround.hpp>
+
 #include <cstring>
+#ifndef BOOST_NO_CWCHAR 
 #include <cwchar>
+#endif
 
 namespace boost
 {
@@ -33,10 +38,12 @@ namespace boost
             return strlen( s );
         }
 
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T 
         inline std::size_t length( const wchar_t* s )
         {
             return wcslen( s );
         }
+#endif        
 
         //
         // Remark: the compiler cannot choose between T* and T[sz]
@@ -54,7 +61,7 @@ namespace boost
             return true;
         }
 
-        
+#ifndef BOOST_NO_INTRINSIC_WCHAR_T 
         inline bool is_char_ptr( wchar_t* )
         {
             return true;
@@ -64,9 +71,10 @@ namespace boost
         {
             return true;
         }
+#endif
         
         template< class T >
-        inline long is_char_ptr( T r )
+        inline long is_char_ptr( T /* r */ )
         {
             return 0L;
         }
@@ -104,14 +112,13 @@ namespace boost
     template< class Char, std::size_t sz >
     inline iterator_range<Char*> as_literal( Char (&arr)[sz] )
     {
-        return boost::make_iterator_range( arr, arr + sz - 1 );
+        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );        
     }
-
     
     template< class Char, std::size_t sz >
     inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] )
     {
-        return boost::make_iterator_range( arr, arr + sz - 1 );
+        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
     }
 }
 

include/boost/range/atl.hpp

@@ -0,0 +1,733 @@
+#ifndef BOOST_RANGE_ATL_HPP
+#define BOOST_RANGE_ATL_HPP
+
+
+
+
+// Boost.Range ATL Extension
+//
+// Copyright Shunsuke Sogame 2005-2006.
+// Distributed under 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)
+
+
+
+
+// config
+//
+
+
+#include <atldef.h> // _ATL_VER
+
+
+#if !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+    #if (_ATL_VER < 0x0700)
+        #define BOOST_RANGE_ATL_NO_COLLECTIONS
+    #endif
+#endif
+
+
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+    #if (_ATL_VER < 0x0700) // dubious
+        #define BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX
+    #endif
+#endif
+
+
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING)
+    #if (_MSC_VER < 1310)   // from <boost/regex/mfc.hpp>, but dubious
+        #define BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING
+    #endif
+#endif
+
+
+
+
+// forward declarations
+//
+
+
+#include <basetyps.h> // IID
+
+
+namespace ATL {
+
+
+#if !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+    // arrays
+    //
+    template< class E, class ETraits >
+    class CAtlArray;
+
+    template< class E >
+    class CAutoPtrArray;
+
+    template< class I, const IID *piid >
+    class CInterfaceArray;
+
+
+    // lists
+    //
+    template< class E, class ETraits >
+    class CAtlList;
+
+    template< class E >
+    class CAutoPtrList;
+
+    template< class E, class Allocator >
+    class CHeapPtrList;
+
+    template< class I, const IID *piid >
+    class CInterfaceList;
+
+
+    // maps
+    //
+    template< class K, class V, class KTraits, class VTraits >
+    class CAtlMap;
+
+    template< class K, class V, class KTraits, class VTraits >
+    class CRBTree;
+
+    template< class K, class V, class KTraits, class VTraits >
+    class CRBMap;
+
+    template< class K, class V, class KTraits, class VTraits >
+    class CRBMultiMap;
+
+
+    // strings
+    //
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING)
+    template< class BaseType, bool t_bMFCDLL >
+    class CSimpleStringT;
+#else
+    template< class BaseType >
+    class CSimpleStringT;
+#endif
+
+    template< class BaseType, class StringTraits >
+    class CStringT;
+
+    template< class StringType, int t_nChars >
+    class CFixedStringT;
+
+    template< class BaseType, const int t_nSize >
+    class CStaticString;
+
+
+#endif // !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+    // simples
+    //
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+    template< class T, class TEqual >
+    class CSimpleArray;
+
+    template< class TKey, class TVal, class TEqual >
+    class CSimpleMap;
+
+#else
+
+    template< class T >
+    class CSimpleArray;
+
+    template< class T >
+    class CSimpleValArray;
+
+    template< class TKey, class TVal >
+    class CSimpleMap;
+
+#endif // !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+
+    // pointers
+    //
+    template< class E >
+    class CAutoPtr;
+
+    template< class T >
+    class CComPtr;
+
+    template< class T, const IID *piid >
+    class CComQIPtr;
+
+    template< class E, class Allocator >
+    class CHeapPtr;
+
+    template< class T >
+    class CAdapt;
+
+
+} // namespace ATL
+
+
+
+
+// indirect_iterator customizations
+//
+
+
+#include <boost/mpl/identity.hpp>
+#include <boost/pointee.hpp>
+
+
+namespace boost {
+
+
+    template< class E >
+    struct pointee< ATL::CAutoPtr<E> > :
+        mpl::identity<E>
+    { };
+
+    template< class T >
+    struct pointee< ATL::CComPtr<T> > :
+        mpl::identity<T>
+    { };
+
+    template< class T, const IID *piid >
+    struct pointee< ATL::CComQIPtr<T, piid> > :
+        mpl::identity<T>
+    { };
+
+    template< class E, class Allocator >
+    struct pointee< ATL::CHeapPtr<E, Allocator> > :
+        mpl::identity<E>
+    { };
+
+    template< class T >
+    struct pointee< ATL::CAdapt<T> > :
+        pointee<T>
+    { };
+
+
+} // namespace boost
+
+
+
+
+// extended customizations
+//
+
+
+#include <boost/iterator/indirect_iterator.hpp>
+#include <boost/iterator/zip_iterator.hpp>
+#include <boost/range/detail/microsoft.hpp>
+#include <boost/tuple/tuple.hpp>
+#include <atlbase.h> // CComBSTR
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+#if !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+    // arrays
+    //
+
+    struct atl_array_functions :
+        array_functions
+    {
+        template< class Iterator, class X >
+        Iterator end(X& x) // redefine
+        {
+            return x.GetData() + x.GetCount(); // no 'GetSize()'
+        }
+    };
+
+
+    template< class E, class ETraits >
+    struct customization< ATL::CAtlArray<E, ETraits> > :
+        atl_array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef E val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+
+    template< class E >
+    struct customization< ATL::CAutoPtrArray<E> > :
+        atl_array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            // ATL::CAutoPtr/CHeapPtr is no assignable.
+            typedef ATL::CAutoPtr<E> val_t;
+            typedef val_t *miter_t;
+            typedef val_t const *citer_t;
+
+            typedef indirect_iterator<miter_t> mutable_iterator;
+            typedef indirect_iterator<citer_t> const_iterator;
+        };
+    };
+
+
+    template< class I, const IID *piid >
+    struct customization< ATL::CInterfaceArray<I, piid> > :
+        atl_array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef ATL::CComQIPtr<I, piid> val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+
+    template< class E, class ETraits >
+    struct customization< ATL::CAtlList<E, ETraits> > :
+        list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef E val_t;
+
+            typedef list_iterator<X, val_t> mutable_iterator;
+            typedef list_iterator<X const, val_t const> const_iterator;
+        };
+    };
+
+
+    struct indirected_list_functions
+    {
+        template< class Iterator, class X >
+        Iterator begin(X& x)
+        {
+            typedef typename Iterator::base_type base_t; // == list_iterator
+            return Iterator(base_t(x, x.GetHeadPosition()));
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            typedef typename Iterator::base_type base_t;
+            return Iterator(base_t(x, POSITION(0)));
+        }
+    };
+
+
+    template< class E >
+    struct customization< ATL::CAutoPtrList<E> > :
+        indirected_list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef ATL::CAutoPtr<E> val_t;
+            typedef list_iterator<X, val_t> miter_t;
+            typedef list_iterator<X const, val_t const> citer_t;
+
+            typedef indirect_iterator<miter_t> mutable_iterator;
+            typedef indirect_iterator<citer_t> const_iterator;
+        };
+    };
+
+
+    template< class E, class Allocator >
+    struct customization< ATL::CHeapPtrList<E, Allocator> > :
+        indirected_list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef ATL::CHeapPtr<E, Allocator> val_t;
+            typedef list_iterator<X, val_t> miter_t;
+            typedef list_iterator<X const, val_t const> citer_t;
+
+            typedef indirect_iterator<miter_t> mutable_iterator;
+            typedef indirect_iterator<citer_t> const_iterator;
+        };
+    };
+
+
+    template< class I, const IID *piid >
+    struct customization< ATL::CInterfaceList<I, piid> > :
+        list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef ATL::CComQIPtr<I, piid> val_t;
+
+            typedef list_iterator<X, val_t> mutable_iterator;
+            typedef list_iterator<X const, val_t const> const_iterator;
+        };
+    };
+
+
+    // maps
+    //
+
+    struct atl_rb_tree_tag
+    { };
+
+    template< >
+    struct customization< atl_rb_tree_tag > :
+        indirected_list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef typename X::CPair val_t;
+
+            typedef list_iterator<X, val_t *, val_t *> miter_t;
+            typedef list_iterator<X const, val_t const *, val_t const *> citer_t;
+            
+            typedef indirect_iterator<miter_t> mutable_iterator;
+            typedef indirect_iterator<citer_t> const_iterator;
+        };
+    };
+
+
+    template< class K, class V, class KTraits, class VTraits >
+    struct customization< ATL::CAtlMap<K, V, KTraits, VTraits> > :
+        customization< atl_rb_tree_tag >
+    {
+        template< class Iterator, class X >
+        Iterator begin(X& x) // redefine
+        {
+            typedef typename Iterator::base_type base_t; // == list_iterator
+            return Iterator(base_t(x, x.GetStartPosition())); // no 'GetHeadPosition'
+        }
+    };
+
+
+    // strings
+    //
+
+    struct atl_string_tag
+    { };
+
+    template< >
+    struct customization< atl_string_tag >
+    {
+        template< class X >
+        struct meta
+        {
+            typedef typename X::PXSTR mutable_iterator;
+            typedef typename X::PCXSTR const_iterator;
+        };
+
+        template< class Iterator, class X >
+        typename mutable_<Iterator, X>::type begin(X& x)
+        {
+            return x.GetBuffer(0);
+        }
+
+        template< class Iterator, class X >
+        Iterator begin(X const& x)
+        {
+            return x.GetString();
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return begin<Iterator>(x) + x.GetLength();
+        }
+    };
+
+
+    template< class BaseType, const int t_nSize >
+    struct customization< ATL::CStaticString<BaseType, t_nSize> >
+    {
+        template< class X >
+        struct meta
+        {
+            typedef BaseType const *mutable_iterator;
+            typedef mutable_iterator const_iterator;
+        };
+
+        template< class Iterator, class X >
+        Iterator begin(X const& x)
+        {
+            return x;
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X const& x)
+        {
+            return begin<Iterator>(x) + X::GetLength();
+        }
+    };
+
+
+#endif // !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+    template< >
+    struct customization< ATL::CComBSTR >
+    {
+        template< class X >
+        struct meta
+        {
+            typedef OLECHAR *mutable_iterator;
+            typedef OLECHAR const *const_iterator;
+        };
+
+        template< class Iterator, class X >
+        Iterator begin(X& x)
+        {
+            return x.operator BSTR();
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return begin<Iterator>(x) + x.Length();
+        }
+    };
+
+
+    // simples
+    //
+
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+    template< class T, class TEqual >
+    struct customization< ATL::CSimpleArray<T, TEqual> > :
+#else
+    template< class T >
+    struct customization< ATL::CSimpleArray<T> > :
+#endif
+        array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef T val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+
+#if defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+    template< class T >
+    struct customization< ATL::CSimpleValArray<T> > :
+        array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef T val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+#endif // defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+    template< class TKey, class TVal, class TEqual >
+    struct customization< ATL::CSimpleMap<TKey, TVal, TEqual> >
+#else
+    template< class TKey, class TVal >
+    struct customization< ATL::CSimpleMap<TKey, TVal> >
+#endif
+    {
+        template< class X >
+        struct meta
+        {
+            typedef TKey k_val_t;
+            typedef k_val_t *k_miter_t;
+            typedef k_val_t const *k_citer_t;
+
+            typedef TVal v_val_t;
+            typedef v_val_t *v_miter_t;
+            typedef v_val_t const *v_citer_t;
+
+            // Topic:
+            // 'std::pair' can't contain references
+            // because of reference to reference problem.
+
+            typedef zip_iterator< tuple<k_miter_t, v_miter_t> > mutable_iterator;
+            typedef zip_iterator< tuple<k_citer_t, v_citer_t> > const_iterator;
+        };
+
+        template< class Iterator, class X >
+        Iterator begin(X& x)
+        {
+            return Iterator(boost::make_tuple(x.m_aKey, x.m_aVal));
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return Iterator(boost::make_tuple(x.m_aKey + x.GetSize(), x.m_aVal + x.GetSize()));
+        }
+    };
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+
+
+// range customizations
+//
+
+
+#if !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+    // arrays
+    //
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CAtlArray, 2
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CAutoPtrArray, 1
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CInterfaceArray, (class)(const IID *)
+    )
+
+
+    // lists
+    //
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CAtlList, 2
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CAutoPtrList, 1
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CHeapPtrList, 2
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CInterfaceList, (class)(const IID *)
+    )
+
+
+    //maps
+    //
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CAtlMap, 4
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::atl_rb_tree_tag,
+        (ATL, BOOST_PP_NIL), CRBTree, 4
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::atl_rb_tree_tag,
+        (ATL, BOOST_PP_NIL), CRBMap, 4
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::atl_rb_tree_tag,
+        (ATL, BOOST_PP_NIL), CRBMultiMap, 4
+    )
+
+
+    // strings
+    //
+    #if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLESTRING)
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+            boost::range_detail_microsoft::atl_string_tag,
+            (ATL, BOOST_PP_NIL), CSimpleStringT, (class)(bool)
+        )
+    #else
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+            boost::range_detail_microsoft::atl_string_tag,
+            (ATL, BOOST_PP_NIL), CSimpleStringT, 1
+        )
+    #endif
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::atl_string_tag,
+        (ATL, BOOST_PP_NIL), CStringT, 2
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::atl_string_tag,
+        (ATL, BOOST_PP_NIL), CFixedStringT, (class)(int)
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CStaticString, (class)(const int)
+    )
+
+
+#endif // !defined(BOOST_RANGE_ATL_NO_COLLECTIONS)
+
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    (ATL, BOOST_PP_NIL), CComBSTR
+)
+
+
+// simples
+//
+#if !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CSimpleArray, 2
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CSimpleMap, 3
+    )
+
+#else
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CSimpleArray, 1
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CSimpleMap, 2
+    )
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        (ATL, BOOST_PP_NIL), CSimpleValArray, 1
+    )
+
+#endif // !defined(BOOST_RANGE_ATL_HAS_OLD_CSIMPLE_XXX)
+
+
+
+
+#endif

include/boost/range/begin.hpp

@@ -41,6 +41,11 @@ namespace range_detail
     inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
     range_begin( C& c )
     {
+        //
+        // If you get a compile-error here, it is most likely because
+        // you have not implemented range_begin() properly in
+        // the namespace of C
+        //
         return c.begin();
     }
 
@@ -68,15 +73,15 @@ namespace range_detail
     // May this be discarded? Or is it needed for bad compilers?
     //
     template< typename T, std::size_t sz >
-    inline const T* range_begin( const T (&array)[sz] )
+    inline const T* range_begin( const T (&a)[sz] )
     {
-        return array;
+        return a;
     }
 
     template< typename T, std::size_t sz >
-    inline T* range_begin( T (&array)[sz] )
+    inline T* range_begin( T (&a)[sz] )
     {
-        return array;
+        return a;
     }
 
 

include/boost/range/concepts.hpp

@@ -13,8 +13,8 @@
 
 #include <boost/concept_check.hpp>
 #include <boost/iterator/iterator_concepts.hpp>
-#include <boost/range/functions.hpp>
-#include <boost/range/metafunctions.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
 
 /*!
  * \file
@@ -57,10 +57,11 @@ namespace boost {
 
     //! Check if a type T models the SinglePassRange range concept.
     template<typename T>
-    struct SinglePassRangeConcept {
-        typedef typename range_value<T>::type range_value;
-        typedef typename range_iterator<T>::type range_iterator;
-        typedef typename range_const_iterator<T>::type range_const_iterator;
+    struct SinglePassRangeConcept 
+    {
+        typedef typename range_iterator<T const>::type  range_const_iterator;
+        typedef typename range_iterator<T>::type        range_iterator;
+
         void constraints()
         {
             function_requires<
@@ -70,9 +71,9 @@ namespace boost {
             >();
             i = boost::begin(a);
             i = boost::end(a);
-            b = boost::empty(a);
             const_constraints(a);
         }
+        
         void const_constraints(const T& a)
         {
             ci = boost::begin(a);
@@ -81,14 +82,12 @@ namespace boost {
         T a;
         range_iterator i;
         range_const_iterator ci;
-        bool b;
     };
 
     //! Check if a type T models the ForwardRange range concept.
     template<typename T>
-    struct ForwardRangeConcept {
-        typedef typename range_difference<T>::type range_difference;
-        typedef typename range_size<T>::type range_size;
+    struct ForwardRangeConcept 
+    {
         void constraints()
         {
             function_requires<
@@ -99,17 +98,13 @@ namespace boost {
                     typename range_iterator<T>::type
                 >
             >();
-            s = boost::size(a);
         }
-        T a;
-        range_size s;
     };
 
     //! Check if a type T models the BidirectionalRange range concept.
     template<typename T>
-    struct BidirectionalRangeConcept {
-        typedef typename range_reverse_iterator<T>::type range_reverse_iterator;
-        typedef typename range_const_reverse_iterator<T>::type range_const_reverse_iterator;
+    struct BidirectionalRangeConcept 
+    {
         void constraints()
         {
             function_requires<
@@ -120,23 +115,13 @@ namespace boost {
                     typename range_iterator<T>::type
                 >
             >();
-            i = boost::rbegin(a);
-            i = boost::rend(a);
-            const_constraints(a);
-            }
-        void const_constraints(const T& a)
-        {
-            ci = boost::rbegin(a);
-            ci = boost::rend(a);
         }
-        T a;
-        range_reverse_iterator i;
-        range_const_reverse_iterator ci;
     };
 
     //! Check if a type T models the RandomAccessRange range concept.
     template<typename T>
-    struct RandomAccessRangeConcept {
+    struct RandomAccessRangeConcept 
+    {
         void constraints()
         {
             function_requires<
@@ -147,7 +132,7 @@ namespace boost {
                     typename range_iterator<T>::type
                 >
             >();
-            }
+         }
     };
 
 } // namespace boost

include/boost/range/config.hpp

@@ -37,8 +37,7 @@
 #error "macro already defined!"
 #endif
 
-//#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || __MWERKS__ <= 0x3003
-#if _MSC_VER <= 1300 && !defined( __COMO__ ) && !defined( __GNUC__ ) && __MWERKS__ <= 0x3003
+#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
 #define BOOST_RANGE_NO_ARRAY_SUPPORT 1
 #endif
 

include/boost/range/detail/as_literal.hpp

@@ -8,8 +8,8 @@
 // For more information, see http://www.boost.org/libs/range/
 //
 
-#ifndef BOOST_RANGE_AS_LITERAL_HPP
-#define BOOST_RANGE_AS_LITERAL_HPP
+#ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP
+#define BOOST_RANGE_DETAIL_AS_LITERAL_HPP
 
 #if defined(_MSC_VER) && (_MSC_VER >= 1200)
 # pragma once

include/boost/range/detail/implementation_help.hpp

@@ -25,6 +25,8 @@ namespace boost
 {
     namespace range_detail
     {
+        template <typename T>
+        inline void boost_range_silence_warning( const T& ) { }
         
         /////////////////////////////////////////////////////////////////////
         // end() help
@@ -57,55 +59,15 @@ namespace boost
             return const_cast<Char*>( str_end( s, s ) );
         }
 
-        /*
-        template< class T, std::size_t sz >
-        inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz], int )
-        {
-            return boost_range_array + sz;
-        }
-        
-        template< class T, std::size_t sz >
-        inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz], int )
-        {
-            return boost_range_array + sz;
-        }
-
-        template< class T, std::size_t sz >
-        inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz], char_or_wchar_t_array_tag )
-        {
-            return boost_range_array + sz - 1;
-        }
-        
-        template< class T, std::size_t sz >
-        inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz], char_or_wchar_t_array_tag )
-        {
-            return boost_range_array + sz - 1;
-        }
-        */
-
         template< class T, std::size_t sz >
         inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] )
         {
-            /*
-            typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<char,T>::value || is_same<wchar_t,T>::value,
-                                                                char_or_wchar_t_array_tag,
-                                                                int >::type tag;
-
-            return array_end<T,sz>( boost_range_array, tag() );
-            */
             return boost_range_array + sz;
         }
         
         template< class T, std::size_t sz >
         inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
         {
-            /*
-            typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<char,T>::value || is_same<wchar_t,T>::value,
-                                                                char_or_wchar_t_array_tag,
-                                                                int >::type tag;
-        
-            return array_end<T,sz>( boost_range_array, tag() );
-            */
             return boost_range_array + sz;
         }
 
@@ -119,54 +81,17 @@ namespace boost
             return str_end( s ) - s;
         }
 
-        /*
-        template< class T, std::size_t sz >
-        inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz], int )
-        {
-            return sz;
-        }
-       
-        template< class T, std::size_t sz >
-        inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz], int )
-        {
-            return sz;
-        }
-
-        template< class T, std::size_t sz >
-        inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz], char_or_wchar_t_array_tag )
-        {
-            return sz - 1;
-        }
-                 
-        template< class T, std::size_t sz >
-        inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz], char_or_wchar_t_array_tag )
-        {
-            return sz - 1;
-        }
-        */
-        
         template< class T, std::size_t sz >
         inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz] )
         {
-            /*
-            typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<const char,T>::value || is_same<const wchar_t,T>::value ||
-                                                                   is_same<char,T>::value       || is_same<wchar_t,T>::value,
-                                                                char_or_wchar_t_array_tag,
-                                                                int >::type tag;
-            return array_size<T,sz>( boost_range_array, tag() );
-            */
+            boost_range_silence_warning( boost_range_array );
             return sz;
         }
 
         template< class T, std::size_t sz >
         inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz] )
         {
-            /*
-            typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<char,T>::value || is_same<wchar_t,T>::value,
-                                                                char_or_wchar_t_array_tag,
-                                                                int >::type tag;
-            return array_size<T,sz>( boost_range_array, tag() );
-            */
+            boost_range_silence_warning( boost_range_array );
             return sz;
         }
 

include/boost/range/detail/mfc/carray.hpp

@@ -1,97 +0,0 @@
-// Boost.Range library
-//
-//  Copyright Thorsten Ottosen 2003-2004. 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)
-//
-// For more information, see http://www.boost.org/libs/range/
-//
-
-#if !defined( BOOST_RANGE_DETAIL_MFC_CARRAY_HPP ) && defined( BOOST_RANGE_ENABLE_MCF_CARRAY ) 
-#define BOOST_RANGE_DETAIL_MFC_CARRAY_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <afxtempl.h> // for CArray
-#include <boost/range/config.hpp>
-#include <boost/range/metafunctions.hpp>
-
-namespace boost
-{
-    template< class T, class U >
-    struct range_iterator< CArray<T,U> >
-    {
-        typedef T* type;
-    };
-
-    //
-    // Why is this needed?!?
-    //
-    template< class T, class U >
-    struct range_iterator< const CArray<T,U> >
-    {
-        typedef T* type;
-    };
-
-    template< class T, class U >
-    struct range_const_iterator< CArray<T,U> >
-    {
-        typedef const T* type;
-    };
-    
-    template< class T, class U >
-    struct range_difference< CArray<T,U> >
-    {
-        typedef std::ptrdiff_t type;
-    };
-    
-    template< class T, class U >
-    struct range_size< CArray<T,U> >
-    {
-        typedef int type;
-    };
-
-    template< class T, class U >
-    struct range_value< CArray<T,U> >
-    {
-        typedef T type;
-    };
-
-    template< class T, class U >
-    T* boost_range_begin( CArray<T,U>& r )
-    {
-        return r.GetData();
-    }
-        
-    template< class T, class U >
-    const T* boost_range_begin( const CArray<T,U>& r )
-    {
-        return r.GetData();
-    }
-
-    template< class T, class U >
-    int boost_range_size( const CArray<T,U>& r )
-    {
-        return r.GetSize();
-    }
-    
-    template< class T, class U >
-    T* boost_range_end( CArray<T,U>& r )
-    {
-        return boost_range_begin( r ) + boost_range_size( r );
-    }
-        
-    template< class T, class U >
-    const T* boost_range_end( const CArray<T,U>& r )
-    {
-        return boost_range_begin( r ) + boost_range_size( r );
-    }
-
-    // default 'empty()' ok
-
-} // namespace 'boost'
-
-#endif

include/boost/range/detail/mfc/cstring.hpp

@@ -1,92 +0,0 @@
-// Boost.Range library
-//
-//  Copyright Thorsten Ottosen 2003-2004. 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)
-//
-// For more information, see http://www.boost.org/libs/range/
-//
-
-#if !defined(BOOST_RANGE_DETAIL_MFC_CSTRING_HPP) && defined(BOOST_RANGE_ENABLE_MFC)
-#define BOOST_RANGE_DETAIL_MFC_CSTRING_HPP
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
-# pragma once
-#endif
-
-#include <afx.h> // for CString
-#include <boost/range/config.hpp>
-#include <boost/range/metafunctions.hpp>
-
-namespace boost
-{
-    template<>
-    struct range_iterator< CString >
-    {
-        typedef TCHAR* type;
-    };
-
-    //
-    // Why is this needed?!?
-    //
-    template<>
-    struct range_iterator< const CString >
-    {
-        typedef TCHAR* type;
-    };
-
-    template<>
-    struct range_const_iterator< CString >
-    {
-        typedef const TCHAR* type;
-    };
-
-    template<>
-    struct range_difference< CString >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_size< CString >
-    {
-        typedef int type;
-    };
-
-    template<>
-    struct range_value< CString >
-    {
-        typedef TCHAR type;
-    };
-
-    TCHAR* boost_range_begin( CString& r )
-    {
-        return r.GetBuffer(0);
-    }
-        
-    const TCHAR* boost_range_begin( const CString& r )
-    {
-        return (LPCTSTR)r;
-    }
-
-    int boost_range_size( const CString& r )
-    {
-        return r.GetLength();
-    }
-    
-    TCHAR* boost_range_end( CString& r )
-    {
-        return boost_range_begin( r ) + boost_range_size( r );
-    }
-        
-    const TCHAR* range_adl_end( const CString& r )
-    {
-        return boost_range_begin( r ) + boost_range_size( r );
-    }
-
-    // default 'empty()' ok
-
-} // namespace 'boost'
-
-#endif

include/boost/range/detail/microsoft.hpp

@@ -0,0 +1,931 @@
+#ifndef BOOST_RANGE_DETAIL_MICROSOFT_HPP
+#define BOOST_RANGE_DETAIL_MICROSOFT_HPP
+
+// Boost.Range MFC/ATL Extension
+//
+// Copyright Shunsuke Sogame 2005-2006.
+// Distributed under 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)
+
+
+
+
+// config
+//
+
+
+#include <boost/range/iterator.hpp>
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1 1
+
+
+#if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+    #define BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator range_mutable_iterator
+    #define BOOST_RANGE_DETAIL_MICROSOFT_range_begin            range_begin
+    #define BOOST_RANGE_DETAIL_MICROSOFT_range_end              range_end
+#else
+    #define BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator range_mutable_iterator
+    #define BOOST_RANGE_DETAIL_MICROSOFT_range_begin            range_begin
+    #define BOOST_RANGE_DETAIL_MICROSOFT_range_end              range_end
+#endif
+
+
+
+
+// yet another customization way
+//
+
+
+#include <boost/iterator/iterator_traits.hpp> // iterator_difference
+#include <boost/mpl/identity.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/preprocessor/cat.hpp>
+#include <boost/preprocessor/control/iif.hpp>
+#include <boost/preprocessor/comma_if.hpp>
+#include <boost/preprocessor/detail/is_unary.hpp>
+#include <boost/preprocessor/list/for_each.hpp>
+#include <boost/preprocessor/repetition/enum_params.hpp>
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/seq/for_each_i.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/tuple/eat.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/size_type.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/type_traits/remove_cv.hpp>
+#include <boost/utility/addressof.hpp>
+#include <boost/utility/enable_if.hpp> // disable_if
+
+#if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+    #include <boost/range/mutable_iterator.hpp>
+#else
+    #include <iterator> // distance
+    #include <boost/range/begin.hpp>
+    #include <boost/range/end.hpp>
+    #include <boost/range/iterator.hpp>
+#endif
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+    // customization point
+    //
+
+    template< class Tag >
+    struct customization;
+
+
+    template< class T >
+    struct customization_tag;
+
+
+    struct using_type_as_tag
+    { };
+
+
+    // Topic:
+    // In fact, it is unnecessary for VC++.
+    // VC++'s behavior seems conforming, while GCC fails without this.
+    template< class Iterator, class T >
+    struct mutable_ :
+        disable_if< is_const<T>, Iterator >
+    { };
+
+
+    // helpers
+    //
+
+    template< class Tag, class T >
+    struct customization_tag_of
+    {
+        typedef typename mpl::if_< is_same<using_type_as_tag, Tag>,
+            T,
+            Tag
+        >::type type;
+    };
+
+
+    template< class T >
+    struct customization_of
+    {
+        typedef typename remove_cv<T>::type bare_t;
+        typedef typename customization_tag<bare_t>::type tag_t;
+        typedef customization<tag_t> type;
+    };
+
+
+    template< class T >
+    struct mutable_iterator_of
+    {
+        typedef typename remove_cv<T>::type bare_t;
+        typedef typename customization_of<bare_t>::type cust_t;
+        typedef typename cust_t::template meta<bare_t>::mutable_iterator type;
+    };
+
+
+    template< class T >
+    struct const_iterator_of
+    {
+        typedef typename remove_cv<T>::type bare_t;
+        typedef typename customization_of<bare_t>::type cust_t;
+        typedef typename cust_t::template meta<bare_t>::const_iterator type;
+    };
+
+
+    template< class T >
+    struct size_type_of
+    {
+        typedef typename range_detail_microsoft::mutable_iterator_of<T>::type miter_t;
+        typedef typename iterator_difference<miter_t>::type type;
+    };
+
+
+    template< class T > inline
+    typename mutable_iterator_of<T>::type
+    begin_of(T& x)
+    {
+        typedef typename customization_of<T>::type cust_t;
+        return cust_t().template begin<typename mutable_iterator_of<T>::type>(x);
+    }
+
+
+    template< class T > inline
+    typename const_iterator_of<T>::type
+    begin_of(T const& x)
+    {
+        typedef typename customization_of<T>::type cust_t;
+        return cust_t().template begin<typename const_iterator_of<T>::type>(x);
+    }
+
+
+    template< class T > inline
+    typename mutable_iterator_of<T>::type
+    end_of(T& x)
+    {
+        typedef typename customization_of<T>::type cust_t;
+        return cust_t().template end<typename mutable_iterator_of<T>::type>(x);
+    }
+
+
+    template< class T > inline
+    typename const_iterator_of<T>::type
+    end_of(T const& x)
+    {
+        typedef typename customization_of<T>::type cust_t;
+        return cust_t().template end<typename const_iterator_of<T>::type>(x);
+    }
+
+
+#if defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+
+    template< class T > inline
+    typename size_type_of<T>::type
+    size_of(T const& x)
+    {
+        return std::distance(boost::begin(x), boost::end(x));
+    }
+
+#endif
+
+
+    template< class Range >
+    struct compatible_mutable_iterator : 
+        BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator<Range>
+    { };
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open(NamespaceList) \
+    BOOST_PP_LIST_FOR_EACH(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open_op, ~, NamespaceList) \
+/**/
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open_op(r, data, elem) \
+        namespace elem { \
+    /**/
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close(NamespaceList) \
+    BOOST_PP_LIST_FOR_EACH(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close_op, ~, NamespaceList) \
+/**/
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close_op(r, data, elem) \
+        } \
+    /**/
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_expand_op(r, data, elem) \
+    :: elem \
+/**/
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(Tag, NamespaceList, Name) \
+    namespace boost { namespace range_detail_microsoft { \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_tag(Tag, BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+    } } \
+    \
+    namespace boost { \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_mutable_iterator(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_const_iterator(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size_type(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+    } \
+    \
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open(NamespaceList) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_begin(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_begin_const(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_end(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_end_const(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name)) \
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close(NamespaceList) \
+/**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_fullname(NamespaceList, Name) \
+        BOOST_PP_LIST_FOR_EACH(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_expand_op, ~, NamespaceList) :: Name \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_tag(Tag, Fullname) \
+        template< > \
+        struct customization_tag< Fullname > : \
+            customization_tag_of< Tag, Fullname > \
+        { }; \
+    /**/
+
+
+    // metafunctions
+    //
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_mutable_iterator(Fullname) \
+        template< > \
+        struct BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator< Fullname > : \
+            range_detail_microsoft::mutable_iterator_of< Fullname > \
+        { }; \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_const_iterator(Fullname) \
+        template< > \
+        struct range_const_iterator< Fullname > : \
+            range_detail_microsoft::const_iterator_of< Fullname > \
+        { }; \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size_type(Fullname) \
+        template< > \
+        struct range_size< Fullname > : \
+            range_detail_microsoft::size_type_of< Fullname > \
+        { }; \
+    /**/
+
+
+    // functions
+    //
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_begin(Fullname) \
+        inline \
+        boost::range_detail_microsoft::mutable_iterator_of< Fullname >::type \
+        BOOST_RANGE_DETAIL_MICROSOFT_range_begin(Fullname& x) \
+        { \
+            return boost::range_detail_microsoft::begin_of(x); \
+        } \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_begin_const(Fullname) \
+        inline \
+        boost::range_detail_microsoft::const_iterator_of< Fullname >::type \
+        BOOST_RANGE_DETAIL_MICROSOFT_range_begin(Fullname const& x) \
+        { \
+            return boost::range_detail_microsoft::begin_of(x); \
+        } \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_end(Fullname) \
+        inline \
+        boost::range_detail_microsoft::mutable_iterator_of< Fullname >::type \
+        BOOST_RANGE_DETAIL_MICROSOFT_range_end(Fullname& x) \
+        { \
+            return boost::range_detail_microsoft::end_of(x); \
+        } \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_end_const(Fullname) \
+        inline \
+        boost::range_detail_microsoft::const_iterator_of< Fullname >::type \
+        BOOST_RANGE_DETAIL_MICROSOFT_range_end(Fullname const& x) \
+        { \
+            return boost::range_detail_microsoft::end_of(x); \
+        } \
+    /**/
+
+
+    #if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+
+        #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size(Fullname) \
+        /**/
+
+    #else
+
+        #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE_size(Fullname) \
+            inline \
+            boost::range_detail_microsoft::size_type_of< Fullname >::type \
+            boost_range_size(Fullname const& x) \
+            { \
+                return boost::range_detail_microsoft::size_of(x); \
+            } \
+        /**/
+
+    #endif
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(Tag, NamespaceList, Name, ParamSeqOrCount) \
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_impl( \
+        Tag, NamespaceList, Name, \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_to_param_seq(ParamSeqOrCount) \
+    ) \
+/**/
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_to_param_seq(ParamSeqOrCount) \
+        BOOST_PP_IIF(BOOST_PP_IS_UNARY(ParamSeqOrCount), \
+            ParamSeqOrCount BOOST_PP_TUPLE_EAT(3), \
+            BOOST_PP_REPEAT \
+        )(ParamSeqOrCount, BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_to_param_seq_op, ~) \
+    /**/
+
+        #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_to_param_seq_op(z, n, _) \
+            (class) \
+        /**/
+
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_impl(Tag, NamespaceList, Name, ParamSeq) \
+    namespace boost { namespace range_detail_microsoft { \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_tag( \
+            Tag, \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        ) \
+    } } \
+    \
+    namespace boost { \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_mutable_iterator( \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        ) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_const_iterator( \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        ) \
+        \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size_type( \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        ) \
+    } \
+    \
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_open(NamespaceList) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_begin( \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        ) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_begin_const( \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        ) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_end( \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        ) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_end_const( \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        ) \
+        BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size( \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq), \
+            BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        ) \
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_close(NamespaceList) \
+/**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params(ParamSeq) \
+        BOOST_PP_SEQ_FOR_EACH_I(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params_op, ~, ParamSeq) \
+    /**/
+
+        #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_params_op(r, data, i, elem) \
+            BOOST_PP_COMMA_IF(i) elem BOOST_PP_CAT(T, i) \
+        /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_fullname(NamespaceList, Name, ParamSeq) \
+        BOOST_PP_LIST_FOR_EACH(BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_namespace_expand_op, ~, NamespaceList) \
+        :: Name < BOOST_PP_ENUM_PARAMS(BOOST_PP_SEQ_SIZE(ParamSeq), T) > \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_tag(Tag, Params, Fullname) \
+        template< Params > \
+        struct customization_tag< Fullname > : \
+            customization_tag_of< Tag, Fullname > \
+        { }; \
+    /**/
+
+
+    // metafunctions
+    //
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_mutable_iterator(Params, Fullname) \
+        template< Params > \
+        struct BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator< Fullname > : \
+            range_detail_microsoft::mutable_iterator_of< Fullname > \
+        { }; \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_const_iterator(Params, Fullname) \
+        template< Params > \
+        struct range_const_iterator< Fullname > : \
+            range_detail_microsoft::const_iterator_of< Fullname > \
+        { }; \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size_type(Params, Fullname) \
+        template< Params > \
+        struct range_size< Fullname > : \
+            range_detail_microsoft::size_type_of< Fullname > \
+        { }; \
+    /**/
+
+
+    // functions
+    //
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_begin(Params, Fullname) \
+        template< Params > inline \
+        typename boost::range_detail_microsoft::mutable_iterator_of< Fullname >::type \
+        BOOST_RANGE_DETAIL_MICROSOFT_range_begin(Fullname& x) \
+        { \
+            return boost::range_detail_microsoft::begin_of(x); \
+        } \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_begin_const(Params, Fullname) \
+        template< Params > inline \
+        typename boost::range_detail_microsoft::const_iterator_of< Fullname >::type \
+        BOOST_RANGE_DETAIL_MICROSOFT_range_begin(Fullname const& x) \
+        { \
+            return boost::range_detail_microsoft::begin_of(x); \
+        } \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_end(Params, Fullname) \
+        template< Params > inline \
+        typename boost::range_detail_microsoft::mutable_iterator_of< Fullname >::type \
+        BOOST_RANGE_DETAIL_MICROSOFT_range_end(Fullname& x) \
+        { \
+            return boost::range_detail_microsoft::end_of(x); \
+        } \
+    /**/
+
+
+    #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_end_const(Params, Fullname) \
+        template< Params > inline \
+        typename boost::range_detail_microsoft::const_iterator_of< Fullname >::type \
+        BOOST_RANGE_DETAIL_MICROSOFT_range_end(Fullname const& x) \
+        { \
+            return boost::range_detail_microsoft::end_of(x); \
+        } \
+    /**/
+
+
+    #if !defined(BOOST_RANGE_DETAIL_MICROSOFT_RANGE_VERSION_1)
+
+        #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size(Params, Fullname) \
+        /**/
+
+    #else
+
+        #define BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE_size(Params, Fullname) \
+            template< Params > inline \
+            typename boost::range_detail_microsoft::size_type_of< Fullname >::type \
+            boost_range_size(Fullname const& x) \
+            { \
+                return boost::range_detail_microsoft::size_of(x); \
+            } \
+        /**/
+
+    #endif
+
+
+
+
+// list_iterator and helpers
+//
+
+
+#include <boost/assert.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+
+// POSITION's header is undocumented, so is NULL.
+//
+struct __POSITION; // incomplete, but used as just a pointer.
+typedef __POSITION *POSITION;
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+    template<
+        class ListT,
+        class Value,
+        class Reference,
+        class Traversal
+    >
+    struct list_iterator;
+
+
+    template<
+        class ListT,
+        class Value,
+        class Reference,
+        class Traversal
+    >
+    struct list_iterator_super
+    {
+        typedef typename mpl::if_< is_same<use_default, Reference>,
+            Value&,
+            Reference
+        >::type ref_t;
+
+        typedef typename mpl::if_< is_same<use_default, Traversal>,
+            bidirectional_traversal_tag,
+            Traversal
+        >::type trv_t;
+
+        typedef iterator_facade<
+            list_iterator<ListT, Value, Reference, Traversal>,
+            Value,
+            trv_t,
+            ref_t
+        > type;
+    };
+
+
+    template<
+        class ListT,
+        class Value,
+        class Reference = use_default,
+        class Traversal = use_default
+    >
+    struct list_iterator :
+        list_iterator_super<ListT, Value, Reference, Traversal>::type
+    {
+    private:
+        typedef list_iterator self_t;
+        typedef typename list_iterator_super<ListT, Value, Reference, Traversal>::type super_t;
+        typedef typename super_t::reference ref_t;
+
+    public:
+        explicit list_iterator()
+        { }
+
+        explicit list_iterator(ListT& lst, POSITION pos) :
+            m_plst(boost::addressof(lst)), m_pos(pos)
+        { }
+
+    template< class, class, class, class > friend struct list_iterator;
+        template< class ListT_, class Value_, class Reference_, class Traversal_>
+        list_iterator(list_iterator<ListT_, Value_, Reference_, Traversal_> const& other) :
+            m_plst(other.m_plst), m_pos(other.m_pos)
+        { }
+
+    private:
+        ListT *m_plst;
+        POSITION m_pos;
+
+    friend class iterator_core_access;
+        ref_t dereference() const
+        {
+            BOOST_ASSERT(m_pos != 0 && "out of range");
+            return m_plst->GetAt(m_pos);
+        }
+
+        // A    B    C    D    x
+        // Head           Tail NULL(0)
+        //
+        void increment()
+        {
+            BOOST_ASSERT(m_pos != 0 && "out of range");
+            m_plst->GetNext(m_pos);
+        }
+
+        void decrement()
+        {
+            if (m_pos == 0) {
+                m_pos = m_plst->GetTailPosition();
+                return;
+            }
+
+            m_plst->GetPrev(m_pos);
+        }
+
+        bool equal(self_t const& other) const
+        {
+            BOOST_ASSERT(m_plst == other.m_plst && "iterators incompatible");
+            return m_pos == other.m_pos;
+        }
+    };
+
+
+    // customization helpers
+    //
+
+    struct array_functions
+    {
+        template< class Iterator, class X >
+        Iterator begin(X& x)
+        {
+            return x.GetData();
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return begin<Iterator>(x) + x.GetSize();
+        }
+    };
+
+
+    struct list_functions
+    {
+        template< class Iterator, class X >
+        Iterator begin(X& x)
+        {
+            return Iterator(x, x.GetHeadPosition());
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return Iterator(x, POSITION(0));
+        }
+    };
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+
+
+// test
+//
+
+
+#if defined(BOOST_RANGE_DETAIL_MICROSOFT_TEST)
+
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+#include <boost/concept_check.hpp>
+#include <boost/next_prior.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/distance.hpp>
+#include <boost/range/empty.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/mutable_iterator.hpp>
+#include <boost/range/rbegin.hpp>
+#include <boost/range/rend.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+    template< class Range1, class Range2 >
+    bool test_equals(Range1 const& rng1, Range2 const& rng2)
+    {
+        return
+            boost::distance(rng1) == boost::distance(rng2) &&
+            std::equal(boost::begin(rng1), boost::end(rng1), boost::begin(rng2))
+        ;
+    }
+
+
+    template< class AssocContainer, class PairT >
+    bool test_find_key_and_mapped(AssocContainer const& ac, PairT const& pa)
+    {
+        typedef typename boost::range_const_iterator<AssocContainer>::type iter_t;
+        for (iter_t it = boost::const_begin(ac), last = boost::const_end(ac); it != last; ++it) {
+            if (it->first == pa.first && it->second == pa.second)
+                return true;
+        }
+
+        return false;
+    }
+
+
+    // test functions
+    //
+
+    template< class Range >
+    bool test_emptiness(Range& )
+    {
+        bool result = true;
+
+        Range emptyRng;
+        result = result && boost::empty(emptyRng);
+
+        return result;
+    }
+
+
+    template< class Range >
+    bool test_trivial(Range& rng)
+    {
+        bool result = true;
+
+        // convertibility check
+        typedef typename range_const_iterator<Range>::type citer_t;
+        citer_t cit = boost::begin(rng);
+        (void)cit; // unused
+
+        // mutability check
+        typedef typename range_value<Range>::type val_t;
+        val_t v = *boost::begin(rng);
+        *boost::begin(rng) = v;
+        result = result && *boost::begin(rng) == v;
+
+        return result;
+    }
+
+
+    template< class Range >
+    bool test_forward(Range& rng)
+    {
+        boost::function_requires< ForwardRangeConcept<Range> >();
+
+        bool result = (test_trivial)(rng);
+
+        typedef typename range_value<Range>::type val_t;
+
+        std::vector<val_t> saved;
+        std::copy(boost::begin(rng), boost::end(rng), std::back_inserter(saved));
+        std::rotate(boost::begin(saved), boost::next(boost::begin(saved)), boost::end(saved));
+
+        std::rotate(boost::begin(rng), boost::next(boost::begin(rng)), boost::end(rng));
+
+        return result && (test_equals)(saved, rng);
+    };
+
+
+    template< class Range >
+    bool test_bidirectional(Range& rng)
+    {
+        boost::function_requires< BidirectionalRangeConcept<Range> >();
+
+        bool result = (test_forward)(rng);
+
+        typedef typename range_value<Range>::type val_t;
+
+        std::vector<val_t> saved;
+        std::copy(boost::begin(rng), boost::end(rng), std::back_inserter(saved));
+
+        result = result && (test_equals)(
+            boost::make_iterator_range(boost::rbegin(saved), boost::rend(saved)),
+            boost::make_iterator_range(boost::rbegin(rng), boost::rend(rng))
+        );
+
+        return result;
+    }
+
+
+    template< class Range >
+    bool test_random_access(Range& rng)
+    {
+        boost::function_requires< RandomAccessRangeConcept<Range> >();
+
+        bool result = (test_bidirectional)(rng);
+
+        typedef typename range_value<Range>::type val_t;
+
+        std::vector<val_t> saved;
+        std::copy(boost::begin(rng), boost::end(rng), std::back_inserter(saved));
+        std::sort(boost::begin(saved), boost::end(saved));
+
+        std::random_shuffle(boost::begin(rng), boost::end(rng));
+        std::sort(boost::begin(rng), boost::end(rng));
+        result = result && (test_equals)(rng, saved);
+
+        std::random_shuffle(boost::begin(rng), boost::end(rng));
+        std::stable_sort(boost::begin(rng), boost::end(rng));
+        result = result && (test_equals)(rng, saved);
+
+        std::random_shuffle(boost::begin(rng), boost::end(rng));
+        std::partial_sort(boost::begin(rng), boost::end(rng), boost::end(rng));
+        result = result && (test_equals)(rng, saved);
+
+        return result;
+    }
+
+
+    // initializer
+    //
+
+    template< class ArrayT, class SampleRange >
+    bool test_init_array(ArrayT& arr, SampleRange const& sample)
+    {
+        typedef typename range_const_iterator<SampleRange>::type iter_t;
+        typedef typename range_value<SampleRange>::type val_t;
+
+        for (iter_t it = boost::const_begin(sample), last = boost::const_end(sample); it != last; ++it) {
+            val_t v = *it; // works around ATL3 CSimpleArray
+            arr.Add(v);
+        }
+
+        return (test_equals)(arr, sample);
+    }
+
+
+    template< class ListT, class SampleRange >
+    bool test_init_list(ListT& lst, SampleRange const& sample)
+    {
+        typedef typename range_const_iterator<SampleRange>::type iter_t;
+
+        for (iter_t it = boost::const_begin(sample), last = boost::const_end(sample); it != last; ++it) {
+            lst.AddTail(*it);
+        }
+
+        return (test_equals)(lst, sample);
+    }
+
+
+    template< class StringT, class SampleRange >
+    bool test_init_string(StringT& str, SampleRange const& sample)
+    {
+        typedef typename range_const_iterator<SampleRange>::type iter_t;
+        typedef typename range_value<SampleRange>::type val_t;
+
+        for (iter_t it = boost::const_begin(sample), last = boost::const_end(sample); it != last; ++it) {
+            str += *it;
+        }
+
+        return (test_equals)(str, sample);
+    }
+
+
+    template< class MapT, class SampleMap >
+    bool test_init_map(MapT& map, SampleMap const& sample)
+    {
+        typedef typename range_const_iterator<SampleMap>::type iter_t;
+
+        for (iter_t it = boost::const_begin(sample), last = boost::const_end(sample); it != last; ++it) {
+            map.SetAt(it->first, it->second);
+        }
+
+        return boost::distance(map) == boost::distance(sample);
+    }
+
+
+    // metafunction test
+    //
+
+    template< class Range, class Iter >
+    struct test_mutable_iter :
+        boost::is_same< typename boost::BOOST_RANGE_DETAIL_MICROSOFT_range_mutable_iterator<Range>::type, Iter >
+    { };
+
+
+    template< class Range, class Iter >
+    struct test_const_iter :
+        boost::is_same< typename boost::range_const_iterator<Range>::type, Iter >
+    { };
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+#endif // defined(BOOST_RANGE_DETAIL_MICROSOFT_TEST)
+
+
+
+#endif

include/boost/range/detail/sizer.hpp

@@ -25,12 +25,10 @@ namespace boost
     //////////////////////////////////////////////////////////////////////
     
     template< typename T, std::size_t sz >
-    char&
-    sizer( const T BOOST_RANGE_ARRAY_REF()[sz] )[sz];
+    char (& sizer( const T BOOST_RANGE_ARRAY_REF()[sz] ) )[sz];
     
     template< typename T, std::size_t sz >
-    char&
-    sizer( T BOOST_RANGE_ARRAY_REF()[sz] )[sz];
+    char (& sizer( T BOOST_RANGE_ARRAY_REF()[sz] ) )[sz];
 
 } // namespace 'boost'
 

include/boost/range/end.hpp

@@ -42,6 +42,11 @@ namespace range_detail
         inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
         range_end( C& c )
         {
+            //
+            // If you get a compile-error here, it is most likely because
+            // you have not implemented range_begin() properly in
+            // the namespace of C
+            //
             return c.end();
         }
 
@@ -66,15 +71,15 @@ namespace range_detail
         //////////////////////////////////////////////////////////////////////
 
         template< typename T, std::size_t sz >
-        inline const T* range_end( const T (&array)[sz] )
+        inline const T* range_end( const T (&a)[sz] )
         {
-            return range_detail::array_end<T,sz>( array );
+            return range_detail::array_end<T,sz>( a );
         }
 
         template< typename T, std::size_t sz >
-        inline T* range_end( T (&array)[sz] )
+        inline T* range_end( T (&a)[sz] )
         {
-            return range_detail::array_end<T,sz>( array );
+            return range_detail::array_end<T,sz>( a );
         }
 
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \

include/boost/range/iterator.hpp

@@ -24,13 +24,45 @@
 
 namespace boost
 {
+
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)  
+
+    namespace range_detail_vc7_1  
+    {  
+       template< typename C, typename Sig = void(C) >  
+       struct range_iterator  
+       {  
+           typedef BOOST_RANGE_DEDUCED_TYPENAME   
+               mpl::eval_if_c< is_const<C>::value,   
+                               range_const_iterator< typename remove_const<C>::type >,  
+                               range_mutable_iterator<C> >::type type;  
+       };  
+    
+       template< typename C, typename T >  
+       struct range_iterator< C, void(T[]) >  
+       {  
+           typedef T* type;  
+       };       
+    }  
+    
+#endif  
+
     template< typename C >
     struct range_iterator
     {
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
+  
+        typedef BOOST_RANGE_DEDUCED_TYPENAME  
+               range_detail_vc7_1::range_iterator<C>::type type;  
+           
+#else  
+
         typedef BOOST_RANGE_DEDUCED_TYPENAME 
             mpl::eval_if_c< is_const<C>::value, 
                             range_const_iterator< typename remove_const<C>::type >,
                             range_mutable_iterator<C> >::type type;
+        
+#endif         
     };
     
 } // namespace boost

include/boost/range/iterator_range.hpp

@@ -11,8 +11,15 @@
 #ifndef BOOST_RANGE_ITERATOR_RANGE_HPP
 #define BOOST_RANGE_ITERATOR_RANGE_HPP
 
-// From boost/dynamic_bitset.hpp; thanks to Matthias Troyer for Cray X1 patch.
 #include <boost/config.hpp> // Define __STL_CONFIG_H, if appropriate.
+#include <boost/detail/workaround.hpp>
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
+    #pragma warning( push )
+    #pragma warning( disable : 4996 )
+#endif
+
+// From boost/dynamic_bitset.hpp; thanks to Matthias Troyer for Cray X1 patch.
 #ifndef BOOST_OLD_IOSTREAMS 
 # if defined(__STL_CONFIG_H) && \
     !defined (__STL_USE_NEW_IOSTREAMS) && !defined(__crayx1) \
@@ -21,22 +28,24 @@
 # endif
 #endif // #ifndef BOOST_OLD_IOSTREAMS
 
-#include <boost/detail/workaround.hpp>
+#include <boost/assert.hpp>
+#include <boost/iterator/iterator_traits.hpp>    
+#include <boost/type_traits/is_abstract.hpp>
 #include <boost/range/functions.hpp>
 #include <boost/range/iterator.hpp>
 #include <boost/range/difference_type.hpp>
-#include <boost/iterator/iterator_traits.hpp>    
-#include <boost/assert.hpp>
+#include <boost/utility/enable_if.hpp>
 #include <iterator>
 #include <algorithm>
-#ifndef BOOST_OLD_IOSTREAMS
-# include <ostream>
-#else
-# include <ostream.h>
-#endif
+#ifndef _STLP_NO_IOSTREAMS
+# ifndef BOOST_OLD_IOSTREAMS
+#  include <ostream>
+# else
+#  include <ostream.h>
+# endif
+#endif // _STLP_NO_IOSTREAMS
 #include <cstddef>
 
-
 /*! \file
     Defines the \c iterator_class and related functions. 
     \c iterator_range is a simple wrapper of iterator pair idiom. It provides
@@ -70,10 +79,10 @@ namespace boost
         template< class Left, class Right >
         inline bool equal( const Left& l, const Right& r )
         {
-            typedef BOOST_DEDUCED_TYPENAME boost::range_size<Left>::type sz_type;
+            typedef BOOST_DEDUCED_TYPENAME boost::range_difference<Left>::type sz_type;
 
-            sz_type l_size = boost::size( l ),
-                    r_size = boost::size( r );
+            sz_type l_size = boost::distance( l ),
+                    r_size = boost::distance( r );
 
             if( l_size != r_size )
                 return false;
@@ -158,32 +167,25 @@ namespace boost
             //! iterator type
             typedef IteratorT iterator;
 
+        private: // for return value of operator()()
+            typedef BOOST_DEDUCED_TYPENAME 
+                boost::mpl::if_< boost::is_abstract<value_type>,
+                                 reference, value_type >::type abstract_value_type;
+
+        public:
             iterator_range() : m_Begin( iterator() ), m_End( iterator() )
                 #ifndef NDEBUG
             , singular( true )
                 #endif
             { }
-/*
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))  
-            iterator_range( this_type r ) :
-            : m_Begin(r.begin()), m_End(r.end())
-            { }
-
-            this_type& operator=( this_type r )
-            {
-                m_Begin = r.begin();
-                m_End   = r.end();
-                return *this;
-            }
-#endif
-*/            
+           
             //! Constructor from a pair of iterators
             template< class Iterator >
             iterator_range( Iterator Begin, Iterator End ) : 
                 m_Begin(Begin), m_End(End)
                 #ifndef NDEBUG
             , singular(false) 
-                 #endif
+                #endif
             {}
 
             //! Constructor from a Range
@@ -208,7 +210,7 @@ namespace boost
             template< class Range >
             iterator_range( const Range& r, iterator_range_detail::const_range_tag ) : 
                 m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
-                 #ifndef NDEBUG
+                #ifndef NDEBUG
             , singular(false) 
                 #endif
             {}
@@ -217,7 +219,7 @@ namespace boost
             template< class Range >
             iterator_range( Range& r, iterator_range_detail::range_tag ) : 
                 m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
-                 #ifndef NDEBUG
+                #ifndef NDEBUG
             , singular(false) 
                 #endif
             {}
@@ -280,7 +282,7 @@ namespace boost
                 return m_End; 
             } 
 
-            size_type size() const
+            difference_type size() const
             { 
                 BOOST_ASSERT( !is_singular() );
                 return m_End - m_Begin;
@@ -348,10 +350,21 @@ namespace boost
                return *--last;
            }
     
-           reference operator[]( size_type sz ) const
+           reference operator[]( difference_type at ) const
            {
-               BOOST_ASSERT( sz < size() );
-               return m_Begin[sz];
+               BOOST_ASSERT( at >= 0 && at < size() );
+               return m_Begin[at];
+           }
+
+           //
+           // When storing transform iterators, operator[]()
+           // fails because it returns by reference. Therefore
+           // operator()() is provided for these cases.
+           // 
+           abstract_value_type operator()( difference_type at ) const                              
+           {
+               BOOST_ASSERT( at >= 0 && at < size() );
+               return m_Begin[at];               
            }
 
            iterator_range& advance_begin( difference_type n )
@@ -377,13 +390,15 @@ namespace boost
             bool      singular;
             #endif
 
-            #ifndef NDEBUG
         public:
             bool is_singular() const
             {
+                 #ifndef NDEBUG
                  return singular;
+                 #else
+                 return false;
+                 #endif
             }
-            #endif
 
         protected:
             //
@@ -395,7 +410,8 @@ namespace boost
 
 //  iterator range free-standing operators ---------------------------//
 
-#ifndef BOOST_OLD_IOSTREAMS   
+#ifndef _STLP_NO_IOSTREAMS
+# ifndef BOOST_OLD_IOSTREAMS   
 
         //! iterator_range output operator
         /*!
@@ -414,7 +430,7 @@ namespace boost
             return Os;
         }
 
-#else
+# else
 
         //! iterator_range output operator
         /*!
@@ -430,7 +446,8 @@ namespace boost
             return Os;
         }
 
-#endif
+# endif
+#endif // _STLP_NO_IOSTREAMS
 
         /////////////////////////////////////////////////////////////////////
         // comparison operators
@@ -634,5 +651,9 @@ namespace boost
 
 #undef BOOST_OLD_IOSTREAMS
 
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) 
+    #pragma warning( pop )
+#endif
+
 #endif
 

include/boost/range/mfc.hpp

@@ -0,0 +1,984 @@
+#ifndef BOOST_RANGE_MFC_HPP
+#define BOOST_RANGE_MFC_HPP
+
+
+
+
+// Boost.Range MFC Extension
+//
+// Copyright Shunsuke Sogame 2005-2006.
+// Distributed under 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)
+
+
+
+
+// config
+//
+
+
+#include <afx.h> // _MFC_VER
+
+
+#if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+    #if (_MFC_VER < 0x0700) // dubious
+        #define BOOST_RANGE_MFC_NO_CPAIR
+    #endif
+#endif
+
+
+#if !defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+    #if (_MFC_VER < 0x0700) // dubious
+        #define BOOST_RANGE_MFC_HAS_LEGACY_STRING
+    #endif
+#endif
+
+
+// A const collection of old MFC doesn't return const reference.
+//
+#if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+    #if (_MFC_VER < 0x0700) // dubious
+        #define BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF
+    #endif
+#endif
+
+
+
+
+// forward declarations
+//
+
+
+template< class Type, class ArgType >
+class CArray;
+
+template< class Type, class ArgType >
+class CList;
+
+template< class Key, class ArgKey, class Mapped, class ArgMapped >
+class CMap;
+
+template< class BaseClass, class PtrType >
+class CTypedPtrArray;
+
+template< class BaseClass, class PtrType >
+class CTypedPtrList;
+
+template< class BaseClass, class KeyPtrType, class MappedPtrType >
+class CTypedPtrMap;
+
+
+
+
+// extended customizations
+//
+
+
+#include <cstddef> // ptrdiff_t
+#include <utility> // pair
+#include <boost/assert.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/range/atl.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/range/detail/microsoft.hpp>
+#include <boost/range/end.hpp>
+#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_categories.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/iterator/transform_iterator.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_pointer.hpp>
+#include <boost/utility/addressof.hpp>
+#include <afx.h> // legacy CString
+#include <afxcoll.h> // CXXXArray, CXXXList, CMapXXXToXXX
+#include <tchar.h>
+
+
+namespace boost { namespace range_detail_microsoft {
+
+
+    // mfc_ptr_array_iterator
+    //
+    // 'void **' is not convertible to 'void const **',
+    // so we define...
+    //
+
+    template< class ArrayT, class PtrType >
+    struct mfc_ptr_array_iterator;
+
+    template< class ArrayT, class PtrType >
+    struct mfc_ptr_array_iterator_super
+    {
+        typedef iterator_adaptor<
+            mfc_ptr_array_iterator<ArrayT, PtrType>,
+            std::ptrdiff_t, // Base!
+            PtrType,        // Value
+            random_access_traversal_tag,
+            use_default,
+            std::ptrdiff_t  // Difference
+        > type;
+    };
+
+    template< class ArrayT, class PtrType >
+    struct mfc_ptr_array_iterator :
+        mfc_ptr_array_iterator_super<ArrayT, PtrType>::type
+    {
+    private:
+        typedef mfc_ptr_array_iterator self_t;
+        typedef typename mfc_ptr_array_iterator_super<ArrayT, PtrType>::type super_t;
+        typedef typename super_t::reference ref_t;
+
+    public:
+        explicit mfc_ptr_array_iterator()
+        { }
+
+        explicit mfc_ptr_array_iterator(ArrayT& arr, INT_PTR index) :
+            super_t(index), m_parr(boost::addressof(arr))
+        { }
+
+    template< class, class > friend struct mfc_ptr_array_iterator;
+        template< class ArrayT_, class PtrType_ >
+        mfc_ptr_array_iterator(mfc_ptr_array_iterator<ArrayT_, PtrType_> const& other) :
+            super_t(other.base()), m_parr(other.m_parr)
+        { }
+
+    private:
+        ArrayT *m_parr;
+
+    friend class iterator_core_access;
+        ref_t dereference() const
+        {
+            BOOST_ASSERT(0 <= this->base() && this->base() < m_parr->GetSize() && "out of range");
+            return *( m_parr->GetData() + this->base() );
+        }
+
+        bool equal(self_t const& other) const
+        {
+            BOOST_ASSERT(m_parr == other.m_parr && "iterators incompatible");
+            return this->base() == other.base();
+        }
+    };
+
+    struct mfc_ptr_array_functions
+    {
+        template< class Iterator, class X >
+        Iterator begin(X& x)
+        {
+            return Iterator(x, 0);
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return Iterator(x, x.GetSize());
+        }
+    };
+
+
+    // arrays
+    //
+
+    template< >
+    struct customization< ::CByteArray > :
+        array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef BYTE val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CDWordArray > :
+        array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef DWORD val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CObArray > :
+        mfc_ptr_array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef mfc_ptr_array_iterator<X, CObject *> mutable_iterator;
+            typedef mfc_ptr_array_iterator<X const, CObject const *> const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CPtrArray > :
+        mfc_ptr_array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef mfc_ptr_array_iterator<X, void *> mutable_iterator;
+            typedef mfc_ptr_array_iterator<X const, void const *> const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CStringArray > :
+        array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef ::CString val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CUIntArray > :
+        array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef UINT val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CWordArray > :
+        array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef WORD val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+
+    // lists
+    //
+
+    template< >
+    struct customization< ::CObList > :
+        list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef list_iterator<X, ::CObject *> mutable_iterator;
+    #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+            typedef list_iterator<X const, ::CObject const *> const_iterator;
+    #else
+            typedef list_iterator<X const, ::CObject const * const, ::CObject const * const> const_iterator;
+    #endif
+        };
+    };
+
+
+    template< >
+    struct customization< ::CPtrList > :
+        list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef list_iterator<X, void *> mutable_iterator;
+    #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+            typedef list_iterator<X const, void const *> const_iterator;
+    #else
+            typedef list_iterator<X const, void const * const, void const * const> const_iterator;
+    #endif
+        };
+    };
+
+
+    template< >
+    struct customization< ::CStringList > :
+        list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef ::CString val_t;
+
+            typedef list_iterator<X, val_t> mutable_iterator;
+    #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+            typedef list_iterator<X const, val_t const> const_iterator;
+    #else
+            typedef list_iterator<X const, val_t const, val_t const> const_iterator;
+    #endif
+        };
+    };
+
+
+    // mfc_map_iterator
+    //
+
+    template< class MapT, class KeyT, class MappedT >
+    struct mfc_map_iterator;
+
+    template< class MapT, class KeyT, class MappedT >
+    struct mfc_map_iterator_super
+    {
+        typedef iterator_facade<
+            mfc_map_iterator<MapT, KeyT, MappedT>,
+            std::pair<KeyT, MappedT>,
+            forward_traversal_tag,
+            std::pair<KeyT, MappedT> const
+        > type;
+    };
+
+    template< class MapT, class KeyT, class MappedT >
+    struct mfc_map_iterator :
+        mfc_map_iterator_super<MapT, KeyT, MappedT>::type
+    {
+    private:
+        typedef mfc_map_iterator self_t;
+        typedef typename mfc_map_iterator_super<MapT, KeyT, MappedT>::type super_t;
+        typedef typename super_t::reference ref_t;
+
+    public:
+        explicit mfc_map_iterator()
+        { }
+
+        explicit mfc_map_iterator(MapT const& map, POSITION pos) :
+            m_pmap(boost::addressof(map)), m_posNext(pos)
+        {
+            increment();
+        }
+
+        explicit mfc_map_iterator(MapT const& map) :
+            m_pmap(&map), m_pos(0) // end iterator
+        { }
+
+    template< class, class, class > friend struct mfc_map_iterator;
+        template< class MapT_, class KeyT_, class MappedT_>
+        mfc_map_iterator(mfc_map_iterator<MapT_, KeyT_, MappedT_> const& other) :
+            m_pmap(other.m_pmap),
+            m_pos(other.m_pos), m_posNext(other.m_posNext),
+            m_key(other.m_key), m_mapped(other.m_mapped)
+        { }
+
+    private:
+        MapT const *m_pmap;
+        POSITION m_pos, m_posNext;
+        KeyT m_key; MappedT m_mapped;
+
+    friend class iterator_core_access;
+        ref_t dereference() const
+        {
+            BOOST_ASSERT(m_pos != 0 && "out of range");
+            return std::make_pair(m_key, m_mapped);
+        }
+
+        void increment()
+        {
+            BOOST_ASSERT(m_pos != 0 && "out of range");
+
+            if (m_posNext == 0) {
+                m_pos = 0;
+                return;
+            }
+
+            m_pos = m_posNext;
+            m_pmap->GetNextAssoc(m_posNext, m_key, m_mapped);
+        }
+
+        bool equal(self_t const& other) const
+        {
+            BOOST_ASSERT(m_pmap == other.m_pmap && "iterators incompatible");
+            return m_pos == other.m_pos;
+        }
+    };
+
+    struct mfc_map_functions
+    {
+        template< class Iterator, class X >
+        Iterator begin(X& x)
+        {
+            return Iterator(x, x.GetStartPosition());
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return Iterator(x);
+        }
+    };
+
+
+#if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+
+
+    // mfc_cpair_map_iterator
+    //
+    // used by ::CMap and ::CMapStringToString
+    //
+
+    template< class MapT, class PairT >
+    struct mfc_cpair_map_iterator;
+
+    template< class MapT, class PairT >
+    struct mfc_pget_map_iterator_super
+    {
+        typedef iterator_facade<
+            mfc_cpair_map_iterator<MapT, PairT>,
+            PairT,
+            forward_traversal_tag
+        > type;
+    };
+
+    template< class MapT, class PairT >
+    struct mfc_cpair_map_iterator :
+        mfc_pget_map_iterator_super<MapT, PairT>::type
+    {
+    private:
+        typedef mfc_cpair_map_iterator self_t;
+        typedef typename mfc_pget_map_iterator_super<MapT, PairT>::type super_t;
+        typedef typename super_t::reference ref_t;
+
+    public:
+        explicit mfc_cpair_map_iterator()
+        { }
+
+        explicit mfc_cpair_map_iterator(MapT& map, PairT *pp) :
+            m_pmap(boost::addressof(map)), m_pp(pp)
+        { }
+
+    template< class, class > friend struct mfc_cpair_map_iterator;
+        template< class MapT_, class PairT_>
+        mfc_cpair_map_iterator(mfc_cpair_map_iterator<MapT_, PairT_> const& other) :
+            m_pmap(other.m_pmap), m_pp(other.m_pp)
+        { }
+
+    private:
+        MapT  *m_pmap;
+        PairT *m_pp;
+
+    friend class iterator_core_access;
+        ref_t dereference() const
+        {
+            BOOST_ASSERT(m_pp != 0 && "out of range");
+            return *m_pp;
+        }
+
+        void increment()
+        {
+            BOOST_ASSERT(m_pp != 0 && "out of range");
+            m_pp = m_pmap->PGetNextAssoc(m_pp);
+        }
+
+        bool equal(self_t const& other) const
+        {
+            BOOST_ASSERT(m_pmap == other.m_pmap && "iterators incompatible");
+            return m_pp == other.m_pp;
+        }
+    };
+
+    struct mfc_cpair_map_functions
+    {
+        template< class Iterator, class X >
+        Iterator begin(X& x)
+        {
+            // Workaround:
+            // Assertion fails if empty.
+            // MFC document is wrong.
+    #if !defined(NDEBUG)
+            if (x.GetCount() == 0) 
+                return Iterator(x, 0);
+    #endif
+
+            return Iterator(x, x.PGetFirstAssoc());
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return Iterator(x, 0);
+        }
+    };
+
+
+#endif // !defined(BOOST_RANGE_MFC_NO_CPAIR)
+
+
+    // maps
+    //
+
+    template< >
+    struct customization< ::CMapPtrToWord > :
+        mfc_map_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef void *key_t;
+            typedef WORD mapped_t;
+
+            typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+            typedef mutable_iterator const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CMapPtrToPtr > :
+        mfc_map_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef void *key_t;
+            typedef void *mapped_t;
+
+            typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+            typedef mutable_iterator const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CMapStringToOb > :
+        mfc_map_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef ::CString key_t;
+            typedef ::CObject *mapped_t;
+
+            typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+            typedef mutable_iterator const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CMapStringToPtr > :
+        mfc_map_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef ::CString key_t;
+            typedef void *mapped_t;
+
+            typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+            typedef mutable_iterator const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CMapStringToString > :
+    #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+        mfc_cpair_map_functions
+    #else
+        mfc_map_functions
+    #endif
+    {
+        template< class X >
+        struct meta
+        {
+    #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+            typedef typename X::CPair pair_t;
+
+            typedef mfc_cpair_map_iterator<X, pair_t> mutable_iterator;
+            typedef mfc_cpair_map_iterator<X const, pair_t const> const_iterator;
+    #else
+            typedef ::CString key_t;
+            typedef ::CString mapped_t;
+
+            typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+            typedef mutable_iterator const_iterator;
+    #endif
+        };
+    };
+
+
+    template< >
+    struct customization< ::CMapWordToOb > :
+        mfc_map_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef WORD key_t;
+            typedef ::CObject *mapped_t;
+
+            typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+            typedef mutable_iterator const_iterator;
+        };
+    };
+
+
+    template< >
+    struct customization< ::CMapWordToPtr > :
+        mfc_map_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef WORD key_t;
+            typedef void *mapped_t;
+
+            typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+            typedef mutable_iterator const_iterator;
+        };
+    };
+
+
+    // templates
+    //
+
+    template< class Type, class ArgType >
+    struct customization< ::CArray<Type, ArgType> > :
+        array_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef Type val_t;
+
+            typedef val_t *mutable_iterator;
+            typedef val_t const *const_iterator;
+        };
+    };
+
+
+    template< class Type, class ArgType >
+    struct customization< ::CList<Type, ArgType> > :
+        list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef Type val_t;
+
+            typedef list_iterator<X, val_t> mutable_iterator;
+    #if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+            typedef list_iterator<X const, val_t const> const_iterator;
+    #else
+            typedef list_iterator<X const, val_t const, val_t const> const_iterator;
+    #endif
+        };
+    };
+
+
+    template< class Key, class ArgKey, class Mapped, class ArgMapped >
+    struct customization< ::CMap<Key, ArgKey, Mapped, ArgMapped> > :
+    #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+        mfc_cpair_map_functions
+    #else
+        mfc_map_functions
+    #endif
+    {
+        template< class X >
+        struct meta
+        {
+    #if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+            typedef typename X::CPair pair_t;
+
+            typedef mfc_cpair_map_iterator<X, pair_t> mutable_iterator;
+            typedef mfc_cpair_map_iterator<X const, pair_t const> const_iterator;
+    #else
+            typedef Key key_t;
+            typedef Mapped mapped_t;
+
+            typedef mfc_map_iterator<X, key_t, mapped_t> mutable_iterator;
+            typedef mutable_iterator const_iterator;
+    #endif            
+        };
+    };
+
+
+    template< class BaseClass, class PtrType >
+    struct customization< ::CTypedPtrArray<BaseClass, PtrType> >
+    {
+        template< class X >
+        struct fun
+        {
+            typedef typename remove_pointer<PtrType>::type val_t;
+
+            typedef typename mpl::if_< is_const<X>,
+                val_t const,
+                val_t
+            >::type val_t_;
+
+            typedef val_t_ * const result_type;
+
+            template< class PtrType_ >
+            result_type operator()(PtrType_ p) const
+            {
+                return static_cast<result_type>(p);
+            }
+        };
+
+        template< class X >
+        struct meta
+        {
+            typedef typename compatible_mutable_iterator<BaseClass>::type miter_t;
+            typedef typename range_const_iterator<BaseClass>::type citer_t;
+
+            typedef transform_iterator<fun<X>, miter_t> mutable_iterator;
+            typedef transform_iterator<fun<X const>, citer_t> const_iterator;
+        };
+
+        template< class Iterator, class X >
+        Iterator begin(X& x)
+        {
+            return Iterator(boost::begin<BaseClass>(x), fun<X>());
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return Iterator(boost::end<BaseClass>(x), fun<X>());
+        }
+    };
+
+
+    template< class BaseClass, class PtrType >
+    struct customization< ::CTypedPtrList<BaseClass, PtrType> > :
+        list_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef typename remove_pointer<PtrType>::type val_t;
+
+            // not l-value
+            typedef list_iterator<X, val_t * const, val_t * const> mutable_iterator;
+            typedef list_iterator<X const, val_t const * const, val_t const * const> const_iterator;
+        };
+    };
+
+
+    template< class BaseClass, class KeyPtrType, class MappedPtrType >
+    struct customization< ::CTypedPtrMap<BaseClass, KeyPtrType, MappedPtrType> > :
+        mfc_map_functions
+    {
+        template< class X >
+        struct meta
+        {
+            typedef mfc_map_iterator<X, KeyPtrType, MappedPtrType> mutable_iterator;
+            typedef mutable_iterator const_iterator;
+        };
+    };
+
+
+    // strings
+    //
+
+#if defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+    template< >
+    struct customization< ::CString >
+    {
+        template< class X >
+        struct meta
+        {
+            // LPTSTR/LPCTSTR is not always defined in <tchar.h>.
+            typedef TCHAR *mutable_iterator;
+            typedef TCHAR const *const_iterator;
+        };
+
+        template< class Iterator, class X >
+        typename mutable_<Iterator, X>::type begin(X& x)
+        {
+            return x.GetBuffer(0);
+        }
+
+        template< class Iterator, class X >
+        Iterator begin(X const& x)
+        {
+            return x;
+        }
+
+        template< class Iterator, class X >
+        Iterator end(X& x)
+        {
+            return begin<Iterator>(x) + x.GetLength();
+        }
+    };
+
+#endif // defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+
+} } // namespace boost::range_detail_microsoft
+
+
+
+
+// range customizations
+//
+
+
+// arrays
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CByteArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CDWordArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CStringArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CUIntArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CWordArray
+)
+
+
+// lists
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CObList
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CPtrList
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CStringList
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CObArray
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CPtrArray
+)
+
+
+// maps
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CMapPtrToWord
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CMapPtrToPtr
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CMapStringToOb
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CMapStringToPtr
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CMapStringToString
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CMapWordToOb
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CMapWordToPtr
+)
+
+
+// templates
+//
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CArray, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CList, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CMap, 4
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CTypedPtrArray, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CTypedPtrList, 2
+)
+
+BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TEMPLATE(
+    boost::range_detail_microsoft::using_type_as_tag,
+    BOOST_PP_NIL, CTypedPtrMap, 3
+)
+
+
+// strings
+//
+#if defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+    BOOST_RANGE_DETAIL_MICROSOFT_CUSTOMIZATION_TYPE(
+        boost::range_detail_microsoft::using_type_as_tag,
+        BOOST_PP_NIL, CString
+    )
+
+#endif
+
+
+
+
+#endif

include/boost/range/size.hpp

@@ -17,14 +17,17 @@
 
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
-#include <boost/range/size_type.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/assert.hpp>
 
 namespace boost 
 {
 
     template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_size<T>::type size( const T& r )
+    inline BOOST_DEDUCED_TYPENAME range_difference<T>::type size( const T& r )
     {
+        BOOST_ASSERT( (boost::end( r ) - boost::begin( r )) >= 0 &&
+                      "reachability invariant broken!" );
         return boost::end( r ) - boost::begin( r );
     }
 

include/boost/range/sub_range.hpp

@@ -11,12 +11,20 @@
 #ifndef BOOST_RANGE_SUB_RANGE_HPP
 #define BOOST_RANGE_SUB_RANGE_HPP
 
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) 
+    #pragma warning( push )
+    #pragma warning( disable : 4996 )
+#endif
+
+#include <boost/detail/workaround.hpp>
 #include <boost/range/config.hpp>
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/range/size_type.hpp>
 #include <boost/range/difference_type.hpp>
 #include <boost/assert.hpp>
+#include <boost/type_traits/is_reference.hpp>
+#include <boost/type_traits/remove_reference.hpp>
 
 namespace boost
 {
@@ -34,20 +42,23 @@ namespace boost
         typedef BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type   const_iterator;
         typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type       difference_type;
         typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type             size_type;
+        typedef BOOST_DEDUCED_TYPENAME base::reference                            reference;
+        
+    public: // for return value of front/back
+        typedef BOOST_DEDUCED_TYPENAME 
+                boost::mpl::if_< boost::is_reference<reference>,
+                                 const BOOST_DEDUCED_TYPENAME boost::remove_reference<reference>::type&, 
+                                 reference >::type const_reference;
 
     public:
         sub_range() : base() 
         { }
-
-/*        
-        template< class ForwardRange2 >
-        sub_range( sub_range<ForwardRange2> r ) :
-
-#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
-            base( impl::adl_begin( r ), impl::adl_end( r ) )
-#else
-            base( r )
-#endif */
+        
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) ) 
+        sub_range( const sub_range& r ) 
+            : base( static_cast<const base&>( r ) )  
+        { }  
+#endif
 
         template< class ForwardRange2 >
         sub_range( ForwardRange2& r ) : 
@@ -86,15 +97,11 @@ namespace boost
         {
             base::operator=( r );
             return *this;
-        }
+        }   
 
-        sub_range& operator=( sub_range r )
+        sub_range& operator=( const sub_range& r )
         {
-            //
-            // argument passed by value to avoid 
-            // const_iterator to iterator conversion
-            //
-            base::operator=( r );
+            base::operator=( static_cast<const base&>(r) );
             return *this;            
         }
         
@@ -104,36 +111,36 @@ namespace boost
         const_iterator  begin() const    { return base::begin(); }
         iterator        end()            { return base::end();   }
         const_iterator  end() const      { return base::end();   }
-        size_type       size() const     { return base::size();  }   
+        difference_type size() const     { return base::size();  }   
 
         
     public: // convenience
-        value_type& front()
+        reference front()
         {
             return base::front();
         }
 
-        const value_type& front() const
+        const_reference front() const
         {
             return base::front();
         }
 
-        value_type& back()
+        reference back()
         {
             return base::back();
         }
 
-        const value_type& back() const
+        const_reference back() const
         {
             return base::back();
         }
 
-        value_type& operator[]( size_type sz )
+        reference operator[]( difference_type sz )
         {
             return base::operator[](sz);
         }
 
-        const value_type& operator[]( size_type sz ) const
+        const_reference operator[]( difference_type sz ) const
         {
             return base::operator[](sz);
         }
@@ -164,5 +171,9 @@ namespace boost
 
 } // namespace 'boost'
 
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) 
+    #pragma warning( pop )
+#endif
+
 #endif
 

index.html

@@ -18,11 +18,11 @@
   </table>
 
   <p>
-  Copyright <20> 2003-2004 Thorsten Ottosen
+  Copyright <20> 2003-2007 Thorsten Ottosen
   </p>
   <p>
   Use, modification and distribution is subject to the Boost Software License, Version 1.0
-  (see <a href=http://www.boost.org/LICENSE_1_0.txt>
+  (see <a href="http://www.boost.org/LICENSE_1_0.txt">
    http://www.boost.org/LICENSE_1_0.txt</a>).
   </p>
 
@@ -34,7 +34,7 @@
   </p>
   
   <ul>
-      <li> <a href="doc/intro.html">Introduction </a></code>
+      <li> <a href="doc/intro.html">Introduction </a>
           
       <li><a href="doc/range.html">Range concepts:</a>
       <ul>
@@ -51,17 +51,17 @@
 
       <li> <a href="doc/style.html">Terminology and style guidelines </a>
       <li><a href="doc/headers.html">Headers</a> </li>
-      <li><a href="doc/examples.html">Examples</a>    
+      <li><a href="doc/examples.html">Examples</a>  
+          <li><a href="doc/mfc_atl.html">MFC/ATL mapping (courtesy of Shunsuke
+              Sogame)</a></li>  
       <li><a href="doc/portability.html">Portability</a>
+          <li><a href="doc/upgrading.html">Upgrading from Boost v. 
+              1.34.*</a></li>
       <li><a href="doc/faq.html">FAQ</a>    
       <li><a href="doc/history_ack.html">History and acknowledgment</a>    
           
   </ul>
 
-  <hr>
-  <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
-  </p>
 
   <br>
   <br>

test/Jamfile.v2

@@ -12,9 +12,9 @@ rule range-test ( name : includes * )
 {
     return [
         run $(name).cpp /boost/test//boost_unit_test_framework/<link>static
+        :
         : 
-        : 
-        : $(includes)
+        : <toolset>gcc:<cxxflags>"-Wall -Wunused "
         ] ;
 }
 

test/TODO

@@ -1 +0,0 @@
-

test/algorithm_example.cpp

@@ -37,7 +37,7 @@ namespace
     }
     
     template< typename Range, typename T >
-    inline typename boost::range_const_iterator<Range>::type 
+    inline typename boost::range_iterator<Range>::type 
     find( const Range& c, const T& value )
     {
        return std::find( boost::begin( c ), boost::end( c ), value );
@@ -47,7 +47,7 @@ namespace
     // replace first value and return its index
     //                                
     template< class Range, class T >
-    inline typename boost::range_size<Range>::type
+    inline typename boost::range_difference<Range>::type
     my_generic_replace( Range& c, const T& value, const T& replacement )
     {
        typename boost::range_iterator<Range>::type found = find( c, value );
@@ -64,14 +64,14 @@ void check_algorithm()
     //
     // usage
     //
-    const unsigned N = 5;                     
+    const int N = 5;                     
     std::vector<int> my_vector;
     int values[] = { 1,2,3,4,5,6,7,8,9 };
     my_vector.assign( values, values + 9 );
     typedef std::vector<int>::iterator iterator;
     std::pair<iterator,iterator>       my_view( boost::begin( my_vector ), 
                                                 boost::begin( my_vector ) + N );
-    BOOST_CHECK_EQUAL( my_generic_replace( my_vector, 4, 2 ), 3u );
+    BOOST_CHECK_EQUAL( my_generic_replace( my_vector, 4, 2 ), 3 );
     BOOST_CHECK_EQUAL( my_generic_replace( my_view, 4, 2 ), N );
 
 }

test/array.cpp

@@ -62,6 +62,8 @@ void check_array()
     BOOST_CHECK_EQUAL( end( ca ), ca + size( ca ) );
     BOOST_CHECK_EQUAL( empty( ca ),false );
 
+    const char A[] = "\0A";
+    BOOST_CHECK_EQUAL( boost::size(A), 3 );
 }
 
 using boost::unit_test::test_suite;

test/atl.cpp

@@ -0,0 +1,623 @@
+
+
+// Boost.Range ATL Extension
+//
+// Copyright Shunsuke Sogame 2005-2006.
+// Distributed under 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 <pstade/vodka/drink.hpp>
+
+#include <boost/test/test_tools.hpp>
+#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS
+#define _ATL_NO_AUTOMATIC_NAMESPACE
+
+#define BOOST_LIB_NAME boost_test_exec_monitor
+#include <boost/config/auto_link.hpp>
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_TEST
+#include <boost/range/atl.hpp> // can be placed first
+
+
+#include <map>
+#include <string>
+#include <boost/concept_check.hpp>
+#include <boost/mpl/if.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/distance.hpp>
+#include <boost/range/iterator_range.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits/is_same.hpp>
+
+
+#include <boost/foreach.hpp>
+
+
+#include <atlbase.h> // for ATL3 CSimpleArray/CSimpleValArray
+#if !(_ATL_VER < 0x0700)
+    #include <atlcoll.h>
+    #include <cstringt.h>
+    #include <atlsimpstr.h>
+    #include <atlstr.h>
+#endif
+
+
+namespace brdm = boost::range_detail_microsoft;
+
+
+#if !(_ATL_VER < 0x0700)
+
+
+template< class ArrayT, class SampleRange >
+bool test_init_auto_ptr_array(ArrayT& arr, SampleRange& sample)
+{
+    typedef typename boost::range_iterator<SampleRange>::type iter_t;
+
+    for (iter_t it = boost::begin(sample), last = boost::end(sample); it != last; ++it) {
+        arr.Add(*it); // moves ownership
+    }
+
+    return boost::distance(arr) == boost::distance(sample);
+}
+
+
+template< class ListT, class SampleRange >
+bool test_init_auto_ptr_list(ListT& lst, SampleRange& sample)
+{
+    typedef typename boost::range_iterator<SampleRange>::type iter_t;
+    typedef typename boost::range_value<SampleRange>::type val_t;
+
+    for (iter_t it = boost::begin(sample), last = boost::end(sample); it != last; ++it) {
+        lst.AddTail(*it); // moves ownership
+    }
+
+    return boost::distance(lst) == boost::distance(sample);
+}
+
+
+// Workaround:
+// CRBTree provides no easy access function, but yes, it is the range!
+//
+template< class AtlMapT, class KeyT, class MappedT >
+bool test_atl_map_has(AtlMapT& map, const KeyT& k, const MappedT m)
+{
+    typedef typename boost::range_iterator<AtlMapT>::type iter_t;
+
+    for (iter_t it = boost::begin(map), last = boost::end(map); it != last; ++it) {
+        if (it->m_key == k && it->m_value == m)
+            return true;
+    }
+
+    return false;
+}
+
+
+template< class AtlMapT, class MapT >
+bool test_atl_map(AtlMapT& map, const MapT& sample)
+{
+    typedef typename boost::range_iterator<AtlMapT>::type iter_t;
+    typedef typename boost::range_const_iterator<MapT>::type siter_t;
+
+    bool result = true;
+
+    result = result && (boost::distance(map) == boost::distance(sample));
+    if (!result)
+        return false;
+
+    {
+        for (iter_t it = boost::begin(map), last = boost::end(map); it != last; ++it) {
+            result = result && brdm::test_find_key_and_mapped(sample, std::make_pair(it->m_key, it->m_value));
+        }
+    }
+
+    {
+        for (siter_t it = boost::begin(sample), last = boost::end(sample); it != last; ++it) {
+            result = result && (test_atl_map_has)(map, it->first, it->second);
+        }
+    }
+
+    return result;
+}
+
+
+template< class MapT, class SampleMap >
+bool test_init_atl_multimap(MapT& map, const SampleMap& sample)
+{
+    typedef typename boost::range_const_iterator<SampleMap>::type iter_t;
+
+    for (iter_t it = boost::const_begin(sample), last = boost::const_end(sample); it != last; ++it) {
+        map.Insert(it->first, it->second);
+    }
+
+    return boost::distance(map) == boost::distance(sample);
+}
+
+
+// arrays
+//
+
+template< class Range >
+void test_CAtlArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ATL::CAtlArray<val_t> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, val_t *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, val_t const*>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class ValT, class Range >
+void test_CAutoPtrArray(Range& sample)
+{
+    typedef ValT val_t;
+
+    typedef ATL::CAutoPtrArray<val_t> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, boost::indirect_iterator< ATL::CAutoPtr<val_t> *> >::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, boost::indirect_iterator< ATL::CAutoPtr<val_t> const*> >::value ));
+
+    rng_t rng;
+    BOOST_CHECK( ::test_init_auto_ptr_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class I, class Range >
+void test_CInterfaceArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ATL::CInterfaceArray<I> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, ATL::CComQIPtr<I> * >::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, ATL::CComQIPtr<I> const* >::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+// lists
+//
+
+template< class Range >
+void test_CAtlList(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ATL::CAtlList<val_t> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter< rng_t, brdm::list_iterator<rng_t,       val_t> >::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, val_t const> >::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_list(rng, sample) );
+    BOOST_CHECK( brdm::test_bidirectional(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class ValT, class Range >
+void test_CAutoPtrList(Range& sample)
+{
+    typedef ValT val_t;
+
+    typedef ATL::CAutoPtrList<val_t> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter< rng_t, boost::indirect_iterator< brdm::list_iterator<rng_t,       ATL::CAutoPtr<val_t> > > >::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, boost::indirect_iterator< brdm::list_iterator<rng_t const, ATL::CAutoPtr<val_t> const> > >::value ));
+
+    rng_t rng;
+    BOOST_CHECK( ::test_init_auto_ptr_list(rng, sample) );
+    BOOST_CHECK( brdm::test_bidirectional(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class ValT, class Range >
+void test_CHeapPtrList(const Range& sample)
+{
+    typedef ValT val_t;
+
+    typedef ATL::CHeapPtrList<val_t> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter< rng_t, boost::indirect_iterator< brdm::list_iterator<rng_t,       ATL::CHeapPtr<val_t> > > >::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, boost::indirect_iterator< brdm::list_iterator<rng_t const, ATL::CHeapPtr<val_t> const> > >::value ));
+
+    rng_t rng;
+    BOOST_CHECK( ::test_init_auto_ptr_list(rng, sample) );
+    BOOST_CHECK( brdm::test_bidirectional(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class I, class Range >
+void test_CInterfaceList(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ATL::CInterfaceList<I> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter< rng_t, brdm::list_iterator<rng_t,       ATL::CComQIPtr<I> > >::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, ATL::CComQIPtr<I> const> >::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_list(rng, sample) );
+    BOOST_CHECK( brdm::test_bidirectional(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+// strings
+//
+
+template< class Range >
+void test_CSimpleStringT(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef typename boost::mpl::if_< boost::is_same<val_t, char>,
+        ATL::CAtlStringA,
+        ATL::CAtlStringW
+    >::type derived_t;
+
+    typedef ATL::CSimpleStringT<val_t> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, typename rng_t::PXSTR>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, typename rng_t::PCXSTR>::value ));
+
+    derived_t drng;
+    rng_t& rng = drng;
+    BOOST_CHECK( brdm::test_init_string(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    // BOOST_CHECK( brdm::test_emptiness(rng) ); no default constructible
+}
+
+
+template< int n, class Range >
+void test_CFixedStringT(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef typename boost::mpl::if_< boost::is_same<val_t, char>,
+        ATL::CAtlStringA,
+        ATL::CAtlStringW
+    >::type base_t;
+
+    typedef ATL::CFixedStringT<base_t, n> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, typename rng_t::PXSTR>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, typename rng_t::PCXSTR>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_string(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CStringT(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef typename boost::mpl::if_< boost::is_same<val_t, char>,
+        ATL::CAtlStringA, // == CStringT<char, X>
+        ATL::CAtlStringW  // == CStringT<wchar_t, X>
+    >::type rng_t;
+
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, typename rng_t::PXSTR>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, typename rng_t::PCXSTR>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_string(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CStaticString(const Range& sample)
+{
+#if !defined(BOOST_RANGE_ATL_NO_TEST_UNDOCUMENTED_RANGE)
+    {
+        typedef ATL::CStaticString<char, 20> rng_t;
+        BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, char const *>::value ));
+        BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, char const *>::value ));
+
+        rng_t rng("hello static string");
+        BOOST_CHECK( *(boost::begin(rng)+4) == 'o' );
+        BOOST_CHECK( *(boost::end(rng)-3) == 'i' );
+    }
+
+    {
+        typedef ATL::CStaticString<wchar_t, 40> rng_t;
+        BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, wchar_t const *>::value ));
+        BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, wchar_t const *>::value ));
+
+        rng_t rng(L"hello static string");
+        BOOST_CHECK( *(boost::begin(rng)+4) == L'o' );
+        BOOST_CHECK( *(boost::end(rng)-3) == L'i' );
+    }
+#endif
+
+    (void)sample; // unused
+}
+
+
+#endif // !(_ATL_VER < 0x0700) 
+
+
+template< class Range >
+void test_CComBSTR(const Range& sample)
+{
+    typedef ATL::CComBSTR rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, OLECHAR *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, OLECHAR const*>::value ));
+
+    rng_t rng(OLESTR("hello CComBSTR range!"));
+    BOOST_CHECK( brdm::test_equals(rng, std::string("hello CComBSTR range!")) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+
+    (void)sample; // unused
+}
+
+
+// simples
+//
+
+template< class Range >
+void test_CSimpleArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ATL::CSimpleArray<val_t> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, val_t *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, val_t const*>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CSimpleMap(const Range& sample)
+{
+#if !defined(BOOST_RANGE_ATL_NO_TEST_UNDOCUMENTED_RANGE)
+
+    typedef ATL::CSimpleMap<int, double> rng_t;
+
+    rng_t rng;
+    rng.Add(3, 3.0);
+    rng.Add(4, 2.0);
+
+    BOOST_CHECK( boost::begin(rng)->get<0>() == 3.0 );
+    BOOST_CHECK( (boost::end(rng)-1)->get<1>() == 2.0 );
+
+#endif
+
+    (void)sample; // unused
+}
+
+
+template< class Range >
+void test_CSimpleValArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ATL::CSimpleArray<val_t> rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, val_t *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, val_t const*>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+// maps
+//
+
+template< class MapT >
+void test_CAtlMap(const MapT& sample)
+{
+    typedef typename MapT::key_type k_t;
+    typedef typename MapT::mapped_type m_t;
+
+    typedef ATL::CAtlMap<k_t, m_t> rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+    BOOST_CHECK( ::test_atl_map(rng, sample) );
+}
+
+
+template< class MapT >
+void test_CRBTree(const MapT& sample)
+{
+    typedef typename MapT::key_type k_t;
+    typedef typename MapT::mapped_type m_t;
+
+    typedef ATL::CRBMap<k_t, m_t> derived_t;
+    typedef ATL::CRBTree<k_t, m_t> rng_t;
+
+    derived_t drng;
+    rng_t& rng = drng;
+
+    boost::function_requires< boost::BidirectionalRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(drng, sample) );
+    BOOST_CHECK( ::test_atl_map(rng, sample) );
+}
+
+
+template< class MapT >
+void test_CRBMap(const MapT& sample)
+{
+    typedef typename MapT::key_type k_t;
+    typedef typename MapT::mapped_type m_t;
+
+    typedef ATL::CRBMap<k_t, m_t> rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::BidirectionalRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+    BOOST_CHECK( ::test_atl_map(rng, sample) );
+}
+
+
+template< class MapT >
+void test_CRBMultiMap(const MapT& sample)
+{
+    typedef typename MapT::key_type k_t;
+    typedef typename MapT::mapped_type m_t;
+
+    typedef ATL::CRBMultiMap<k_t, m_t> rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::BidirectionalRangeConcept<rng_t> >();
+    BOOST_CHECK( ::test_init_atl_multimap(rng, sample) );
+    BOOST_CHECK( ::test_atl_map(rng, sample) );
+}
+
+
+// main test
+//
+
+void test_atl()
+{
+
+    // ordinary ranges
+    //
+    {
+        std::string sample("rebecca judy and mary whiteberry chat monchy");
+#if !(_ATL_VER < 0x0700)
+        ::test_CAtlArray(sample);
+        ::test_CAtlList(sample);
+        ::test_CSimpleStringT(sample);
+        ::test_CFixedStringT<44>(sample);
+        ::test_CStringT(sample);
+        ::test_CStaticString(sample);
+#endif
+        ::test_CComBSTR(sample);
+        ::test_CSimpleArray(sample);
+        ::test_CSimpleMap(sample);
+        ::test_CSimpleValArray(sample);
+    }
+
+
+    {
+        std::wstring sample(L"rebecca judy and mary whiteberry chat monchy");
+#if !(_ATL_VER < 0x0700)
+        ::test_CAtlArray(sample);
+        ::test_CAtlList(sample);
+        ::test_CSimpleStringT(sample);
+        ::test_CFixedStringT<44>(sample);
+        ::test_CStringT(sample);
+        ::test_CStaticString(sample);
+#endif
+        ::test_CComBSTR(sample);
+        ::test_CSimpleArray(sample);
+        ::test_CSimpleMap(sample);
+        ::test_CSimpleValArray(sample);
+    }
+
+    // pointer ranges
+    //
+#if !(_ATL_VER < 0x0700)
+    {
+        typedef ATL::CAutoPtr<int> ptr_t;
+        ptr_t
+            ptr0(new int(3)), ptr1(new int(4)), ptr2(new int(5)), ptr3(new int(4)),
+            ptr4(new int(1)), ptr5(new int(2)), ptr6(new int(4)), ptr7(new int(0));
+
+        ptr_t ptrs[8] = {
+            ptr0, ptr1, ptr2, ptr3, ptr4, ptr5, ptr6, ptr7
+        };
+
+        boost::iterator_range< ptr_t * > workaround(ptrs, ptrs+8);
+        ::test_CAutoPtrArray<int>(workaround);
+    }
+
+    {
+        typedef ATL::CAutoPtr<int> ptr_t;
+        ptr_t
+            ptr0(new int(3)), ptr1(new int(4)), ptr2(new int(5)), ptr3(new int(4)),
+            ptr4(new int(1)), ptr5(new int(2)), ptr6(new int(4)), ptr7(new int(0));
+
+        ptr_t ptrs[8] = {
+            ptr0, ptr1, ptr2, ptr3, ptr4, ptr5, ptr6, ptr7
+        };
+
+        boost::iterator_range< ptr_t * > workaround(ptrs, ptrs+8);
+        ::test_CAutoPtrList<int>(workaround);
+    }
+
+    {
+        typedef ATL::CHeapPtr<int> ptr_t;
+        ptr_t ptrs[5]; {
+            ptrs[0].AllocateBytes(sizeof(int));
+            ptrs[1].AllocateBytes(sizeof(int));
+            ptrs[2].AllocateBytes(sizeof(int));
+            ptrs[3].AllocateBytes(sizeof(int));
+            ptrs[4].AllocateBytes(sizeof(int));
+        }
+
+        boost::iterator_range< ptr_t * > workaround(ptrs, ptrs+5);
+        ::test_CHeapPtrList<int>(workaround);
+    }
+
+
+    {
+        typedef ATL::CComQIPtr<IDispatch> ptr_t;
+        ptr_t ptrs[8];
+
+        boost::iterator_range< ptr_t * > workaround(ptrs, ptrs+8);
+        ::test_CInterfaceArray<IDispatch>(workaround);
+        ::test_CInterfaceList<IDispatch>(workaround);
+    }
+#endif
+
+    // maps
+    //
+    {
+#if !(_ATL_VER < 0x0700)
+        std::map<int, std::string> sample; {
+            sample[0] = "hello";
+            sample[1] = "range";
+            sample[2] = "atl";
+            sample[3] = "mfc";
+            sample[4] = "collections";
+        }
+
+        ::test_CAtlMap(sample);
+        ::test_CRBTree(sample);
+        ::test_CRBMap(sample);
+        ::test_CRBMultiMap(sample);
+#endif
+    }
+
+
+} // test_atl
+
+
+#include <boost/test/unit_test.hpp>
+using boost::unit_test::test_suite;
+
+
+test_suite *
+init_unit_test_suite(int argc, char* argv[])
+{
+    test_suite *test = BOOST_TEST_SUITE("ATL Range Test Suite");
+    test->add(BOOST_TEST_CASE(&test_atl));
+
+    (void)argc, (void)argv; // unused
+    return test;
+}

test/extension_mechanism.cpp

@@ -44,7 +44,6 @@ namespace Foo
                 typedef std::vector<int>       data_t;
                 typedef data_t::iterator       iterator;
                 typedef data_t::const_iterator const_iterator;
-                typedef data_t::size_type      size_type;
 
                 data_t vec;
 

test/iterator_pair.cpp

@@ -15,6 +15,7 @@
 #  pragma warn -8057 // unused argument argc/argv in Boost.Test
 #endif
 
+#include <boost/range/concepts.hpp>
 #include <boost/range/functions.hpp>
 #include <boost/range/metafunctions.hpp>
 #include <boost/static_assert.hpp>
@@ -64,17 +65,17 @@ void check_iterator_pair()
     BOOST_CHECK( begin( pair ) == pair.first );
     BOOST_CHECK( end( pair )   == pair.second );
     BOOST_CHECK( empty( pair ) == (pair.first == pair.second) );
-    BOOST_CHECK( size( pair )  == std::size_t( std::distance( pair.first, pair.second ) ) );
+    BOOST_CHECK( size( pair )  == std::distance( pair.first, pair.second ) );
     
     BOOST_CHECK( begin( const_pair ) == const_pair.first );
     BOOST_CHECK( end( const_pair )   == const_pair.second );
     BOOST_CHECK( empty( const_pair ) == (const_pair.first == const_pair.second) );
-    BOOST_CHECK( size( const_pair )  == std::size_t( std::distance( const_pair.first, const_pair.second ) ) );
+    BOOST_CHECK( size( const_pair )  == std::distance( const_pair.first, const_pair.second ) );
 
     BOOST_CHECK( begin( constness_pair ) == constness_pair.first );
     BOOST_CHECK( end( constness_pair )   == constness_pair.second );
     BOOST_CHECK( empty( constness_pair ) == (constness_pair.first == const_pair.second) );
-    BOOST_CHECK( size( constness_pair )  == std::size_t( std::distance( constness_pair.first, constness_pair.second ) ) );
+    BOOST_CHECK( size( constness_pair )  == std::distance( constness_pair.first, constness_pair.second ) );
 
 }
 

test/iterator_range.cpp

@@ -19,6 +19,7 @@
 
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/functions.hpp>
+#include <boost/range/as_literal.hpp> 
 #include <boost/test/test_tools.hpp>
 #include <boost/test/unit_test.hpp>
 #include <iostream>
@@ -79,12 +80,12 @@ void check_iterator_range()
     BOOST_CHECK( rr.equal( r ) );
 
     rr  = make_iterator_range( str.begin(), str.begin() + 5 );
-    BOOST_CHECK( rr == "hello" );
-    BOOST_CHECK( rr != "hell" );
-    BOOST_CHECK( rr < "hello dude" );
-    BOOST_CHECK( "hello" == rr );
-    BOOST_CHECK( "hell"  != rr );
-    BOOST_CHECK( ! ("hello dude" < rr ) );
+    BOOST_CHECK( rr == as_literal("hello") );
+    BOOST_CHECK( rr != as_literal("hell") );
+    BOOST_CHECK( rr < as_literal("hello dude") );
+    BOOST_CHECK( as_literal("hello") == rr );
+    BOOST_CHECK( as_literal("hell")  != rr );
+    BOOST_CHECK( ! (as_literal("hello dude") < rr ) );
     irange rrr = rr;
     BOOST_CHECK( rrr == rr );
     BOOST_CHECK( !( rrr != rr ) );
@@ -94,9 +95,10 @@ void check_iterator_range()
     BOOST_CHECK_EQUAL( cr.front(), 'h' );
     BOOST_CHECK_EQUAL( cr.back(), 'd' );
     BOOST_CHECK_EQUAL( cr[1], 'e' );
+    BOOST_CHECK_EQUAL( cr(1), 'e' );
 
     rrr = make_iterator_range( str, 1, -1 );
-    BOOST_CHECK( rrr == "ello worl" );
+    BOOST_CHECK( rrr == as_literal("ello worl") );
     rrr = make_iterator_range( rrr, -1, 1 );
     BOOST_CHECK( rrr == str );
 

test/mfc.cpp

@@ -1,86 +1,743 @@
-// Boost.Range library
-//
-//  Copyright Thorsten Ottosen 2003-2004. 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)
-//
-// For more information, see http://www.boost.org/libs/range/
+// Boost.Range MFC Extension
 //
+// Copyright Shunsuke Sogame 2005-2006.
+// Distributed under 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)
 
-#define _MSL_USING_NAMESPACE 1
 
-#include <boost/detail/workaround.hpp>
+#include <afx.h> // must be here
 
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-#  pragma warn -8091 // supress warning in Boost.Test
-#  pragma warn -8057 // unused argument argc/argv in Boost.Test
-#endif
-
-#define BOOST_RANGE_ENABLE_MFC
-#define BOOST_RANGE_ENABLE_MCF_CARRAY
-
-/*
-#define WIN32
-#define _WINDOWS
-#define _MBCS
-#define _AFXDLL
-#define _ATL_DLL
-*/
-
-///Od /D "WIN32" /D "_WINDOWS" /D "_DEBUG" /D "_MBCS" /D "_AFXDLL" /D "_ATL_DLL" /Gm /EHsc /RTC1 
-// /MDd /Zc:wchar_t /Yu"stdafx.h" /Fp"Debug/Foo.pch" /Fo"Debug/" /Fd"Debug/vc70.pdb" /W3 /nologo /c /Wp64 /ZI /TP
-
-#include <boost/range.hpp>
-#include <boost/range/detail/mfc/carray.hpp>
-#include <boost/range/detail/mfc/cstring.hpp>
+// #include <pstade/vodka/drink.hpp>
 
 #include <boost/test/test_tools.hpp>
-#include <boost/config.hpp>
+#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS
+#define _ATL_NO_AUTOMATIC_NAMESPACE
+
+#define BOOST_LIB_NAME boost_test_exec_monitor
+#include <boost/config/auto_link.hpp>
+
+#define BOOST_RANGE_DETAIL_MICROSOFT_TEST
+#include <boost/range/mfc.hpp> // can be placed first
 
 
-void check_mfc()
+#include <map>
+#include <boost/concept_check.hpp>
+// #include <boost/foreach.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/concepts.hpp>
+#include <boost/range/end.hpp>
+#include <boost/static_assert.hpp>
+#include <boost/algorithm/string.hpp>
+
+
+#include <afx.h>
+#include <afxcoll.h>
+#include <afxtempl.h>
+
+#if !(_ATL_VER < 0x0700)
+    #include <cstringt.h>
+    #include <atlsimpstr.h>
+    #include <atlstr.h>
+#endif
+
+
+namespace brdm = boost::range_detail_microsoft;
+
+
+// helpers
+//
+
+template< class MfcMapT, class MapT >
+bool test_mfc_map(MfcMapT& map, const MapT& sample)
 {
-    CString s = "hello world";
-    BOOST_CHECK( boost::begin( s ) + boost::size( s ) == boost::end( s ) );
-    BOOST_CHECK( boost::size( s ) == boost::size( "hello world" ) );
-    BOOST_CHECK( !boost::empty( s ) );
-    const CString cs( s );
-    BOOST_CHECK( boost::begin( cs ) + boost::size( cs ) == boost::end( cs ) );
-    BOOST_CHECK( boost::size( cs ) == boost::size( "hello world" ) );
-    BOOST_CHECK( !boost::empty( cs ) );
-    
-    CArray<int,int> a;
-    BOOST_CHECK( boost::empty( a ) );
-    a.Add( 5 );
-    a.Add( 10 );
-    BOOST_CHECK( boost::begin( a ) + boost::size( a ) == boost::end( a ) );
-    BOOST_CHECK( boost::size( a ) == 2 );
-    BOOST_CHECK( !boost::empty( a ) );
-    const CArray<int,int>& ca = a;
-    BOOST_CHECK( boost::begin( ca ) + boost::size( ca ) == boost::end( ca ) );
-    BOOST_CHECK( boost::size( ca ) == 2 );
-    BOOST_CHECK( !boost::empty( ca ) );
-    
+    typedef typename boost::range_iterator<MfcMapT>::type iter_t;
+    typedef typename boost::range_const_iterator<MapT>::type siter_t;
+
+    bool result = true;
+
+    result = result && (boost::distance(map) == boost::distance(sample));
+    if (!result)
+        return false;
+
+    {
+        for (iter_t it = boost::begin(map), last = boost::end(map); it != last; ++it) {
+            result = result && brdm::test_find_key_and_mapped(sample, *it);
+        }
+    }
+
+    {
+        for (siter_t it = boost::begin(sample), last = boost::end(sample); it != last; ++it) {
+            result = result && (map[it->first] == it->second);
+        }
+    }
+
+    return result;
 }
 
 
+template< class MfcMapT, class MapT >
+bool test_mfc_cpair_map(MfcMapT& map, const MapT& sample)
+{
+    typedef typename boost::range_iterator<MfcMapT>::type iter_t;
+    typedef typename boost::range_const_iterator<MapT>::type siter_t;
+
+    bool result = true;
+
+    result = result && (boost::distance(map) == boost::distance(sample));
+    if (!result)
+        return false;
+
+    {
+        for (iter_t it = boost::begin(map), last = boost::end(map); it != last; ++it) {
+            result = result && brdm::test_find_key_and_mapped(sample, std::make_pair(it->key, it->value));
+        }
+    }
+
+    {
+        for (siter_t it = boost::begin(sample), last = boost::end(sample); it != last; ++it) {
+            result = result && (map[it->first] == it->second);
+        }
+    }
+
+    return result;
+}
+
+
+// arrays
+//
+template< class Range >
+void test_CByteArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CByteArray rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, BYTE *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, BYTE const*>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CDWordArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CDWordArray rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, DWORD *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, DWORD const*>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CObArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CObArray rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, brdm::mfc_ptr_array_iterator<rng_t, ::CObject *> >::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, brdm::mfc_ptr_array_iterator<const rng_t, const ::CObject *> >::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CPtrArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CPtrArray rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, brdm::mfc_ptr_array_iterator<rng_t, void *> >::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, brdm::mfc_ptr_array_iterator<const rng_t, const void *> >::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CStringArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CStringArray rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, ::CString *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, ::CString const *>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CUIntArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CUIntArray rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, UINT *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, UINT const *>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CWordArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CWordArray rng_t;
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, WORD *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, WORD const *>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+// lists
+//
+
+template< class Range >
+void test_CObList(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CObList rng_t;
+
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter< rng_t, brdm::list_iterator<rng_t,       ::CObject *> >::value ));
+#if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, ::CObject const *> >::value ));
+#else
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, ::CObject const * const, ::CObject const * const> >::value ));
+#endif
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_list(rng, sample) );
+    BOOST_CHECK( brdm::test_bidirectional(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CPtrList(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CPtrList rng_t;
+
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter< rng_t, brdm::list_iterator<rng_t,       void *> >::value ));
+#if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, void const *> >::value ));
+#else
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, void const * const, void const * const> >::value ));
+#endif
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_list(rng, sample) );
+    BOOST_CHECK( brdm::test_bidirectional(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CStringList(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CStringList rng_t;
+
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter< rng_t, brdm::list_iterator<rng_t,       ::CString> >::value ));
+#if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, ::CString const> >::value ));
+#else
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, ::CString const, ::CString const> >::value ));
+#endif
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_list(rng, sample) );
+    BOOST_CHECK( brdm::test_bidirectional(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+// maps
+//
+
+template< class MapT >
+void test_CMapPtrToWord(const MapT& sample)
+{
+    typedef ::CMapPtrToWord rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+    BOOST_CHECK( ::test_mfc_map(rng, sample) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class MapT >
+void test_CMapPtrToPtr(const MapT& sample)
+{
+    typedef ::CMapPtrToPtr rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+    BOOST_CHECK( ::test_mfc_map(rng, sample) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class MapT >
+void test_CMapStringToOb(const MapT& sample)
+{
+    typedef ::CMapStringToOb rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+    BOOST_CHECK( ::test_mfc_map(rng, sample) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class MapT >
+void test_CMapStringToPtr(const MapT& sample)
+{
+    typedef ::CMapStringToPtr rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+    BOOST_CHECK( ::test_mfc_map(rng, sample) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class MapT >
+void test_CMapStringToString(const MapT& sample)
+{
+    typedef ::CMapStringToString rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+#if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+    BOOST_CHECK( ::test_mfc_cpair_map(rng, sample) );
+#endif
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class MapT >
+void test_CMapWordToOb(const MapT& sample)
+{
+    typedef ::CMapWordToOb rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+    BOOST_CHECK( ::test_mfc_map(rng, sample) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class MapT >
+void test_CMapWordToPtr(const MapT& sample)
+{
+    typedef ::CMapWordToPtr rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+    BOOST_CHECK( ::test_mfc_map(rng, sample) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+// templates
+//
+
+template< class Range >
+void test_CArray(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CArray<val_t, const val_t&> rng_t; // An old MFC needs the second template argument.
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, val_t *>::value ));
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, val_t const*>::value ));
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_array(rng, sample) );
+    BOOST_CHECK( brdm::test_random_access(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class Range >
+void test_CList(const Range& sample)
+{
+    typedef typename boost::range_value<Range>::type val_t;
+
+    typedef ::CList<val_t, const val_t&> rng_t;
+
+    BOOST_STATIC_ASSERT(( brdm::test_mutable_iter< rng_t, brdm::list_iterator<rng_t,       val_t> >::value ));
+#if !defined(BOOST_RANGE_MFC_CONST_COL_RETURNS_NON_REF)
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, val_t const> >::value ));
+#else
+    BOOST_STATIC_ASSERT(( brdm::test_const_iter  < rng_t, brdm::list_iterator<rng_t const, val_t const, val_t const> >::value ));
+#endif
+
+    rng_t rng;
+    BOOST_CHECK( brdm::test_init_list(rng, sample) );
+    BOOST_CHECK( brdm::test_bidirectional(rng) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+template< class MapT >
+void test_CMap(const MapT& sample)
+{
+    typedef typename MapT::key_type k_t;
+    typedef typename MapT::mapped_type m_t;
+
+    typedef ::CMap<k_t, const k_t&, m_t, const m_t&> rng_t;
+
+    rng_t rng;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+    BOOST_CHECK( brdm::test_init_map(rng, sample) );
+#if !defined(BOOST_RANGE_MFC_NO_CPAIR)
+    BOOST_CHECK( ::test_mfc_cpair_map(rng, sample) );
+#endif
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+void test_CTypedPtrArray()
+{
+    typedef ::CTypedPtrArray< ::CPtrArray, int * > rng_t;
+    boost::function_requires< boost::RandomAccessRangeConcept<rng_t> >();
+
+    rng_t rng;
+    int o1, o2, o3, o4, o5;
+    int *data[] = { &o1, &o2, &o3, &o4, &o5 };
+    BOOST_CHECK( brdm::test_init_array(rng, boost::make_iterator_range(data, data+5)) );
+
+    BOOST_CHECK( *(boost::begin(rng) + 2) == &o3 );
+    BOOST_CHECK( *(boost::end(rng) - 1) == &o5 );        
+
+    // BOOST_CHECK( brdm::test_random_access(rng) ); this range is not mutable
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+void test_CTypedPtrList()
+{
+    typedef ::CTypedPtrList< ::CObList, ::CObList * > rng_t;
+    boost::function_requires< boost::BidirectionalRangeConcept<rng_t> >();
+
+    rng_t rng;
+
+    ::CObList o1, o2, o3, o4, o5;
+    ::CObList *data[] = { &o1, &o2, &o3, &o4, &o5 };
+    BOOST_CHECK( brdm::test_init_list(rng, data) );
+
+    boost::range_iterator<rng_t>::type it = boost::begin(rng);
+    std::advance(it, 1);
+    BOOST_CHECK( *it == &o2 );
+    std::advance(it, 2);
+    BOOST_CHECK( *it == &o4 );
+
+    // BOOST_CHECK( brdm::test_bidirectional(rng) ); this range is not mutable
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+void test_CTypedPtrMap()
+{
+    typedef ::CTypedPtrMap< ::CMapStringToPtr, ::CString, int *> rng_t;
+    boost::function_requires< boost::ForwardRangeConcept<rng_t> >();
+
+    rng_t rng;
+    ::CString o0(_T('a')), o1(_T('c')), o2(_T('f')), o3(_T('q')), o4(_T('g'));
+    int d0, d1, d2, d3, d4;
+    std::map< ::CString, int * > data;
+    data[o0] = &d0, data[o1] = &d1, data[o2] = &d2, data[o3] = &d3, data[o4] = &d4;
+
+    BOOST_CHECK( brdm::test_init_map(rng, data) );
+    BOOST_CHECK( ::test_mfc_map(rng, data) );
+    BOOST_CHECK( brdm::test_emptiness(rng) );
+}
+
+
+// strings
+//
+#if defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+
+    template< class Range >
+    void test_CString(const Range& sample)
+    {
+        typedef typename boost::range_value<Range>::type val_t;
+
+        typedef ::CString rng_t; // An old MFC needs the second template argument.
+        BOOST_STATIC_ASSERT(( brdm::test_mutable_iter<rng_t, TCHAR *>::value ));
+        BOOST_STATIC_ASSERT(( brdm::test_const_iter  <rng_t, TCHAR const*>::value ));
+
+        rng_t rng;
+        BOOST_CHECK( brdm::test_init_string(rng, sample) );
+        BOOST_CHECK( brdm::test_random_access(rng) );
+        BOOST_CHECK( brdm::test_emptiness(rng) );
+    }
+
+#endif
+
+
+struct CPerson
+{
+    void hello_range() { };
+};
+
+
+void test_mfc()
+{
+#if 0
+    // overview
+    //
+    {
+        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));
+                // ...
+            }
+        }
+    }
+#endif
+
+    // arrays
+    //
+    {
+        BYTE data[] = { 4,5,1,3,5,12,3,1,3,1,6,1,3,60,1,1,5,1,3,1,10 };
+
+        ::test_CByteArray(boost::make_iterator_range(data, data+22));
+    }
+
+    {
+        DWORD data[] = { 4,5,1,3,5,12,3,1,3,1,6,1,3,60,1,1,5,1,3,1,10 };
+
+        test_CDWordArray(boost::make_iterator_range(data, data+22));
+    }
+
+    {
+        ::CObArray o1, o2, o3, o4, o5;
+        ::CObject *data[] = { &o1, &o2, &o3, &o4, &o5 };
+
+        ::test_CObArray(boost::make_iterator_range(data, data+5));
+    }
+
+    {
+        ::CPtrArray o1, o2, o3, o4, o5;
+        void *data[] = { &o1, &o2, &o3, &o4, &o5 };
+
+        ::test_CPtrArray(boost::make_iterator_range(data, data+5));
+    }
+
+    {
+        ::CString data[] = {
+            ::CString(_T('0')), ::CString(_T('1')), ::CString(_T('2')), ::CString(_T('3')),
+            ::CString(_T('4')), ::CString(_T('5')), ::CString(_T('6')), ::CString(_T('7'))
+        };
+
+        ::test_CStringArray(boost::make_iterator_range(data, data+8));
+    }
+
+    {
+        ::CUIntArray rng;
+        UINT data[] = { 4,5,1,3,5,12,3,1,3,1,6,1,3,60,1,1,5,1,3,1,10 };
+
+        ::test_CUIntArray(boost::make_iterator_range(data, data+22));
+    }
+
+    {
+        ::CWordArray rng;
+        WORD data[] = { 4,5,1,3,5,12,3,1,3,1,6,1,3,60,1,1,5,1,3,1,10 };
+
+        ::test_CWordArray(boost::make_iterator_range(data, data+22));
+    }
+
+    
+    // lists
+    //
+    {
+        ::CObList rng;
+        ::CObList o1, o2, o3, o4, o5;
+        ::CObject *data[] = { &o1, &o2, &o3, &o4, &o5 };
+
+        ::test_CObList(boost::make_iterator_range(data, data+5));
+    }
+
+    {
+        ::CPtrList rng;
+        ::CPtrList o1, o2, o3, o4, o5;
+        void *data[] = { &o1, &o2, &o3, &o4, &o5 };
+
+        ::test_CPtrList(boost::make_iterator_range(data, data+5));
+    }
+
+    {
+        ::CString data[] = {
+            ::CString(_T('0')), ::CString(_T('1')), ::CString(_T('2')), ::CString(_T('3')),
+            ::CString(_T('4')), ::CString(_T('5')), ::CString(_T('6')), ::CString(_T('7'))
+        };
+
+        ::test_CStringList(boost::make_iterator_range(data, data+8));
+    }
+
+
+    // maps
+    //
+    {
+        std::map<void *, WORD> data;
+        int o0, o1, o2, o3, o4;
+        data[&o0] = 15, data[&o1] = 14, data[&o2] = 3, data[&o3] = 6, data[&o4] = 1;
+
+        ::test_CMapPtrToWord(data);
+    }
+
+    {
+        std::map<void *, void*> data;
+        int o0, o1, o2, o3, o4;
+        data[&o0] = &o3, data[&o1] = &o2, data[&o2] = &o1, data[&o3] = &o0, data[&o4] = &o4;
+
+        ::test_CMapPtrToPtr(data);
+    }
+
+    {
+        std::map< ::CString, CObject * > data;
+        CObArray o0, o1, o2, o3, o4;
+        data[ ::CString('0') ] = &o0, data[ ::CString('1') ] = &o1, data[ ::CString('2') ] = &o2,
+        data[ ::CString('3') ] = &o3, data[ ::CString('4') ] = &o4;
+
+        ::test_CMapStringToOb(data);
+    }
+
+    {
+        std::map< ::CString, void * > data;
+        CObArray o0, o1, o2, o3, o4;
+        data[ ::CString('0') ] = &o0, data[ ::CString('1') ] = &o1, data[ ::CString('2') ] = &o2,
+        data[ ::CString('3') ] = &o3, data[ ::CString('4') ] = &o4;
+
+        ::test_CMapStringToPtr(data);
+    }
+
+    {
+        std::map< ::CString, ::CString > data;
+        CString o0('a'), o1('b'), o2('c'), o3('d'), o4('e');
+        data[ ::CString('0') ] = o0, data[ ::CString('1') ] = o1, data[ ::CString('2') ] = o2,
+        data[ ::CString('3') ] = o3, data[ ::CString('4') ] = o4;
+
+        ::test_CMapStringToString(data);
+    }
+
+    {
+        std::map< WORD, CObject * > data;
+        ::CDWordArray o0, o1, o2, o3, o4;
+        data[21] = &o3, data[52] = &o2, data[12] = &o1, data[76] = &o0, data[54] = &o4;
+
+        ::test_CMapWordToOb(data);
+    }
+
+    {
+        std::map< WORD, void * > data;
+        ::CDWordArray o0, o1, o2, o3, o4;
+        data[21] = &o3, data[52] = &o2, data[12] = &o1, data[76] = &o0, data[54] = &o4;
+
+        ::test_CMapWordToPtr(data);
+    }
+
+    // templates
+    //
+    {
+        std::string data("0987654321qwertyuiop");
+        ::test_CArray(data);
+        ::test_CList(data);
+    }    
+
+    {
+        std::wstring data(L"asdfghjklzxcvbnm");
+        ::test_CArray(data);
+        ::test_CList(data);
+    }    
+
+    {
+        std::map< int, std::string > data;
+        data[0] = "abcde", data[1] = "ajfie", data[2] = "lij", data[3] = "abc", data[4] = "ioiu";
+
+        ::test_CMap(data);
+    }
+
+
+    // typed
+    //
+    {
+        ::test_CTypedPtrArray();
+        ::test_CTypedPtrList();
+        ::test_CTypedPtrMap();
+    }
+
+
+    // strings
+    //
+#if defined(BOOST_RANGE_MFC_HAS_LEGACY_STRING)
+    {
+        std::string data("123456789 abcdefghijklmn");
+        ::test_CString(data);
+    }
+#endif
+
+
+} // test_mfc
+
 
 #include <boost/test/unit_test.hpp>
 using boost::unit_test::test_suite;
 
 
-test_suite* init_unit_test_suite( int argc, char* argv[] )
+test_suite *
+init_unit_test_suite(int argc, char* argv[])
 {
-    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
-
-    test->add( BOOST_TEST_CASE( &check_mfc ) );
+    test_suite *test = BOOST_TEST_SUITE("MFC Range Test Suite");
+    test->add(BOOST_TEST_CASE(&test_mfc));
 
+    (void)argc, (void)argv; // unused
     return test;
 }
-
-
-
-
-
-

test/partial_workaround.cpp

@@ -10,6 +10,8 @@
 
 #include <boost/config.hpp>
 #include <boost/detail/workaround.hpp>
+#include <boost/range/detail/implementation_help.hpp>
+#include <boost/test/test_tools.hpp>
 
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
 #  pragma warn -8091 // supress warning in Boost.Test
@@ -30,7 +32,6 @@
 
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
-#include <boost/test/test_tools.hpp>
 #include <iostream>
 #include <vector>
 
@@ -91,6 +92,11 @@ void check_partial_workaround()
 
 void check_partial_workaround()
 {
+    //
+    // test if warnings are generated
+    //
+    std::size_t s = boost::range_detail::array_size( "foo" );
+    BOOST_CHECK_EQUAL( s,  4u );
 }
 
 #endif

test/std_container.cpp

@@ -48,12 +48,12 @@ void check_std_container()
     BOOST_CHECK( begin( vec ) == vec.begin() );
     BOOST_CHECK( end( vec )   == vec.end() );
     BOOST_CHECK( empty( vec ) == vec.empty() );
-    BOOST_CHECK( size( vec ) == vec.size() );
+    BOOST_CHECK( (std::size_t)size( vec ) == vec.size() );
     
     BOOST_CHECK( begin( cvec ) == cvec.begin() );
     BOOST_CHECK( end( cvec )   == cvec.end() );
     BOOST_CHECK( empty( cvec ) == cvec.empty() );
-    BOOST_CHECK( size( cvec ) == cvec.size() );
+    BOOST_CHECK( (std::size_t)size( cvec ) == cvec.size() );
 
 }
 

test/string.cpp

@@ -33,28 +33,28 @@ template< class T >
 inline BOOST_DEDUCED_TYPENAME boost::range_iterator<T>::type
 str_begin( T& r )
 {
-    return boost::begin( as_literal(r) ); 
+    return boost::begin( boost::as_literal(r) ); 
 }
 
 template< class T >
 inline BOOST_DEDUCED_TYPENAME boost::range_iterator<T>::type
 str_end( T& r )
 {
-    return boost::end( as_literal(r) ); 
+    return boost::end( boost::as_literal(r) ); 
 }
 
 template< class T >
 inline BOOST_DEDUCED_TYPENAME boost::range_size<T>::type
 str_size( const T& r )
 {
-    return boost::size( as_literal(r) ); 
+    return boost::size( boost::as_literal(r) ); 
 }
 
 template< class T >
 inline bool
 str_empty( T& r )
 {
-    return boost::empty( as_literal(r) ); 
+    return boost::empty( boost::as_literal(r) ); 
 }
 
 template< typename Container, typename T >
@@ -137,14 +137,7 @@ void check_char()
     BOOST_CHECK_EQUAL( str_end( char_s ), str_end1 );
     BOOST_CHECK_EQUAL( str_empty( char_s ), (char_s == 0 || char_s[0] == char()) );
     BOOST_CHECK_EQUAL( sz, std::char_traits<char>::length( char_s ) );
-/*    
-    BOOST_CHECK_EQUAL( str_begin( char_s2 ), char_s2 );
-    std::size_t sz2 = size( char_s2 );
-    const char* str_end12 = str_begin( char_s2 ) + sz;
-    BOOST_CHECK_EQUAL( str_end( char_s2 ), str_end12 );
-    BOOST_CHECK_EQUAL( empty( char_s2 ), (char_s2 == 0 || char_s2[0] == char()) );
-    BOOST_CHECK_EQUAL( sz2, std::char_traits<char>::length( char_s2 ) );
-*/
+
     BOOST_CHECK_EQUAL( str_begin( my_string ), my_string );
     range_iterator<char_array_t>::type str_end2 = str_begin( my_string ) + str_size(my_string);
     range_iterator<char_array_t>::type str_end3 = str_end(my_string);
@@ -165,6 +158,20 @@ void check_char()
 
     BOOST_CHECK( find_const( as_array( my_string ), to_search ) != str_end(my_string) );
     BOOST_CHECK( find_const( as_array( my_const_string ), to_search ) != str_end(my_string) );
+
+    //
+    // Test that as_literal() always scan for null terminator
+    //
+    char an_array[] = "foo\0bar";
+    BOOST_CHECK_EQUAL( str_begin( an_array ), an_array );
+    BOOST_CHECK_EQUAL( str_end( an_array ), an_array + 3 );
+    BOOST_CHECK_EQUAL( str_size( an_array ), 3 );
+
+    const char a_const_array[] = "foobar\0doh";
+    BOOST_CHECK_EQUAL( str_begin( a_const_array ), a_const_array );
+    BOOST_CHECK_EQUAL( str_end( a_const_array ), a_const_array + 6 );
+    BOOST_CHECK_EQUAL( str_size( a_const_array ), 6 );
+
 }
 
 
@@ -172,9 +179,6 @@ void check_char()
 void check_string()
 {
     check_char();
-//    check_char<volatile char>();
-//    check_char<const char>();
-//    check_char<const volatile char>();
     
 #ifndef BOOST_NO_STD_WSTRING
     typedef wchar_t*               wchar_iterator_t;          
@@ -197,13 +201,7 @@ void check_string()
     BOOST_CHECK_EQUAL( str_end(char_ws), (str_begin( char_ws ) + sz) );
     BOOST_CHECK_EQUAL( str_empty( char_ws ), (char_ws == 0 || char_ws[0] == wchar_t()) );
     BOOST_CHECK_EQUAL( sz, std::char_traits<wchar_t>::length( char_ws ) );
- /*       
-    std::size_t sz2 = size( char_ws2 );
-    BOOST_CHECK_EQUAL( str_begin( char_ws2 ), char_ws2 );
-    BOOST_CHECK_EQUAL( str_end( char_ws2 ), (begin( char_ws2 ) + sz2) );
-    BOOST_CHECK_EQUAL( empty( char_ws2 ), (char_ws2 == 0 || char_ws2[0] == wchar_t()) );
-    BOOST_CHECK_EQUAL( sz2, std::char_traits<wchar_t>::length( char_ws2 ) );
-   */ 
+
     wchar_t to_search = L'n';
     BOOST_CHECK( find( char_ws, to_search ) != str_end(char_ws) );    
 

test/sub_range.cpp

@@ -17,6 +17,7 @@
 #endif
 
 #include <boost/range/sub_range.hpp>
+#include <boost/range/as_literal.hpp> 
 #include <boost/test/test_tools.hpp>
 #include <iostream>
 #include <string>
@@ -110,12 +111,12 @@ void check_sub_range()
     BOOST_CHECK( rr.equal( r ) );
 
     rr  = make_iterator_range( str.begin(), str.begin() + 5 );
-    BOOST_CHECK( rr == "hello" );
-    BOOST_CHECK( rr != "hell" );
-    BOOST_CHECK( rr < "hello dude" );
-    BOOST_CHECK( "hello" == rr );
-    BOOST_CHECK( "hell"  != rr );
-    BOOST_CHECK( ! ("hello dude" < rr ) );
+    BOOST_CHECK( rr == as_literal("hello") );
+    BOOST_CHECK( rr != as_literal("hell") );
+    BOOST_CHECK( rr < as_literal("hello dude") );
+    BOOST_CHECK( as_literal("hello") == rr );
+    BOOST_CHECK( as_literal("hell")  != rr );
+    BOOST_CHECK( ! (as_literal("hello dude") < rr ) );
     
     irange rrr = rr;
     BOOST_CHECK( rrr == rr );
@@ -126,15 +127,16 @@ void check_sub_range()
     BOOST_CHECK_EQUAL( cr.front(), 'h' );
     BOOST_CHECK_EQUAL( cr.back(), 'd' );
     BOOST_CHECK_EQUAL( cr[1], 'e' );
+    BOOST_CHECK_EQUAL( cr(1), 'e' );
 
     rrr = make_iterator_range( str, 1, -1 );
-    BOOST_CHECK( rrr == "ello worl" );
+    BOOST_CHECK( rrr == as_literal("ello worl") );
     rrr = make_iterator_range( rrr, -1, 1 );
     BOOST_CHECK( rrr == str );
     rrr.front() = 'H';
     rrr.back()  = 'D';
     rrr[1]      = 'E';
-    BOOST_CHECK( rrr == "HEllo worlD" );
+    BOOST_CHECK( rrr == as_literal("HEllo worlD") );
 }   
 
 #include <boost/test/unit_test.hpp>