Create branch for next serialization release

[SVN r38613]

doc/example.cpp

@@ -0,0 +1,148 @@
+/*
+//  Copyright Thorsten Ottosen 2003-2005. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+*/
+
+#include <boost/range.hpp>
+#include <iterator>         // for std::iterator_traits, std::distance()
+
+namespace Foo
+{
+        //
+        // Our sample UDT. A 'Pair'
+        // will work as a range when the stored
+        // elements are iterators.
+        //
+        template< class T >
+        struct Pair
+        {
+                T first, last;
+        };
+
+} // namespace 'Foo'
+
+namespace boost
+{
+        //
+        // Specialize metafunctions. We must include the range.hpp header.
+        // We must open the 'boost' namespace.
+        //
+        /*
+        template< class T >
+        struct range_value< Foo::Pair<T> >
+        {
+                typedef typename std::iterator_traits<T>::value_type type;
+        };
+        */
+
+        template< class T >
+        struct range_iterator< Foo::Pair<T> >
+        {
+                typedef T type;
+        };
+
+        template< class T >
+        struct range_const_iterator< Foo::Pair<T> >
+        {
+                //
+                // Remark: this is defined similar to 'range_iterator'
+                //         because the 'Pair' type does not distinguish
+                //         between an iterator and a const_iterator.
+                //
+                typedef T type;
+        };
+
+        /*
+    template< class T >
+        struct range_difference< Foo::Pair<T> >
+        {
+                typedef typename std::iterator_traits<T>::difference_type type;
+        };
+        */
+
+        template< class T >
+    struct range_size< Foo::Pair<T> >
+        {
+                int static_assertion[ sizeof( std::size_t ) >=
+                          sizeof( typename range_difference< Foo::Pair<T> >::type ) ];
+                typedef std::size_t type;
+        };
+
+} // namespace 'boost'
+
+namespace Foo
+{
+        //
+        // The required functions. These should be defined in
+        // the same namespace as 'Pair', in this case
+        // in namespace 'Foo'.
+        //
+
+        template< class T >
+        inline T boost_range_begin( Pair<T>& x )
+        {
+                return x.first;
+        }
+
+    template< class T >
+        inline T boost_range_begin( const Pair<T>& x )
+        {
+                return x.first;
+        }
+
+        template< class T >
+    inline T boost_range_end( Pair<T>& x )
+        {
+                return x.last;
+        }
+
+        template< class T >
+    inline T boost_range_end( const Pair<T>& x )
+        {
+                return x.last;
+        }
+
+        template< class T >
+        inline typename boost::range_size< Pair<T> >::type
+        boost_range_size( const Pair<T>& x )
+        {
+                return std::distance(x.first,x.last);
+        }
+
+} // namespace 'Foo'
+
+#include <vector>
+
+int main()
+{
+        typedef std::vector<int>::iterator  iter;
+        std::vector<int>                    vec;
+        vec.push_back( 42 );
+        Foo::Pair<iter>                     pair  = { vec.begin(), vec.end() };
+        const Foo::Pair<iter>&              cpair = pair;
+        //
+        // Notice that we call 'begin' etc with qualification.
+        //
+        iter i = boost::begin( pair );
+        iter e = boost::end( pair );
+        i      = boost::begin( cpair );
+        e      = boost::end( cpair );
+        boost::range_size< Foo::Pair<iter> >::type s = boost::size( pair );
+        s      = boost::size( cpair );
+        boost::range_const_reverse_iterator< Foo::Pair<iter> >::type
+        ri     = boost::rbegin( cpair ),
+        re         = boost::rend( cpair );
+
+        //
+        // Test metafunctions
+        //
+
+        boost::range_value< Foo::Pair<iter> >::type
+        v = *boost::begin(pair);
+
+        boost::range_difference< Foo::Pair<iter> >::type
+        d = boost::end(pair) - boost::begin(pair);
+}
+

doc/examples.html

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

doc/faq.html

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

doc/headers.html

@@ -141,6 +141,11 @@
             <td  ><a href="utility_class.html#sub_range" >sub_range</a></td>
             <td>- </td>
         </tr>
+        <tr  >
+            <td  ><code  >&lt;boost/range/concepts.hpp&gt;</code></td>
+            <td  ><a href="range.html#concept_checking" >concept checks</a></td>
+            <td>- </td>
+        </tr>
 
     </table>
     <br
@@ -149,7 +154,7 @@
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
     </p>
 
     <br>

doc/history_ack.html

@@ -56,9 +56,12 @@ C++ standard: <blockquote>
              vc6 and vc7.
     </ul>
     </p>
+    <p>
+    The concept checks and their documentation was provided by Daniel Walker.
+    
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2005
+    (C) Copyright Thorsten Ottosen 2003-2006. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
     </p>
 
     <br>

doc/intro.html

@@ -87,7 +87,7 @@ free-standing functions so syntactic and/or semantic differences can be removed.
     </span><span class=special>{
        </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>find</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>value </span><span class=special>);
     </span><span class=special>}
-    
+
     </span><span class=keyword>template</span><span class=special>&lt; </span><span class=keyword>class </span><span class=identifier>ForwardReadableRange</span><span class=special>, </span><span class=keyword>class </span><span class=identifier>T </span><span class=special>&gt;
     </span><span class=keyword>inline </span><span class=keyword>typename </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>range_const_iterator</span><span class=special>&lt; </span><span
 class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><span class=identifier>type
@@ -95,7 +95,7 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
     </span><span class=special>{
        </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>find</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>value </span><span class=special>);
     </span><span class=special>}
-                   
+
     </span><span class=comment>//
     // replace first value and return its index
     //
@@ -104,7 +104,7 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
     </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>);
-       
+
        </span><span class=keyword>if</span><span class=special>( </span><span class=identifier>found </span><span class=special>!= </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>c </span><span class=special>) </span><span class=special>)
            </span><span class=special>*</span><span class=identifier>found </span><span class=special>= </span><span class=identifier>replacement</span><span class=special>;
        </span><span class=keyword>return </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>distance</span><span class=special>( </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>begin</span><span class=special>( </span><span class=identifier>c </span><span class=special>), </span><span class=identifier>found </span><span class=special>);
@@ -115,30 +115,30 @@ class=identifier>ForwardReadableRange </span><span class=special>&gt;::</span><s
     //
     </span><span class=keyword>const </span><span class=keyword>int </span><span class=identifier>N </span><span class=special>= </span><span class=number>5</span><span class=special>;
     </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt; </span><span class=identifier>my_vector</span><span class=special>;
-    </span><span class=keyword>int </span><span class=identifier>values</span><span class=special>[] </span><span class=special>= </span><span class=special>{ </span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>,</span><span class=number>4</span><span class=special>,</span><span class=number>5</span><span class=special>,</span><span class=number>6</span><span class=special>,</span><span class=number>7</span><span class=special>,</span><span class=number>8</span><span class=special>,</span><span class=number>9 </span><span class=special>};       
+    </span><span class=keyword>int </span><span class=identifier>values</span><span class=special>[] </span><span class=special>= </span><span class=special>{ </span><span class=number>1</span><span class=special>,</span><span class=number>2</span><span class=special>,</span><span class=number>3</span><span class=special>,</span><span class=number>4</span><span class=special>,</span><span class=number>5</span><span class=special>,</span><span class=number>6</span><span class=special>,</span><span class=number>7</span><span class=special>,</span><span class=number>8</span><span class=special>,</span><span class=number>9 </span><span class=special>};
     </span>
-    <span class=identifier>my_vector</span><span class=special>.</span><span 
+    <span class=identifier>my_vector</span><span class=special>.</span><span
 class=identifier>assign</span><span class=special>( </span><span class=identifier>values</span><span class=special>, </span><span class=identifier>boost</span><span class=special>::</span><span class=identifier>end</span><span class=special>( </span><span class=identifier>values </span><span class=special>) </span><span class=special>);</span>
     </span><span class=keyword>typedef </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>vector</span><span class=special>&lt;</span><span class=keyword>int</span><span class=special>&gt;::</span><span class=identifier>iterator </span><span class=identifier>iterator</span><span class=special>;
     </span><span class=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>;
     </span><span class=keyword>char</span><span class=special>* </span><span class=identifier>str       </span><span class=special>= </span><span class=identifier>str_val</span><span class=special>;
-    
-    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>my_vector</span><span class=special>, </span><span class=number>4</span><span class=special>, </span><span class=number>2 </span><span class=special>)
-              </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>my_view</span><span class=special>, </span><span class=number>4</span><span class=special>, </span><span class=number>2 </span><span class=special>)
-              </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>str</span><span class=special>, </span><span class=literal>'a'</span><span class=special>, </span><span class=literal>'b' </span><span class=special>);
+
+    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>my_vector</span><span class=special>, </span><span class=number>4</span><span class=special>, </span><span class=number>2 </span><span class=special>);
+    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>my_view</span><span class=special>, </span><span class=number>4</span><span class=special>, </span><span class=number>2 </span><span class=special>);
+    </span><span class=identifier>std</span><span class=special>::</span><span class=identifier>cout </span><span class=special>&lt;&lt; </span><span class=identifier>my_generic_replace</span><span class=special>( </span><span class=identifier>str</span><span class=special>, </span><span class=literal>'a'</span><span class=special>, </span><span class=literal>'b' </span><span class=special>);
 </span>
     <span class=comment>// prints '3', '5' and '0'     </span>
     </pre>
     </blockquote>
 
-    By using the free-standing functions and <a 
-href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a>, the code automatically 
-    works for all the types supported by this library; now and in the future. 
+    By using the free-standing functions and <a
+href="../../mpl/doc/refmanual/metafunction.html">metafunctions</a>, the code automatically
+    works for all the types supported by this library; now and in the future.
 Notice that we have to
-    provide two version of <code  >find()</code> since we cannot forward a non-const 
-    rvalue with reference arguments (see this article about  <a href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_self" >The 
+    provide two version of <code  >find()</code> since we cannot forward a non-const
+    rvalue with reference arguments (see this article about  <a href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm" target="_self" >The
     Forwarding Problem</a> ).
 
     </p>
@@ -146,7 +146,7 @@ Notice that we have to
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
     </p>
 
     <br>

doc/portability.html

@@ -75,7 +75,7 @@ href="http://boost.sourceforge.net/regression-logs/developer/range.html">here</a
 
     <hr>
     <p>
-    (C) Copyright Thorsten Ottosen 2003-2004
+    (C) Copyright Thorsten Ottosen 2003-2004. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
     </p>
 
     <br>

doc/range.html

@@ -36,6 +36,8 @@
             <a href="#bidirectional_range">Bidirectional Range</a>
         <li>
             <a href="#random_access_range">Random Access Range</a>
+        <li>
+            <a href="#concept_checking">Concept Checking</a>
     </ul>
 
     <a name="overview"></a>
@@ -386,7 +388,7 @@ VAlign="top"><code>boost::range_const_reverse_iterator&ltX>::type</code></TD>
         </TR>
         <TR>
             <TD VAlign="top">Beginning of range</TD>
-            <TD VAlign="top"><code>rboost::begin(a)</code></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>
@@ -394,7 +396,7 @@ otherwise.</TD>
 <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>rboost::end(a)</code></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>
@@ -405,7 +407,7 @@ otherwise.</TD>
 
     <h3>Complexity guarantees</h3>
 
-    <code>rboost::begin(a)</code> has the same complexity as <code>boost::end(a)</code> and <code>rboost::end(a)</code> 
+    <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>.
 
@@ -414,13 +416,13 @@ otherwise.</TD>
     <Table border="1" cellpadding="5">
         <TR>
             <TD VAlign="top">Valid reverse range</TD>
-            <TD VAlign="top">For any Bidirectional Range <code>a</code>, <code>[rboost::begin(a),rboost::end(a))</code> 
-            is a valid range, that is, <code>rboost::end(a)</code> is reachable from <code>rboost::begin(a)</code> 
+            <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>[rboost::begin(a),rboost::end(a))</code>
+            <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>
@@ -450,6 +452,59 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator
 
     <hr>
 
+    <a name=concept_checking><h2>Concept Checking</h2>
+
+    Each of the range concepts has a corresponding concept checking
+    class in the file boost/range/concepts.hpp. These classes may be
+    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
+    is compatible with a range concept. If not, a meaningful compile
+    time error is generated. Checks are provided for the range
+    concepts related to iterator traversal categories. For example,
+    the following line checks that the type <code>T</code> models the
+    <a href="#forward_range">ForwardRange</a> concept.
+
+    <pre>
+    function_requires&lt;ForwardRangeConcept&lt;T&gt; &gt;();
+    </pre>
+
+    An additional concept check is required for the value access
+    property of the range based on the range's iterator type. For
+    example to check for a ForwardReadableRange, the following code is
+    required.
+
+    <pre>
+    function_requires&lt;ForwardRangeConcept&lt;T&gt; &gt;();
+    function_requires&lt;
+        ReadableIteratorConcept&lt;
+            typename range_iterator&lt;T&gt;::type
+        &gt;
+    &gt;();
+    </pre>
+
+    The following range concept checking classes are provided.
+    <ul>
+        <li>
+            Class <code>SinglePassRangeConcept</code> checks for <a
+            href="#single_pass_range">Single Pass Range</a>
+        <li>
+            Class <code>ForwardRangeConcept</code> checks for <a
+            href="#forward_range">Forward Range</a>
+        <li>
+            Class <code>BidirectionalRangeConcept</code> checks for <a
+            href="#bidirectional_range">Bidirectional Range</a>
+        <li>
+            Class <code>RandomAccessRangeConcept</code> checks for <a
+            href="#random_access_range">Random Access Range</a>
+    </ul>
+
+    <h3>See also</h3> 
+    <p> <a href="style.html">Range Terminology and style guidelines</a></p>
+    <p> <a href="../../iterator/doc/iterator_concepts.html">Iterator Concepts</a></p>
+    <p> <a href="../../concept_check/concept_check.htm">Boost Concept Check library</a></p>
+
+    <hr>
 
     <!--
     <h3>Notes</h3>
@@ -475,7 +530,7 @@ href="../../iterator/doc/new-iter-concepts.html#random-access-traversal-iterator
         </TR>
         <tr >
             <TD nowrap>Copyright &copy 2004</TD>
-            <TD>Thorsten Ottosen.
+            <TD>Thorsten Ottosen. Use, modification and distribution is subject to the Boost Software License, Version 1.0.
     </TABLE>
 
     <br>

doc/style.css

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

doc/style.html

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

doc/utility_class.html

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

include/boost/range/begin.hpp

@@ -15,6 +15,7 @@
 # pragma once
 #endif
 
+#include <boost/type_traits/remove_const.hpp>
 #include <boost/range/config.hpp>
 
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -46,7 +47,8 @@ namespace range_detail
     }
 
     template< typename C >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
+    inline BOOST_DEDUCED_TYPENAME range_iterator<
+                                                                        typename remove_const<C>::type >::type
     boost_range_begin( C& c )
     {
         return c.begin();
@@ -140,7 +142,8 @@ namespace range_detail
 
 
 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
+inline BOOST_DEDUCED_TYPENAME range_iterator<
+                        typename remove_const<T>::type >::type begin( T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
     !BOOST_WORKAROUND(__GNUC__, < 3) \
@@ -187,7 +190,7 @@ namespace boost
     inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
     const_begin( const T& r )
     {
-        return begin( r );
+        return boost::begin( r );
     }
 }
 

include/boost/range/concepts.hpp

@@ -0,0 +1,155 @@
+// Boost.Range library concept checks
+//
+//  Copyright Daniel Walker 2006. Use, modification and distribution
+//  are 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/
+//
+
+#ifndef BOOST_RANGE_CONCEPTS_HPP
+#define BOOST_RANGE_CONCEPTS_HPP
+
+#include <boost/concept_check.hpp>
+#include <boost/iterator/iterator_concepts.hpp>
+#include <boost/range/functions.hpp>
+#include <boost/range/metafunctions.hpp>
+
+/*!
+ * \file
+ * \brief Concept checks for the Boost Range library.
+ *
+ * The structures in this file may be used in conjunction with the
+ * Boost Concept Check library to insure that the type of a function
+ * parameter is compatible with a range concept. If not, a meaningful
+ * compile time error is generated. Checks are provided for the range
+ * concepts related to iterator traversal categories. For example, the
+ * following line checks that the type T models the ForwardRange
+ * concept.
+ *
+ * \code
+ * function_requires<ForwardRangeConcept<T> >();
+ * \endcode
+ *
+ * An additional concept check is required for the value access
+ * property of the range. For example to check for a
+ * ForwardReadableRange, the following code is required.
+ *
+ * \code
+ * function_requires<ForwardRangeConcept<T> >();
+ * function_requires<
+ *     ReadableIteratorConcept<
+ *         typename range_iterator<T>::type
+ *     >
+ * >();
+ * \endcode
+ *
+ * \see http://www.boost.org/libs/range/doc/range.html for details
+ * about range concepts.
+ * \see http://www.boost.org/libs/iterator/doc/iterator_concepts.html
+ * for details about iterator concepts.
+ * \see http://www.boost.org/libs/concept_check/concept_check.htm for
+ * details about concept checks.
+ */
+
+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;
+        void constraints()
+        {
+            function_requires<
+                boost_concepts::SinglePassIteratorConcept<
+                    range_iterator
+                >
+            >();
+            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);
+            ci = boost::end(a);
+        }
+        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;
+        void constraints()
+        {
+            function_requires<
+                SinglePassRangeConcept<T>
+            >();        
+            function_requires<
+                boost_concepts::ForwardTraversalConcept<
+                    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;
+        void constraints()
+        {
+            function_requires<
+                    ForwardRangeConcept<T>
+            >();        
+            function_requires<
+                boost_concepts::BidirectionalTraversalConcept<
+                    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 {
+        void constraints()
+        {
+            function_requires<
+                BidirectionalRangeConcept<T>
+            >();        
+            function_requires<
+                boost_concepts::RandomAccessTraversalConcept<
+                    typename range_iterator<T>::type
+                >
+            >();
+            }
+    };
+
+} // namespace boost
+
+#endif // BOOST_RANGE_CONCEPTS_HPP

include/boost/range/detail/common.hpp

@@ -78,35 +78,35 @@ namespace boost
         template< typename C >
         class range
         {
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_pair_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_pair_,
                                                                   boost::range_detail::std_pair_,
                                                                   void >::type pair_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_array_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_array_,
                                                                     boost::range_detail::array_,
                                                                     pair_t >::type array_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_string_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_string_,
                                                                     boost::range_detail::string_,
                                                                     array_t >::type string_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_const_char_ptr_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_char_ptr_,
                                                                     boost::range_detail::const_char_ptr_,
                                                                     string_t >::type const_char_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_char_ptr_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_ptr_,
                                                                     boost::range_detail::char_ptr_,
                                                                     const_char_ptr_t >::type char_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_const_wchar_t_ptr_,
                                                                     boost::range_detail::const_wchar_t_ptr_,
                                                                     char_ptr_t >::type const_wchar_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_ptr_,
                                                                     boost::range_detail::wchar_t_ptr_,
                                                                     const_wchar_ptr_t >::type wchar_ptr_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_wchar_t_array_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_wchar_t_array_,
                                                                     boost::range_detail::wchar_t_array_,
                                                                     wchar_ptr_t >::type wchar_array_t;
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::range_detail::range_helper<C>::is_char_array_,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::range_detail::range_helper<C>::is_char_array_,
                                                                     boost::range_detail::char_array_,
                                                                     wchar_array_t >::type char_array_t;
         public:
-            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< boost::is_void<char_array_t>::value,
+            typedef BOOST_RANGE_DEDUCED_TYPENAME   boost::mpl::if_c< ::boost::is_void<char_array_t>::value,
                                                                     boost::range_detail::std_container_,
                                                                     char_array_t >::type type;  
         }; // class 'range' 

include/boost/range/detail/implementation_help.hpp

@@ -43,7 +43,7 @@ namespace boost
 #else
         inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
         {
-            if( s == 0 && s[0] == 0 )
+            if( s == 0 || s[0] == 0 )
                 return s;
             while( *++s != 0 )
                 ;

include/boost/range/difference_type.hpp

@@ -16,12 +16,25 @@
 #endif
 
 #include <boost/range/config.hpp>
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/range/detail/difference_type.hpp>
-#else
-
+#include <boost/range/const_iterator.hpp>
 #include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+        template< class T >
+        struct range_difference
+        {
+                typedef BOOST_DEDUCED_TYPENAME iterator_difference<
+                        BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type >::type
+                                type;
+        };
+}
+
+//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//#include <boost/range/detail/difference_type.hpp>
+//#else
+
+/*
 #include <cstddef>
 #include <utility>
 
@@ -30,13 +43,13 @@ namespace boost
     //////////////////////////////////////////////////////////////////////////
     // default
     //////////////////////////////////////////////////////////////////////////
-    
+
     template< typename C >
     struct range_difference
     {
         typedef BOOST_DEDUCED_TYPENAME C::difference_type type;
     };
-    
+
     //////////////////////////////////////////////////////////////////////////
     // pair
     //////////////////////////////////////////////////////////////////////////
@@ -44,14 +57,14 @@ namespace boost
     template< typename Iterator >
     struct range_difference< std::pair<Iterator,Iterator> >
     {
-        typedef BOOST_DEDUCED_TYPENAME 
+        typedef BOOST_DEDUCED_TYPENAME
             iterator_difference<Iterator>::type type;
     };
-    
+
     template< typename Iterator >
     struct range_difference< const std::pair<Iterator,Iterator> >
     {
-        typedef BOOST_DEDUCED_TYPENAME 
+        typedef BOOST_DEDUCED_TYPENAME
             iterator_difference<Iterator>::type type;
     };
 
@@ -127,5 +140,6 @@ namespace boost
 } // namespace boost
 
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+*/
 
 #endif

include/boost/range/end.hpp

@@ -15,6 +15,7 @@
 # pragma once
 #endif
 
+#include <boost/type_traits/remove_const.hpp>
 #include <boost/range/config.hpp>
 
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -25,34 +26,35 @@
 #include <boost/range/iterator.hpp>
 #include <boost/range/const_iterator.hpp>
 
-namespace boost 
+namespace boost
 {
-    
+
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
     !BOOST_WORKAROUND(__GNUC__, < 3) \
-    /**/ 
+    /**/
 namespace range_detail
 {
-#endif   
+#endif
 
         //////////////////////////////////////////////////////////////////////
         // primary template
         //////////////////////////////////////////////////////////////////////
-        
+
         template< typename C >
         inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
         boost_range_end( const C& c )
         {
             return c.end();
         }
-                
+
         template< typename C >
-        inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
+                inline BOOST_DEDUCED_TYPENAME range_iterator<
+                                        typename remove_const<C>::type >::type
         boost_range_end( C& c )
         {
             return c.end();
         }
-      
+
         //////////////////////////////////////////////////////////////////////
         // pair
         //////////////////////////////////////////////////////////////////////
@@ -62,13 +64,13 @@ namespace range_detail
         {
             return p.second;
         }
-        
+
         template< typename Iterator >
         inline Iterator boost_range_end( std::pair<Iterator,Iterator>& p )
         {
             return p.second;
         }
-        
+
         //////////////////////////////////////////////////////////////////////
         // array
         //////////////////////////////////////////////////////////////////////
@@ -76,13 +78,13 @@ namespace range_detail
         template< typename T, std::size_t sz >
         inline const T* boost_range_end( const T (&array)[sz] )
         {
-            return range_detail::array_end<T,sz>( array ); 
+            return range_detail::array_end<T,sz>( array );
         }
-        
+
         template< typename T, std::size_t sz >
         inline T* boost_range_end( T (&array)[sz] )
         {
-            return range_detail::array_end<T,sz>( array ); 
+            return range_detail::array_end<T,sz>( array );
         }
 
         //////////////////////////////////////////////////////////////////////
@@ -134,18 +136,19 @@ namespace range_detail
 
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
     !BOOST_WORKAROUND(__GNUC__, < 3) \
-    /**/  
+    /**/
 } // namespace 'range_detail'
 #endif
 
 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
+inline BOOST_DEDUCED_TYPENAME range_iterator<
+                typename remove_const<T>::type >::type end( T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
     !BOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
     using namespace range_detail;
-#endif        
+#endif
     return boost_range_end( r );
 }
 
@@ -156,7 +159,7 @@ inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type end( const T& r )
     !BOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
     using namespace range_detail;
-#endif        
+#endif
     return boost_range_end( r );
 }
 
@@ -191,7 +194,7 @@ namespace boost
     inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
     const_end( const T& r )
     {
-        return end( r );
+        return boost::end( r );
     }
 }
 

include/boost/range/iterator_range.hpp

@@ -57,15 +57,13 @@ namespace boost
             template< class ForwardRange >
             static IteratorT adl_begin( ForwardRange& r )
             {
-                using boost::begin;
-                return IteratorT( begin( r ) );
+                return IteratorT( boost::begin( r ) );
             }
             
             template< class ForwardRange >
             static IteratorT adl_end( ForwardRange& r )
             {
-                using boost::end;
-                return IteratorT( end( r ) );
+                return IteratorT( boost::end( r ) );
             }
         };
  
@@ -74,23 +72,23 @@ namespace boost
         {
             typedef BOOST_DEDUCED_TYPENAME boost::range_size<Left>::type sz_type;
 
-            sz_type l_size = size( l ),
-                    r_size = size( r );
+            sz_type l_size = boost::size( l ),
+                    r_size = boost::size( r );
 
             if( l_size != r_size )
                 return false;
 
-            return std::equal( begin(l), end(l), 
-                               begin(r) );                
+            return std::equal( boost::begin(l), boost::end(l), 
+                               boost::begin(r) );                
         }
 
         template< class Left, class Right >
         inline bool less_than( const Left& l, const Right& r )
         {                
-            return std::lexicographical_compare( begin(l), 
-                                                 end(l), 
-                                                 begin(r), 
-                                                 end(r) );                
+            return std::lexicographical_compare( boost::begin(l), 
+                                                 boost::end(l), 
+                                                 boost::begin(r), 
+                                                 boost::end(r) );                
         }
            
         struct range_tag { };
@@ -142,6 +140,14 @@ namespace boost
 
             //! This type
             typedef iterator_range<IteratorT> this_type;
+
+            //! Refence type
+            //
+            // Needed because value-type is the same for 
+            // const and non-const iterators
+            //
+            typedef BOOST_DEDUCED_TYPENAME
+                iterator_reference<IteratorT>::type reference;
             
             //! const_iterator type
             /*! 
@@ -255,8 +261,12 @@ namespace boost
             { 
                 if( singular )
                     return 0;
-                
+
+#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x582))
+                return std::distance<IteratorT>( m_Begin, m_End );
+#else                
                 return std::distance( m_Begin, m_End );
+#endif                
             }
             
             bool empty() const
@@ -306,26 +316,38 @@ namespace boost
 #endif            
 
         public: // convenience
-           value_type& front() const
+           reference front() const
            {
                BOOST_ASSERT( !empty() );
                return *m_Begin;
            }
     
-           value_type& back() const
+           reference back() const
            {
                BOOST_ASSERT( !empty() );
                IteratorT last( m_End );
                return *--last;
            }
     
-           value_type& operator[]( size_type sz ) const
+           reference operator[]( size_type sz ) const
            {
                //BOOST_STATIC_ASSERT( is_random_access );
                BOOST_ASSERT( sz < size() );
                return m_Begin[sz];
            }
-            
+
+           iterator_range& advance_begin( difference_type n )
+           {
+               std::advance( m_Begin, n );
+               return *this;
+           }
+           
+           iterator_range& advance_end( difference_type n )
+           {
+               std::advance( m_End, n );
+               return *this;
+           }
+           
         private:
             // begin and end iterators
             IteratorT m_Begin;
@@ -360,7 +382,10 @@ namespace boost
                     std::basic_ostream<Elem, Traits>& Os,
                     const iterator_range<IteratorT>& r )
         {
-            std::copy( r.begin(), r.end(), std::ostream_iterator<Elem>(Os));
+            std::copy( r.begin(), r.end(), 
+                       std::ostream_iterator< BOOST_DEDUCED_TYPENAME 
+                                            iterator_value<IteratorT>::type, 
+                                              Elem, Traits>(Os) );
             return Os;
         }
 
@@ -479,7 +504,7 @@ namespace boost
         make_iterator_range( Range& r ) 
         {   
             return iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
-                ( begin( r ), end( r ) );
+                ( boost::begin( r ), boost::end( r ) );
         }
         
 #else
@@ -518,8 +543,8 @@ namespace boost
                     return make_iterator_range( r );
 
                 BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type 
-                    new_begin = begin( r ),
-                    new_end   = end( r );
+                    new_begin = boost::begin( r ),
+                    new_end   = boost::end( r );
                 std::advance( new_begin, advance_begin );
                 std::advance( new_end, advance_end );
                 return make_iterator_range( new_begin, new_end );
@@ -573,7 +598,7 @@ namespace boost
         template< typename SeqT, typename Range >
         inline SeqT copy_range( const Range& r )
         {
-            return SeqT( begin( r ), end( r ) );
+            return SeqT( boost::begin( r ), boost::end( r ) );
         }
 
 } // namespace 'boost'

include/boost/range/rbegin.hpp

@@ -26,7 +26,7 @@ namespace boost
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type
 rbegin( C& c )
 {
     return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( end( c ) );
@@ -35,21 +35,23 @@ rbegin( C& c )
 #else
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+                                                                typename remove_const<C>::type >::type
 rbegin( C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+                                                                typename remove_const<C>::type >::type
         iter_type;
-    return iter_type( end( c ) );
+    return iter_type( boost::end( c ) );
 }
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
 rbegin( const C& c )
 {
     typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
         iter_type;
-    return iter_type( end( c ) );
+    return iter_type( boost::end( c ) );
 }
 
 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -58,7 +60,7 @@ template< class T >
 inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
 const_rbegin( const T& r )
 {
-    return rbegin( r );
+    return boost::rbegin( r );
 }
 
 } // namespace 'boost'

include/boost/range/rend.hpp

@@ -22,34 +22,36 @@
 
 namespace boost
 {
-    
+
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type
 rend( C& c )
 {
-    return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( begin( c ) );
+    return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( boost::begin( c ) );
 }
 
 #else
-    
+
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+                                                                typename remove_const<C>::type >::type
 rend( C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type 
+        typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+                                                                typename remove_const<C>::type >::type
                iter_type;
-    return iter_type( begin( c ) );
+    return iter_type( boost::begin( c ) );
 }
 
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
 rend( const C& c )
 {
     typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
         iter_type;
-    return iter_type( begin( c ) );
+    return iter_type( boost::begin( c ) );
 }
 
 #endif
@@ -58,7 +60,7 @@ template< class T >
 inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
 const_rend( const T& r )
 {
-    return rend( r );
+    return boost::rend( r );
 }
 
 } // namespace 'boost'

include/boost/range/size_type.hpp

@@ -16,6 +16,54 @@
 #endif
 
 #include <boost/range/config.hpp>
+/*
+#include <boost/range/difference_type.hpp>
+
+namespace boost
+{
+        namespace range_detail
+        {
+                template< class T >
+                struct add_unsigned;
+
+                template<>
+                struct add_unsigned<short>
+                {
+                        typedef unsigned short type;
+                };
+
+                template<>
+                struct add_unsigned<int>
+                {
+                        typedef unsigned int type;
+                };
+
+                template<>
+                struct add_unsigned<long>
+                {
+                        typedef unsigned long type;
+                };
+
+#ifdef BOOST_HAS_LONG_LONG
+
+                template<>
+                struct add_unsigned<long long>
+                {
+                        typedef unsigned long long type;
+                };
+#endif
+
+        }
+
+        template< class T >
+        struct range_size
+        {
+                typedef BOOST_DEDUCED_TYPENAME range_detail::add_unsigned<
+                                        BOOST_DEDUCED_TYPENAME range_difference<T>::type >::type
+                        type;
+        };
+}
+*/
 
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #include <boost/range/detail/size_type.hpp>
@@ -29,13 +77,13 @@ namespace boost
     //////////////////////////////////////////////////////////////////////////
     // default
     //////////////////////////////////////////////////////////////////////////
-    
+
     template< typename C >
     struct range_size
     {
         typedef BOOST_DEDUCED_TYPENAME C::size_type type;
     };
-    
+
     //////////////////////////////////////////////////////////////////////////
     // pair
     //////////////////////////////////////////////////////////////////////////
@@ -45,7 +93,7 @@ namespace boost
     {
         typedef std::size_t type;
     };
-    
+
     template< typename Iterator >
     struct range_size< const std::pair<Iterator,Iterator> >
     {
@@ -124,4 +172,5 @@ namespace boost
 
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
+
 #endif

include/boost/range/sub_range.hpp

@@ -35,25 +35,23 @@ namespace boost
         typedef BOOST_DEDUCED_TYPENAME range_const_iterator<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;
+        typedef BOOST_DEDUCED_TYPENAME iterator_reference<const_iterator>::type   const_reference;
 
     public:
         sub_range() : base() 
         { }
-/*
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))  
-        typedef sub_range<ForwardRange> this_type;
-        
-        sub_range( this_type r ) :
-        : base( r )
-        { }
 
-        this_type& operator=( this_type r )
-        {
-            base::operator=( r );
-            return *this;
-        }
-#endif
-*/
+/*        
+        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 */
+
         template< class ForwardRange2 >
         sub_range( ForwardRange2& r ) : 
             
@@ -92,6 +90,16 @@ namespace boost
             base::operator=( r );
             return *this;
         }
+
+        sub_range& operator=( sub_range r )
+        {
+            //
+            // argument passed by value to avoid 
+            // const_iterator to iterator conversion
+            //
+            base::operator=( r );
+            return *this;            
+        }
         
     public:
         
@@ -103,32 +111,32 @@ namespace boost
 
         
     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[]( size_type sz )
         {
             return base::operator[](sz);
         }
 
-        const value_type& operator[]( size_type sz ) const
+        const_reference operator[]( size_type sz ) const
         {
             return base::operator[](sz);
         }

include/boost/range/value_type.hpp

@@ -16,12 +16,26 @@
 #endif
 
 #include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
 
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #include <boost/range/detail/value_type.hpp>
 #else
 
 #include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+        template< class T >
+    struct range_value
+        {
+                typedef BOOST_DEDUCED_TYPENAME iterator_value<
+                        BOOST_DEDUCED_TYPENAME range_iterator<T>::type >::type
+                                type;
+        };
+}
+
+/*
 #include <cstddef>
 #include <utility>
 
@@ -31,13 +45,13 @@ namespace boost
     //////////////////////////////////////////////////////////////////////////
     // default
     //////////////////////////////////////////////////////////////////////////
-    
+
     template< typename C >
     struct range_value
     {
         typedef BOOST_DEDUCED_TYPENAME C::value_type type;
     };
-    
+
     //////////////////////////////////////////////////////////////////////////
     // pair
     //////////////////////////////////////////////////////////////////////////
@@ -45,15 +59,15 @@ namespace boost
     template< typename Iterator >
     struct range_value< std::pair<Iterator,Iterator> >
     {
-        typedef BOOST_DEDUCED_TYPENAME 
+        typedef BOOST_DEDUCED_TYPENAME
             iterator_value<Iterator>::type type;
     };
-    
-    
+
+
     template< typename Iterator >
     struct range_value< const std::pair<Iterator,Iterator> >
     {
-        typedef BOOST_DEDUCED_TYPENAME 
+        typedef BOOST_DEDUCED_TYPENAME
             iterator_value<Iterator>::type type;
     };
 
@@ -72,7 +86,7 @@ namespace boost
     {
         typedef const T type;
     };
-    
+
     //////////////////////////////////////////////////////////////////////////
     // string
     //////////////////////////////////////////////////////////////////////////
@@ -126,7 +140,7 @@ namespace boost
     };
 
 } // namespace boost
-
+*/
 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 #endif

test/Jamfile

@@ -1,40 +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/
-#
-
-subproject libs/range/test ;
-
-import testing ;
-
-rule range-test ( name : includes * )
-{
-    return [
-        run $(name).cpp
-        <lib>../../test/build/boost_unit_test_framework
-        : 
-        : 
-        : <include>$(BOOST_ROOT)
-          $(includes)
-        ] ;
-}
-
-test-suite range :
-    [ range-test array ]
-    [ range-test iterator_pair ]
-    [ range-test std_container ]
-    [ range-test string ]
-    [ range-test iterator_range ]
-    [ range-test sub_range ]
-    [ range-test partial_workaround ]
-    [ range-test algorithm_example ]
-    [ range-test reversible_range ]
-    [ range-test const_ranges ]
-#    [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ] 
-    ;
-

test/Jamfile.v2

@@ -11,7 +11,7 @@
 rule range-test ( name : includes * )
 {
     return [
-        run $(name).cpp /boost/test//boost_unit_test_framework
+        run $(name).cpp /boost/test//boost_unit_test_framework/<link>static
         : 
         : 
         : $(includes)
@@ -29,6 +29,7 @@ test-suite range :
     [ range-test algorithm_example ]
     [ range-test reversible_range ]
     [ range-test const_ranges ]
-    [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ] 
+    [ range-test extension_mechanism ]
+#    [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ] 
     ;
 

test/TODO

@@ -1 +0,0 @@
-

test/extension_mechanism.cpp

@@ -0,0 +1,112 @@
+// 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/
+//
+
+
+#include <boost/detail/workaround.hpp>
+
+#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
+
+#include <boost/range.hpp>
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+#include <vector>
+
+//
+// Generic range algorithm
+//
+template< class Rng >
+typename boost::range_result_iterator<Rng>::type foo_algo( Rng& r )
+{
+        //
+        // This will only compile for Rng = UDT if the qualified calls
+        // find boost_range_XXX via ADL.
+        //
+        return boost::size(r) == 0u ? boost::begin(r) : boost::end(r);
+}
+
+namespace Foo
+{
+        //
+        // Our sample UDT
+        //
+        struct X
+        {
+                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;
+
+                void push_back( int i )
+                { vec.push_back(i); }
+        };
+
+        //
+        // The required functions. No type-traits need
+        // to be defined because X defines the proper set of
+        // nested types.
+        //
+        inline X::iterator boost_range_begin( X& x )
+        {
+                return x.vec.begin();
+        }
+
+
+        inline X::const_iterator boost_range_begin( const X& x )
+        {
+                return x.vec.begin();
+        }
+
+
+        inline X::iterator boost_range_end( X& x )
+        {
+                return x.vec.end();
+        }
+
+        inline X::const_iterator boost_range_end( const X& x )
+        {
+                return x.vec.end();
+        }
+
+        inline X::size_type boost_range_size( const X& x )
+        {
+                return x.vec.size();
+        }
+}
+
+void check_extension()
+{
+        Foo::X x;
+        x.push_back(3);
+        const Foo::X x2;
+
+        foo_algo( x );
+        foo_algo( x2 );
+}
+
+using boost::unit_test::test_suite;
+
+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_extension ) );
+
+    return test;
+}
+
+
+
+
+

test/iterator_range.cpp

@@ -1,6 +1,6 @@
 // Boost.Range library
 //
-//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
+//  Copyright Thorsten Ottosen & Larry Evans 2003-2005. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
@@ -27,6 +27,8 @@
 using namespace boost;
 using namespace std;
 
+void check_reference_type();
+
 void check_iterator_range()
 {
    
@@ -91,6 +93,8 @@ void check_iterator_range()
     BOOST_CHECK( rrr == "ello worl" );
     rrr = make_iterator_range( rrr, -1, 1 );
     BOOST_CHECK( rrr == str );
+
+    check_reference_type();
 }
 
 
@@ -105,3 +109,34 @@ test_suite* init_unit_test_suite( int argc, char* argv[] )
     return test;
 }
 
+
+//
+//
+// Check that constness is propgated correct from
+// the iterator types.
+// 
+// Test contributed by Larry Evans.
+// 
+
+template< class Container >
+int test_iter_range( Container& a_cont )
+{
+    typedef BOOST_DEDUCED_TYPENAME range_result_iterator<Container>::type citer_type;
+    typedef iterator_range<citer_type> riter_type;
+    riter_type a_riter( make_iterator_range( a_cont ) );
+    a_riter.front();
+    a_riter.back();
+    int i = a_riter[0];
+    return i;
+}
+
+
+
+void check_reference_type()
+{
+    typedef vector<int> veci_type;
+    veci_type a_vec;
+    a_vec.push_back( 999 );
+    test_iter_range<veci_type>(a_vec);
+    test_iter_range<veci_type const>(a_vec);
+}

test/partial_workaround.cpp

@@ -90,6 +90,13 @@ void check_partial_workaround()
 
 }
 
+#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+void check_partial_workaround()
+{
+}
+
+#endif
 
 #include <boost/test/unit_test.hpp>
 using boost::unit_test::test_suite;
@@ -102,18 +109,3 @@ test_suite* init_unit_test_suite( int argc, char* argv[] )
 
     return test;
 }
-
-#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
-#include <boost/test/unit_test.hpp>
-using boost::unit_test::test_suite;
-
-test_suite* init_unit_test_suite( int, char** )
-{
-    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
-    
-    return test;
-}
-
-#endif
-

test/sub_range.cpp

@@ -90,17 +90,6 @@ void check_sub_range()
     s.empty();
     r.size();
     s.size();
-    
-    irange singular_irange;
-    BOOST_CHECK( singular_irange.empty() );
-    BOOST_CHECK( singular_irange.size() == 0 );
-    
-    srange singular_srange;
-    BOOST_CHECK( singular_srange.empty() );
-    BOOST_CHECK( singular_srange.size() == 0 );
-
-    BOOST_CHECK( empty( singular_irange ) );
-    BOOST_CHECK( empty( singular_srange ) );
 
     srange rr = make_iterator_range( str );
     BOOST_CHECK( rr.equal( r ) );