Created a branch from trunk

[SVN r38959]
Remove V1 Jamfiles
2007-08-26 05:34:35 +00:00 · 2007-08-08 19:02:26 +00:00 · 2007-01-10 18:57:20 +00:00 · 2007-01-10 18:50:13 +00:00 · 2006-11-10 19:09:56 +00:00 · 2006-10-24 10:37:46 +00:00
55 changed files with 2416 additions and 1855 deletions
--- a/doc/boost_range.html
+++ b/doc/boost_range.html
--- a/doc/example.cpp
+++ b/doc/example.cpp
@ -0,0 +1,141 @@
+#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);
+}
+
--- a/doc/headers.html
+++ b/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
--- a/doc/history_ack.html
+++ b/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
    </p>

    <br>
--- a/doc/intro.html
+++ b/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>
--- a/doc/range.html
+++ b/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>
--- a/include/boost/range/as_array.hpp
+++ b/include/boost/range/as_array.hpp
@ -0,0 +1,45 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2006. 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/
+//
+
+#ifndef BOOST_RANGE_AS_ARRAY_HPP
+#define BOOST_RANGE_AS_ARRAY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/detail/str_types.hpp>
+
+namespace boost
+{
+
+    template< class R >
+    inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<R>::type > 
+    as_array( R& r )
+    {
+        return boost::make_iterator_range( r );
+    }
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+    template< class Range >
+    inline boost::iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type > 
+    as_array( const Range& r )
+    {
+        return boost::make_iterator_range( r );
+    }
+    
+#endif
+    
+}
+
+#endif
+
--- a/include/boost/range/as_literal.hpp
+++ b/include/boost/range/as_literal.hpp
@ -0,0 +1,120 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2006. 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/
+//
+
+#ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP
+#define BOOST_RANGE_DETAIL_AS_LITERAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#if 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 <cstring>
+#include <cwchar>
+
+namespace boost
+{
+    namespace range_detail
+    {
+        inline std::size_t length( const char* s )
+        {
+            return strlen( s );
+        }
+
+        inline std::size_t length( const wchar_t* s )
+        {
+            return wcslen( s );
+        }
+
+        //
+        // Remark: the compiler cannot choose between T* and T[sz]
+        // overloads, so we must put the T* internal to the
+        // unconstrained version.
+        // 
+
+        inline bool is_char_ptr( char* )
+        {
+            return true;
+        }
+        
+        inline bool is_char_ptr( const char* )
+        {
+            return true;
+        }
+
+        
+        inline bool is_char_ptr( wchar_t* )
+        {
+            return true;
+        }
+        
+        inline bool is_char_ptr( const wchar_t* )
+        {
+            return true;
+        }
+        
+        template< class T >
+        inline long is_char_ptr( T r )
+        {
+            return 0L;
+        }
+
+        template< class T >
+        inline iterator_range<T*> 
+        make_range( T* const r, bool )
+        {
+            return iterator_range<T*>( r, r + length(r) );
+        }
+
+        template< class T >
+        inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<T>::type> 
+        make_range( T& r, long )
+        {
+            return boost::make_iterator_range( r );
+        }
+
+    }
+    
+    template< class Range >
+    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type> 
+    as_literal( Range& r )
+    {
+        return range_detail::make_range( r, range_detail::is_char_ptr(r) );
+    }
+
+    template< class Range >
+    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type> 
+    as_literal( const Range& r )
+    {
+        return range_detail::make_range( r, range_detail::is_char_ptr(r) );
+    }
+
+    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 );
+    }
+
+    
+    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 );
+    }
+}
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+#endif
--- a/include/boost/range/begin.hpp
+++ b/include/boost/range/begin.hpp
@ -22,7 +22,6 @@
 #else

 #include <boost/range/iterator.hpp>
-#include <boost/range/const_iterator.hpp>

 namespace boost
 {
@ -38,16 +37,9 @@ namespace range_detail
    // primary template
    //////////////////////////////////////////////////////////////////////

-    template< typename C >
-    inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
-    boost_range_begin( const C& c )
-    {
-        return c.begin();
-    }
-
    template< typename C >
    inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
-    boost_range_begin( C& c )
+    range_begin( C& c )
    {
        return c.begin();
    }
@ -57,13 +49,13 @@ namespace range_detail
    //////////////////////////////////////////////////////////////////////

    template< typename Iterator >
-    inline Iterator boost_range_begin( const std::pair<Iterator,Iterator>& p )
+    inline Iterator range_begin( const std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }

    template< typename Iterator >
-    inline Iterator boost_range_begin( std::pair<Iterator,Iterator>& p )
+    inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }
@ -72,66 +64,22 @@ namespace range_detail
    // array
    //////////////////////////////////////////////////////////////////////

+    //
+    // May this be discarded? Or is it needed for bad compilers?
+    //
    template< typename T, std::size_t sz >
-    inline const T* boost_range_begin( const T (&array)[sz] )
+    inline const T* range_begin( const T (&array)[sz] )
    {
        return array;
    }

    template< typename T, std::size_t sz >
-    inline T* boost_range_begin( T (&array)[sz] )
+    inline T* range_begin( T (&array)[sz] )
    {
        return array;
    }


-    //////////////////////////////////////////////////////////////////////
-    // string
-    //////////////////////////////////////////////////////////////////////
-
-#if 1 || BOOST_WORKAROUND(__MWERKS__, <= 0x3204 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-// CW up to 9.3 and borland have troubles with function ordering
-    inline const char* boost_range_begin( const char* s )
-    {
-        return s;
-    }
-
-    inline char* boost_range_begin( char* s )
-    {
-        return s;
-    }
-
-    inline const wchar_t* boost_range_begin( const wchar_t* s )
-    {
-        return s;
-    }
-
-    inline wchar_t* boost_range_begin( wchar_t* s )
-    {
-        return s;
-    }
-#else
-    inline const char* boost_range_begin( const char*& s )
-    {
-        return s;
-    }
-
-    inline char* boost_range_begin( char*& s )
-    {
-        return s;
-    }
-
-    inline const wchar_t* boost_range_begin( const wchar_t*& s )
-    {
-        return s;
-    }
-
-    inline wchar_t* boost_range_begin( wchar_t*& s )
-    {
-        return s;
-    }
-#endif
-
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
    /**/
@ -147,36 +95,20 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
    /**/
    using namespace range_detail;
 #endif
-    return boost_range_begin( r );
+    return range_begin( r );
 }

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type begin( const T& r )
+inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
    /**/
    using namespace range_detail;
 #endif
-    return boost_range_begin( r );
+    return range_begin( r );
 }

-#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-// BCB and CW are not able to overload pointer when class overloads are also available.
-template<>
-inline range_const_iterator<const char*>::type begin<const char*>( const char*& r )
-{
-    return r;
-}
-
-template<>
-inline range_const_iterator<const wchar_t*>::type begin<const wchar_t*>( const wchar_t*& r )
-{
-    return r;
-}
-
-#endif
-
 } // namespace boost

 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@ -184,11 +116,12 @@ inline range_const_iterator<const wchar_t*>::type begin<const wchar_t*>( const w
 namespace boost
 {
    template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
+    inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
    const_begin( const T& r )
    {
-        return begin( r );
+        return boost::begin( r );
    }
 }

 #endif
+
--- a/include/boost/range/category.hpp
+++ b/include/boost/range/category.hpp
@ -0,0 +1,29 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2006. 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/
+//
+
+#ifndef BOOST_RANGE_CATEGORY_HPP
+#define BOOST_RANGE_CATEGORY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+    template< class T >
+    struct range_category : iterator_category< typename range_iterator<T>::type >
+    { };
+}
+
+#endif
--- a/include/boost/range/concepts.hpp
+++ b/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
--- a/include/boost/range/const_iterator.hpp
+++ b/include/boost/range/const_iterator.hpp
@ -21,6 +21,7 @@
 #include <boost/range/detail/const_iterator.hpp>
 #else

+#include <boost/type_traits/remove_const.hpp>
 #include <cstddef>
 #include <utility>

@ -46,12 +47,6 @@ namespace boost
        typedef Iterator type;
    };
    
-    template< typename Iterator >
-    struct range_const_iterator< const std::pair<Iterator,Iterator> >
-    {
-        typedef Iterator type;
-    };
-
    //////////////////////////////////////////////////////////////////////////
    // array
    //////////////////////////////////////////////////////////////////////////
@ -62,64 +57,6 @@ namespace boost
        typedef const T* type;
    };

-    template< typename T, std::size_t sz >
-    struct range_const_iterator< const T[sz] >
-    {
-        typedef const T* type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // string
-    //////////////////////////////////////////////////////////////////////////
-
-    template<>
-    struct range_const_iterator< char* >
-    {
-        typedef const char* type;
-    };
-
-    template<>
-    struct range_const_iterator< wchar_t* >
-    {
-        typedef const wchar_t* type;
-    };
-
-    template<>
-    struct range_const_iterator< const char* >
-    {
-        typedef const char* type;
-    };
-
-    template<>
-    struct range_const_iterator< const wchar_t* >
-    {
-        typedef const wchar_t* type;
-    };
-
-    template<>
-    struct range_const_iterator< char* const >
-    {
-        typedef const char* type;
-    };
-
-    template<>
-    struct range_const_iterator< wchar_t* const >
-    {
-        typedef const wchar_t* type;
-    };
-
-    template<>
-    struct range_const_iterator< const char* const >
-    {
-        typedef const char* type;
-    };
-
-    template<>
-    struct range_const_iterator< const wchar_t* const >
-    {
-        typedef const wchar_t* type;
-    };
-
 } // namespace boost

 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
--- a/include/boost/range/const_reverse_iterator.hpp
+++ b/include/boost/range/const_reverse_iterator.hpp
@ -15,22 +15,17 @@
 # pragma once
 #endif

-#include <boost/range/config.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
+#include <boost/range/reverse_iterator.hpp>

 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
+    //
+    // This interface is deprecated, use range_reverse_iterator<const T>
+    //
    
    template< typename C >
-    struct range_const_reverse_iterator
-    {
-        typedef reverse_iterator< 
-            BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type > type;
-    };
+    struct range_const_reverse_iterator : range_reverse_iterator<const C>
+    { };
    
 } // namespace boost

--- a/include/boost/range/detail/as_literal.hpp
+++ b/include/boost/range/detail/as_literal.hpp
@ -0,0 +1,33 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2006. 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/
+//
+
+#ifndef BOOST_RANGE_AS_LITERAL_HPP
+#define BOOST_RANGE_AS_LITERAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/detail/detail_str.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost
+{
+    template< class Range >
+    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type> 
+    as_literal( Range& r )
+    {
+        return ::boost::make_iterator_range( ::boost::range_detail::str_begin(r),
+                                             ::boost::range_detail::str_end(r) );
+    }
+
+}
+
+#endif
--- a/include/boost/range/detail/begin.hpp
+++ b/include/boost/range/detail/begin.hpp
@ -13,7 +13,7 @@

 #include <boost/config.hpp> // BOOST_MSVC
 #include <boost/detail/workaround.hpp>
-#include <boost/range/result_iterator.hpp>
+#include <boost/range/iterator.hpp>
 #include <boost/range/detail/common.hpp>
 #if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
 # include <boost/range/value_type.hpp>
@ -35,7 +35,7 @@ namespace boost
        struct range_begin<std_container_>
        {
            template< typename C >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type fun( C& c )
+            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type fun( C& c )
            {
                return c.begin();
            };
@ -49,7 +49,7 @@ namespace boost
        struct range_begin<std_pair_>
        {
            template< typename P >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type fun( const P& p )
+            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type fun( const P& p )
            {
                return p.first;
            }
@ -77,51 +77,10 @@ namespace boost
        #endif
        };

-        //////////////////////////////////////////////////////////////////////
-        // string
-        //////////////////////////////////////////////////////////////////////
-     
-        template<>
-        struct range_begin<char_ptr_>
-        {
-            static char* fun( char* s )
-            {
-                return s;
-            }
-        };
-
-        template<>
-        struct range_begin<const_char_ptr_>
-        {
-            static const char* fun( const char* s )
-            {
-                return s;
-            }
-        };
-        
-        template<>
-        struct range_begin<wchar_t_ptr_>
-        {
-            
-            static wchar_t* fun( wchar_t* s )
-            {
-                return s;
-            }
-        };
-
-        template<>
-        struct range_begin<const_wchar_t_ptr_>
-        {
-            static const wchar_t* fun( const wchar_t* s )
-            {
-                return s;
-            }
-        };
-
    } // namespace 'range_detail'
    
    template< typename C >
-    inline BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type 
+    inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
    begin( C& c )
    {
        return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
--- a/include/boost/range/detail/common.hpp
+++ b/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' 
@ -114,3 +114,4 @@ namespace boost
 }
        
 #endif
+
--- a/include/boost/range/detail/const_iterator.hpp
+++ b/include/boost/range/detail/const_iterator.hpp
@ -56,58 +56,6 @@ namespace boost
                    remove_extent<T>::type* type;
            };
        };
-        
-        template<>
-        struct range_const_iterator_<char_array_>
-        { 
-            template< typename T >
-            struct pts
-            {
-                typedef const BOOST_RANGE_DEDUCED_TYPENAME 
-                    remove_extent<T>::type* type;
-            };
-        };
-
-        template<>
-        struct range_const_iterator_<char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef const char* type; 
-            };         
-        };
-        
-        template<>
-        struct range_const_iterator_<const_char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef const char* type; 
-            };         
-        };
-
-        template<>
-        struct range_const_iterator_<wchar_t_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef const wchar_t* type; 
-            };         
-        };
-
-        template<>
-        struct range_const_iterator_<const_wchar_t_ptr_>
-        {
-             template< typename S >
-             struct pts
-             {
-                 typedef const wchar_t* type; 
-             };         
-         };
-
    } 
    
    template< typename C >
--- a/include/boost/range/detail/detail_str.hpp
+++ b/include/boost/range/detail/detail_str.hpp
@ -0,0 +1,376 @@
+// 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/
+//
+
+#ifndef BOOST_RANGE_DETAIL_DETAIL_STR_HPP
+#define BOOST_RANGE_DETAIL_DETAIL_STR_HPP
+
+#include <boost/config.hpp> // BOOST_MSVC
+#include <boost/range/iterator.hpp>
+
+namespace boost 
+{
+    
+    namespace range_detail
+    {
+        //
+        // iterator
+        //
+        
+        template<>
+        struct range_iterator_<char_array_>
+        { 
+            template< typename T >
+            struct pts
+            {
+                 typedef BOOST_RANGE_DEDUCED_TYPENAME 
+                    remove_extent<T>::type* type;
+            };
+        };
+
+        template<>
+        struct range_iterator_<char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef char* type; 
+            };         
+        };
+
+        template<>
+        struct range_iterator_<const_char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const char* type;
+            };         
+        };
+
+        template<>
+        struct range_iterator_<wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef wchar_t* type; 
+            };         
+        };
+
+        template<>
+        struct range_iterator_<const_wchar_t_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef const wchar_t* type; 
+             };         
+        };
+
+
+        //
+        // const iterator
+        //
+
+        template<>
+        struct range_const_iterator_<char_array_>
+        { 
+            template< typename T >
+            struct pts
+            {
+                typedef const BOOST_RANGE_DEDUCED_TYPENAME 
+                    remove_extent<T>::type* type;
+            };
+        };
+
+        template<>
+        struct range_const_iterator_<char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const char* type; 
+            };         
+        };
+
+        template<>
+        struct range_const_iterator_<const_char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const char* type; 
+            };         
+        };
+
+        template<>
+        struct range_const_iterator_<wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const wchar_t* type; 
+            };         
+        };
+
+        template<>
+        struct range_const_iterator_<const_wchar_t_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef const wchar_t* type; 
+             };         
+        };
+    }
+}
+
+#include <boost/range/detail/begin.hpp>
+#include <boost/range/detail/end.hpp>
+#include <boost/range/detail/size_type>
+#include <boost/range/detail/value_type>
+#include <boost/range/detail/common.hpp>
+
+namespace boost 
+{
+    
+    namespace range_detail
+    {
+        //
+        // str_begin()
+        //
+        template<>
+        struct range_begin<char_ptr_>
+        {
+            static char* fun( char* s )
+            {
+                return s;
+            }
+        };
+
+        template<>
+        struct range_begin<const_char_ptr_>
+        {
+            static const char* fun( const char* s )
+            {
+                return s;
+            }
+        };
+        
+        template<>
+        struct range_begin<wchar_t_ptr_>
+        {
+            
+            static wchar_t* fun( wchar_t* s )
+            {
+                return s;
+            }
+        };
+
+        template<>
+        struct range_begin<const_wchar_t_ptr_>
+        {
+            static const wchar_t* fun( const wchar_t* s )
+            {
+                return s;
+            }
+        };
+        
+        template< typename C >
+        inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
+        str_begin( C& c )
+        {
+            return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME 
+                range_detail::range<C>::type >::fun( c );
+        }
+
+        //
+        // str_end()
+        //
+
+        template<>
+        struct range_end<char_array_>
+        {
+            template< typename T, std::size_t sz >
+            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            {
+                return boost::range_detail::array_end( boost_range_array );
+            }
+        };
+        
+        template<>
+        struct range_end<wchar_t_array_>
+        {
+            template< typename T, std::size_t sz >
+            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            {
+                return boost::range_detail::array_end( boost_range_array );
+            }
+        };
+        
+        template<>
+        struct range_end<char_ptr_>
+        {
+            static char* fun( char* s )
+            {
+                return boost::range_detail::str_end( s );
+            }
+        };
+
+        template<>
+        struct range_end<const_char_ptr_>
+        {
+            static const char* fun( const char* s )
+            {
+                return boost::range_detail::str_end( s );
+            }
+        };
+
+        template<>
+        struct range_end<wchar_t_ptr_>
+        {
+            static wchar_t* fun( wchar_t* s )
+            {
+                return boost::range_detail::str_end( s );
+            }
+        };
+
+
+        template<>
+        struct range_end<const_wchar_t_ptr_>
+        {
+            static const wchar_t* fun( const wchar_t* s )
+            {
+                return boost::range_detail::str_end( s );
+            }
+        };
+
+        template< typename C >
+        inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
+        str_end( C& c )
+        {
+            return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME 
+                range_detail::range<C>::type >::fun( c );
+        }
+
+        //
+        // size_type
+        //
+
+        template<>
+        struct range_size_type_<char_array_>
+        { 
+            template< typename A >
+            struct pts
+            {
+                typedef std::size_t type;
+            };
+        };
+
+        template<>
+        struct range_size_type_<char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef std::size_t type;
+            };         
+        };
+        
+        template<>
+        struct range_size_type_<const_char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef std::size_t type;
+            };         
+        };
+        
+        template<>
+        struct range_size_type_<wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef std::size_t type;
+            };         
+        };
+        
+        template<>
+        struct range_size_type_<const_wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef std::size_t type;
+            };         
+        };  
+
+        //
+        // value_type
+        //
+        
+        template<>
+        struct range_value_type_<char_array_>
+        { 
+            template< typename T >
+            struct pts
+            {
+                typedef char type;
+            };
+        };
+
+        template<>
+        struct range_value_type_<char_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef char type; 
+             };         
+        };
+        
+        template<>
+        struct range_value_type_<const_char_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef const char type;
+             };         
+        };
+        
+        template<>
+        struct range_value_type_<wchar_t_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef wchar_t type;
+             };         
+        };
+        
+        template<>
+        struct range_value_type_<const_wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const wchar_t type;
+            };         
+        };
+
+    } // namespace 'range_detail'
+
+} // namespace 'boost'
+
+
+#endif
--- a/include/boost/range/detail/end.hpp
+++ b/include/boost/range/detail/end.hpp
@ -18,8 +18,7 @@
 # include <boost/range/detail/vc6/end.hpp>
 #else
 # include <boost/range/detail/implementation_help.hpp>
-# include <boost/range/detail/implementation_help.hpp>
-# include <boost/range/result_iterator.hpp>
+# include <boost/range/iterator.hpp>
 # include <boost/range/detail/common.hpp>
 # if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
 #  include <boost/range/detail/remove_extent.hpp>
@ -40,7 +39,7 @@ namespace boost
        struct range_end<std_container_>
        {
            template< typename C >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type 
+            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
            fun( C& c )
            {
                return c.end();
@ -55,7 +54,7 @@ namespace boost
        struct range_end<std_pair_>
        {
            template< typename P >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type 
+            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type 
            fun( const P& p )
            {
                return p.second;
@ -83,73 +82,11 @@ namespace boost
            }
        #endif
        };
-
-                
-        template<>
-        struct range_end<char_array_>
-        {
-            template< typename T, std::size_t sz >
-            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
-            {
-                return boost::range_detail::array_end( boost_range_array );
-            }
-        };
-        
-        template<>
-        struct range_end<wchar_t_array_>
-        {
-            template< typename T, std::size_t sz >
-            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
-            {
-                return boost::range_detail::array_end( boost_range_array );
-            }
-        };
-
-        //////////////////////////////////////////////////////////////////////
-        // string
-        //////////////////////////////////////////////////////////////////////
-        
-        template<>
-        struct range_end<char_ptr_>
-        {
-            static char* fun( char* s )
-            {
-                return boost::range_detail::str_end( s );
-            }
-        };
-
-        template<>
-        struct range_end<const_char_ptr_>
-        {
-            static const char* fun( const char* s )
-            {
-                return boost::range_detail::str_end( s );
-            }
-        };
-
-        template<>
-        struct range_end<wchar_t_ptr_>
-        {
-            static wchar_t* fun( wchar_t* s )
-            {
-                return boost::range_detail::str_end( s );
-            }
-        };
-
-
-        template<>
-        struct range_end<const_wchar_t_ptr_>
-        {
-            static const wchar_t* fun( const wchar_t* s )
-            {
-                return boost::range_detail::str_end( s );
-            }
-        };
        
    } // namespace 'range_detail'
    
    template< typename C >
-    inline BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type 
+    inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
    end( C& c )
    {
        return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
--- a/include/boost/range/detail/implementation_help.hpp
+++ b/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 )
                ;
@ -57,6 +57,7 @@ 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 )
        {
@ -80,25 +81,32 @@ namespace boost
        {
            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;
        }

        /////////////////////////////////////////////////////////////////////
@ -110,7 +118,8 @@ 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 )
        {
@ -134,24 +143,31 @@ namespace boost
        {
            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() );
+            */
+            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() );
+            */
+            return sz;
        }

    } // namespace 'range_detail'
--- a/include/boost/range/detail/iterator.hpp
+++ b/include/boost/range/detail/iterator.hpp
@ -64,60 +64,10 @@ namespace boost
            };
        };
        
-        template<>
-        struct range_iterator_<char_array_>
-        { 
-            template< typename T >
-            struct pts
-            {
-                 typedef BOOST_RANGE_DEDUCED_TYPENAME 
-                    remove_extent<T>::type* type;
-            };
-        };
-
-        template<>
-        struct range_iterator_<char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef char* type; 
-            };         
-        };
-        
-        template<>
-        struct range_iterator_<const_char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef const char* type;
-            };         
-        };
-
-        template<>
-        struct range_iterator_<wchar_t_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef wchar_t* type; 
-            };         
-        };
-
-        template<>
-        struct range_iterator_<const_wchar_t_ptr_>
-        {
-             template< typename S >
-             struct pts
-             {
-                 typedef const wchar_t* type; 
-             };         
-         };
    } 

    template< typename C >
-    class range_iterator
+    class range_mutable_iterator
    {
        typedef BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type c_type;
    public:
--- a/include/boost/range/detail/size_type.hpp
+++ b/include/boost/range/detail/size_type.hpp
@ -54,55 +54,7 @@ namespace boost
            };
        };

-        template<>
-        struct range_size_type_<char_array_>
-        { 
-            template< typename A >
-            struct pts
-            {
-                typedef std::size_t type;
-            };
-        };
-
-        template<>
-        struct range_size_type_<char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef std::size_t type;
-            };         
-        };
-        
-        template<>
-        struct range_size_type_<const_char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef std::size_t type;
-            };         
-        };
-        
-        template<>
-        struct range_size_type_<wchar_t_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef std::size_t type;
-            };         
-        };
-        
-        template<>
-        struct range_size_type_<const_wchar_t_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef std::size_t type;
-            };         
-        };  
+  
    } 
    
    template< typename C >
--- a/include/boost/range/detail/str_types.hpp
+++ b/include/boost/range/detail/str_types.hpp
@ -0,0 +1,38 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2006. 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/
+//
+
+#ifndef BOOST_RANGE_DETAIL_STR_TYPES_HPP
+#define BOOST_RANGE_DETAIL_STR_TYPES_HPP
+
+#include <boost/range/size_type.hpp>
+#include <boost/range/iterator.hpp>
+
+namespace boost
+{
+    template< class T >
+    struct range_mutable_iterator<T*>
+    {
+        typedef T* type;
+    };
+
+    template< class T >
+    struct range_const_iterator<T*>
+    {
+        typedef const T* type;
+    };
+
+    template< class T >
+    struct range_size<T*>
+    {
+       typedef std::size_t type;
+    };    
+}
+
+#endif
--- a/include/boost/range/detail/value_type.hpp
+++ b/include/boost/range/detail/value_type.hpp
@ -56,56 +56,6 @@ namespace boost
            };
        };
        
-        template<>
-        struct range_value_type_<char_array_>
-        { 
-            template< typename T >
-            struct pts
-            {
-                typedef char type;
-            };
-        };
-
-        template<>
-        struct range_value_type_<char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef char type; 
-            };         
-        };
-        
-        template<>
-        struct range_value_type_<const_char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef const char type;
-            };         
-        };
-
-        template<>
-        struct range_value_type_<wchar_t_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef wchar_t type;
-            };         
-        };
-
-        template<>
-        struct range_value_type_<const_wchar_t_ptr_>
-        {
-             template< typename S >
-             struct pts
-             {
-                 typedef const wchar_t type;
-             };         
-         };
-
    } 
    
    template< typename C >
--- a/include/boost/range/difference_type.hpp
+++ b/include/boost/range/difference_type.hpp
@ -16,116 +16,14 @@
 #endif

 #include <boost/range/config.hpp>
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/range/detail/difference_type.hpp>
-#else
-
+#include <boost/range/iterator.hpp>
 #include <boost/iterator/iterator_traits.hpp>
-#include <cstddef>
-#include <utility>

 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
-    
-    template< typename C >
-    struct range_difference
-    {
-        typedef BOOST_DEDUCED_TYPENAME C::difference_type type;
-    };
-    
-    //////////////////////////////////////////////////////////////////////////
-    // pair
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename Iterator >
-    struct range_difference< std::pair<Iterator,Iterator> >
-    {
-        typedef BOOST_DEDUCED_TYPENAME 
-            iterator_difference<Iterator>::type type;
-    };
-    
-    template< typename Iterator >
-    struct range_difference< const std::pair<Iterator,Iterator> >
-    {
-        typedef BOOST_DEDUCED_TYPENAME 
-            iterator_difference<Iterator>::type type;
-    };
-
-
-    //////////////////////////////////////////////////////////////////////////
-    // array
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename T, std::size_t sz >
-    struct range_difference< T[sz] >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template< typename T, std::size_t sz >
-    struct range_difference< const T[sz] >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // string
-    //////////////////////////////////////////////////////////////////////////
-
-    template<>
-    struct range_difference< char* >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< wchar_t* >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< const char* >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< const wchar_t* >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< char* const >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< wchar_t* const >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< const char* const >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< const wchar_t* const >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-} // namespace boost
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template< class T >
+    struct range_difference : iterator_difference< typename range_iterator<T>::type >
+    { };
+}

 #endif
--- a/include/boost/range/distance.hpp
+++ b/include/boost/range/distance.hpp
@ -0,0 +1,34 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2006. 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/
+//
+
+#ifndef BOOST_RANGE_DISTANCE_HPP
+#define BOOST_RANGE_DISTANCE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/difference_type.hpp>
+
+namespace boost 
+{
+
+    template< class T >
+    inline BOOST_DEDUCED_TYPENAME range_difference<T>::type 
+    distance( const T& r )
+    {
+        return std::distance( boost::begin( r ), boost::end( r ) );
+    }
+
+} // namespace 'boost'
+
+#endif
--- a/include/boost/range/empty.hpp
+++ b/include/boost/range/empty.hpp
@ -16,52 +16,19 @@
 #endif

 #include <boost/range/config.hpp>
-//#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-//#include <boost/range/detail/empty.hpp>
-//#else
-
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>

 namespace boost 
 { 
-namespace range_detail 
-{

-        //////////////////////////////////////////////////////////////////////
-        // primary template
-        //////////////////////////////////////////////////////////////////////
-
-        template< typename C >
-        inline bool empty( const C& c )
-        {
-            return boost::begin( c ) == boost::end( c );
-        }
-
-        //////////////////////////////////////////////////////////////////////
-        // string
-        //////////////////////////////////////////////////////////////////////
-
-        inline bool empty( const char* const& s )
-        {
-            return s == 0 || s[0] == 0;
-        }
-
-        inline bool empty( const wchar_t* const& s )
-        {
-            return s == 0 || s[0] == 0;
-        }
-        
-} // namespace 'range_detail'
-
-template< class T >
-inline bool empty( const T& r )
-{
-    return range_detail::empty( r );
-}
+    template< class T >
+    inline bool empty( const T& r )
+    {
+        return boost::begin( r ) == boost::end( r );
+    }

 } // namepace 'boost'

-//#endif //  BOOST_NO_FUNCTION_TEMPLATE_ORDERING

 #endif
--- a/include/boost/range/end.hpp
+++ b/include/boost/range/end.hpp
@ -25,116 +25,61 @@
 #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
-        boost_range_end( C& c )
+        range_end( C& c )
        {
            return c.end();
        }
-      
+
        //////////////////////////////////////////////////////////////////////
        // pair
        //////////////////////////////////////////////////////////////////////

        template< typename Iterator >
-        inline Iterator boost_range_end( const std::pair<Iterator,Iterator>& p )
+        inline Iterator range_end( const std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }
-        
+
        template< typename Iterator >
-        inline Iterator boost_range_end( std::pair<Iterator,Iterator>& p )
+        inline Iterator range_end( std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }
-        
+
        //////////////////////////////////////////////////////////////////////
        // array
        //////////////////////////////////////////////////////////////////////

        template< typename T, std::size_t sz >
-        inline const T* boost_range_end( const T (&array)[sz] )
+        inline const T* 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] )
+        inline T* range_end( T (&array)[sz] )
        {
-            return range_detail::array_end<T,sz>( array ); 
+            return range_detail::array_end<T,sz>( array );
        }

-        //////////////////////////////////////////////////////////////////////
-        // string
-        //////////////////////////////////////////////////////////////////////
-
-#if 1 || BOOST_WORKAROUND(__MWERKS__, <= 0x3204 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-// CW up to 9.3 and borland have troubles with function ordering
-        inline char* boost_range_end( char* s )
-        {
-            return range_detail::str_end( s );
-        }
-
-        inline wchar_t* boost_range_end( wchar_t* s )
-        {
-            return range_detail::str_end( s );
-        }
-
-        inline const char* boost_range_end( const char* s )
-        {
-            return range_detail::str_end( s );
-        }
-
-        inline const wchar_t* boost_range_end( const wchar_t* s )
-        {
-            return range_detail::str_end( s );
-        }
-#else
-        inline char* boost_range_end( char*& s )
-        {
-            return range_detail::str_end( s );
-        }
-
-        inline wchar_t* boost_range_end( wchar_t*& s )
-        {
-            return range_detail::str_end( s );
-        }
-
-        inline const char* boost_range_end( const char*& s )
-        {
-            return range_detail::str_end( s );
-        }
-
-        inline const wchar_t* boost_range_end( const wchar_t*& s )
-        {
-            return range_detail::str_end( s );
-        }
-#endif
-
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
-    /**/  
+    /**/
 } // namespace 'range_detail'
 #endif

@ -145,38 +90,20 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
    !BOOST_WORKAROUND(__GNUC__, < 3) \
    /**/
    using namespace range_detail;
-#endif        
-    return boost_range_end( r );
+#endif
+    return range_end( r );
 }

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type end( const T& r )
+inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
    /**/
    using namespace range_detail;
-#endif        
-    return boost_range_end( r );
-}
-
-
-
-#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-// BCB and CW are not able to overload pointer when class overloads are also available.
-template<>
-inline range_const_iterator<const char*>::type end<const char*>( const char*& r )
-{
-    return range_detail::str_end( r );
-}
-
-template<>
-inline range_const_iterator<const wchar_t*>::type end<const wchar_t*>( const wchar_t*& r )
-{
-    return range_detail::str_end( r );
-}
-
 #endif
+    return range_end( r );
+}

 } // namespace 'boost'

@ -188,11 +115,12 @@ inline range_const_iterator<const wchar_t*>::type end<const wchar_t*>( const wch
 namespace boost
 {
    template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
+    inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
    const_end( const T& r )
    {
-        return end( r );
+        return boost::end( r );
    }
 }

 #endif
+
--- a/include/boost/range/functions.hpp
+++ b/include/boost/range/functions.hpp
@ -1,6 +1,6 @@
 // Boost.Range library
 //
-//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
+//  Copyright Thorsten Ottosen 2003-2006. 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)
@ -18,8 +18,10 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/size.hpp>
+#include <boost/range/distance.hpp>
 #include <boost/range/empty.hpp>
 #include <boost/range/rbegin.hpp>
 #include <boost/range/rend.hpp>

 #endif
+
--- a/include/boost/range/iterator.hpp
+++ b/include/boost/range/iterator.hpp
@ -11,118 +11,30 @@
 #ifndef BOOST_RANGE_ITERATOR_HPP
 #define BOOST_RANGE_ITERATOR_HPP

-#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
 # pragma once
 #endif

 #include <boost/range/config.hpp>
-
-#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/range/detail/iterator.hpp>
-#else
-
-#include <boost/iterator/iterator_traits.hpp>
-#include <cstddef>
-#include <utility>
+#include <boost/range/mutable_iterator.hpp>
+#include <boost/range/const_iterator.hpp>
+#include <boost/type_traits/is_const.hpp>
+#include <boost/type_traits/remove_const.hpp>
+#include <boost/mpl/eval_if.hpp>

 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
-    
    template< typename C >
    struct range_iterator
    {
-        typedef BOOST_DEDUCED_TYPENAME C::iterator type;
+        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;
    };
    
-    //////////////////////////////////////////////////////////////////////////
-    // pair
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename Iterator >
-    struct range_iterator< std::pair<Iterator,Iterator> >
-    {
-        typedef Iterator type;
-    };
-    
-    template< typename Iterator >
-    struct range_iterator< const std::pair<Iterator,Iterator> >
-    {
-        typedef Iterator type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // array
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename T, std::size_t sz >
-    struct range_iterator< T[sz] >
-    {
-        typedef T* type;
-    };
-
-    template< typename T, std::size_t sz >
-    struct range_iterator< const T[sz] >
-    {
-        typedef const T* type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // string
-    //////////////////////////////////////////////////////////////////////////
-
-    template<>
-    struct range_iterator< char* >
-    {
-        typedef char* type;
-    };
-
-    template<>
-    struct range_iterator< wchar_t* >
-    {
-        typedef wchar_t* type;
-    };
-
-    template<>
-    struct range_iterator< const char* >
-    {
-        typedef const char* type;
-    };
-
-    template<>
-    struct range_iterator< const wchar_t* >
-    {
-        typedef const wchar_t* type;
-    };
-
-    template<>
-    struct range_iterator< char* const >
-    {
-        typedef char* type;
-    };
-
-    template<>
-    struct range_iterator< wchar_t* const >
-    {
-        typedef wchar_t* type;
-    };
-
-    template<>
-    struct range_iterator< const char* const >
-    {
-        typedef const char* type;
-    };
-
-    template<>
-    struct range_iterator< const wchar_t* const >
-    {
-        typedef const wchar_t* type;
-    };
-
 } // namespace boost

-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

 #endif
--- a/include/boost/range/iterator_range.hpp
+++ b/include/boost/range/iterator_range.hpp
@ -23,7 +23,7 @@

 #include <boost/detail/workaround.hpp>
 #include <boost/range/functions.hpp>
-#include <boost/range/result_iterator.hpp>
+#include <boost/range/iterator.hpp>
 #include <boost/range/difference_type.hpp>
 #include <boost/iterator/iterator_traits.hpp>    
 #include <boost/assert.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
            /*! 
@ -152,8 +158,10 @@ namespace boost
            //! iterator type
            typedef IteratorT iterator;

-            iterator_range() : m_Begin( iterator() ), m_End( iterator() ), 
-                               singular( true )
+            iterator_range() : m_Begin( iterator() ), m_End( iterator() )
+                #ifndef NDEBUG
+            , singular( true )
+                #endif
            { }
 /*
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))  
@ -172,41 +180,57 @@ namespace boost
            //! Constructor from a pair of iterators
            template< class Iterator >
            iterator_range( Iterator Begin, Iterator End ) : 
-                m_Begin(Begin), m_End(End), singular(false) {}
+                m_Begin(Begin), m_End(End)
+                #ifndef NDEBUG
+            , singular(false) 
+                 #endif
+            {}

            //! Constructor from a Range
            template< class Range >
            iterator_range( const Range& r ) : 
-                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ), 
-                singular(false) {}
-
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+                #ifndef NDEBUG
+            , singular(false) 
+                #endif
+            {}
+            
            //! Constructor from a Range
            template< class Range >
            iterator_range( Range& r ) : 
-                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ), 
-                singular(false) {}
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+                #ifndef NDEBUG
+            , singular(false) 
+                #endif
+            {}

            //! Constructor from a Range
            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 ) ), 
-                singular(false) {}
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+                 #ifndef NDEBUG
+            , singular(false) 
+                #endif
+            {}

            //! Constructor from a Range
            template< class Range >
            iterator_range( Range& r, iterator_range_detail::range_tag ) : 
-                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) ), 
-                singular(false) {}
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
+                 #ifndef NDEBUG
+            , singular(false) 
+                #endif
+            {}

            #if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
            this_type& operator=( const this_type& r )    
            {
                m_Begin  = r.begin(); 
                m_End    = r.end();
-                //
-                // remark: this need not necessarily be true, but it does no harm
-                //
+
+                #ifndef NDEBUG
                singular = r.singular;
+                #endif
                return *this;
            }
            #endif
@ -216,10 +240,9 @@ namespace boost
            {
                m_Begin  = r.begin(); 
                m_End    = r.end();
-                //
-                // remark: this need not necessarily be true, but it does no harm
-                //
-                singular = r.empty();
+                #ifndef NDEBUG
+                singular = r.is_singular();
+                #endif
                return *this;
            }
                                      
@ -228,7 +251,9 @@ namespace boost
            {
                m_Begin  = impl::adl_begin( r ); 
                m_End    = impl::adl_end( r );
+                #ifndef NDEBUG
                singular = false;
+                #endif
                return *this;
            }

@ -237,33 +262,33 @@ namespace boost
            {
                m_Begin  = impl::adl_begin( r ); 
                m_End    = impl::adl_end( r );
+                #ifndef NDEBUG    
                singular = false;
+                #endif
                return *this;
            }

            IteratorT begin() const 
            { 
+                BOOST_ASSERT( !is_singular() );
                return m_Begin; 
            }

            IteratorT end() const 
            { 
+                BOOST_ASSERT( !is_singular() );
                return m_End; 
            } 

            size_type size() const
            { 
-                if( singular )
-                    return 0;
-                
-                return std::distance( m_Begin, m_End );
+                BOOST_ASSERT( !is_singular() );
+                return m_End - m_Begin;
            }
            
            bool empty() const
            {
-                if( singular )
-                    return true;
-                
+                BOOST_ASSERT( !is_singular() );
                return m_Begin == m_End;
            }

@ -282,7 +307,8 @@ namespace boost

            bool equal( const iterator_range& r ) const
            {
-                return singular == r.singular && m_Begin == r.m_Begin && m_End == r.m_End;
+                BOOST_ASSERT( !is_singular() );
+                return m_Begin == r.m_Begin && m_End == r.m_End;
            }


@ -290,64 +316,85 @@ namespace boost

            bool operator==( const iterator_range& r ) const
            {
+                BOOST_ASSERT( !is_singular() );
                return iterator_range_detail::equal( *this, r );
            }

            bool operator!=( const iterator_range& r ) const
            {
+                BOOST_ASSERT( !is_singular() );
                return !operator==(r);
            }

           bool operator<( const iterator_range& r ) const
           {
-                return iterator_range_detail::less_than( *this, r );
+               BOOST_ASSERT( !is_singular() );
+               return iterator_range_detail::less_than( *this, r );
           }

 #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 )
+           {
+               BOOST_ASSERT( !is_singular() );
+               std::advance( m_Begin, n );
+               return *this;
+           }
+           
+           iterator_range& advance_end( difference_type n )
+           {
+               BOOST_ASSERT( !is_singular() );
+               std::advance( m_End, n );
+               return *this;
+           }
+           
        private:
            // begin and end iterators
            IteratorT m_Begin;
            IteratorT m_End;
+
+            #ifndef NDEBUG
            bool      singular;
+            #endif
+
+            #ifndef NDEBUG
+        public:
+            bool is_singular() const
+            {
+                 return singular;
+            }
+            #endif
+
+        protected:
+            //
+            // Allow subclasses an easy way to access the
+            // base type
+            //
+            typedef iterator_range iterator_range_;
        };

 //  iterator range free-standing operators ---------------------------//

-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-#else
-        template< class Iterator >
-        inline bool empty( const iterator_range<Iterator>& r )
-        {
-            //
-            // this will preserve the well-defined empty() even 
-            // though 'r' is singular.
-            //
-            return r.empty();
-        }
-#endif
-
 #ifndef BOOST_OLD_IOSTREAMS   

        //! iterator_range output operator
@ -360,7 +407,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;
        }

@ -475,11 +525,11 @@ namespace boost
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

        template< typename Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
+        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
        make_iterator_range( Range& r ) 
        {   
-            return iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
-                ( begin( r ), end( r ) );
+            return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+                ( boost::begin( r ), boost::end( r ) );
        }
        
 #else
@ -497,10 +547,10 @@ namespace boost
        }

        template< class ForwardRange >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type >
+        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
        make_iterator_range( const ForwardRange& r ) 
        {   
-           return iterator_range< BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type >
+           return iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type >
                ( r, iterator_range_detail::const_range_tag() );
        }

@ -509,17 +559,21 @@ namespace boost
        namespace iterator_range_detail
        {    
            template< class Range >
-            inline iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
+            inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
            make_range_impl( Range& r, 
                             BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
                             BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
            {
-                if( advance_begin == 0 && advance_end == 0 )
-                    return make_iterator_range( r );
+                //
+                // Not worth the effort
+                //
+                //if( advance_begin == 0 && advance_end == 0 )
+                //    return make_iterator_range( r );
+                //

-                BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type 
-                    new_begin = begin( r ),
-                    new_end   = end( r );
+                BOOST_DEDUCED_TYPENAME range_iterator<Range>::type 
+                    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 );
@ -529,7 +583,7 @@ namespace boost
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

        template< class Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type >
+        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
        make_iterator_range( Range& r, 
                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
@ -551,7 +605,7 @@ namespace boost
        }

        template< class Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_const_iterator<Range>::type >
+        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
        make_iterator_range( const Range& r, 
                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
@ -573,7 +627,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'
@ -581,3 +635,4 @@ namespace boost
 #undef BOOST_OLD_IOSTREAMS

 #endif
+
--- a/include/boost/range/metafunctions.hpp
+++ b/include/boost/range/metafunctions.hpp
@ -16,13 +16,15 @@
 #endif

 #include <boost/range/iterator.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/value_type.hpp>
-#include <boost/range/size_type.hpp>
-#include <boost/range/difference_type.hpp>
 #include <boost/range/result_iterator.hpp>
 #include <boost/range/reverse_iterator.hpp>
 #include <boost/range/const_reverse_iterator.hpp>
 #include <boost/range/reverse_result_iterator.hpp>
+#include <boost/range/value_type.hpp>
+#include <boost/range/size_type.hpp>
+#include <boost/range/difference_type.hpp>
+#include <boost/range/category.hpp>
+#include <boost/range/reference.hpp>
+#include <boost/range/pointer.hpp>

 #endif
--- a/include/boost/range/mutable_iterator.hpp
+++ b/include/boost/range/mutable_iterator.hpp
@ -0,0 +1,64 @@
+// 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/
+//
+
+#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP
+#define BOOST_RANGE_MUTABLE_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#include <boost/range/detail/iterator.hpp>
+#else
+
+#include <boost/iterator/iterator_traits.hpp>
+#include <cstddef>
+#include <utility>
+
+namespace boost
+{
+    //////////////////////////////////////////////////////////////////////////
+    // default
+    //////////////////////////////////////////////////////////////////////////
+    
+    template< typename C >
+    struct range_mutable_iterator
+    {
+        typedef BOOST_DEDUCED_TYPENAME C::iterator type;
+    };
+    
+    //////////////////////////////////////////////////////////////////////////
+    // pair
+    //////////////////////////////////////////////////////////////////////////
+
+    template< typename Iterator >
+    struct range_mutable_iterator< std::pair<Iterator,Iterator> >
+    {
+        typedef Iterator type;
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+    // array
+    //////////////////////////////////////////////////////////////////////////
+
+    template< typename T, std::size_t sz >
+    struct range_mutable_iterator< T[sz] >
+    {
+        typedef T* type;
+    };
+
+} // namespace boost
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#endif
--- a/include/boost/range/pointer.hpp
+++ b/include/boost/range/pointer.hpp
@ -0,0 +1,29 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2006. 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/
+//
+
+#ifndef BOOST_RANGE_POINTER_TYPE_HPP
+#define BOOST_RANGE_POINTER_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+    template< class T >
+    struct range_pointer : iterator_pointer< typename range_iterator<T>::type >
+    { };
+}
+
+#endif
--- a/include/boost/range/rbegin.hpp
+++ b/include/boost/range/rbegin.hpp
@ -16,9 +16,7 @@
 #endif

 #include <boost/range/end.hpp>
-#include <boost/range/reverse_result_iterator.hpp>
 #include <boost/range/reverse_iterator.hpp>
-#include <boost/range/const_reverse_iterator.hpp>

 namespace boost
 {
@ -26,41 +24,42 @@ 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_iterator<C>::type
 rbegin( C& c )
 {
-    return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( end( c ) );
+    return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( boost::end( c ) );
 }

 #else

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type 
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
 rbegin( C& c )
 {
    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::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_reverse_iterator<const C>::type
 rbegin( const C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
        iter_type;
-    return iter_type( end( c ) );
+    return iter_type( boost::end( c ) );
 }

 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
 const_rbegin( const T& r )
 {
-    return rbegin( r );
+    return boost::rbegin( r );
 }

 } // namespace 'boost'

 #endif
+
--- a/include/boost/range/reference.hpp
+++ b/include/boost/range/reference.hpp
@ -0,0 +1,29 @@
+// 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/
+//
+
+#ifndef BOOST_RANGE_REFERENCE_TYPE_HPP
+#define BOOST_RANGE_REFERENCE_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+    template< class T >
+    struct range_reference : iterator_reference< typename range_iterator<T>::type >
+    { };
+}
+
+#endif
--- a/include/boost/range/rend.hpp
+++ b/include/boost/range/rend.hpp
@ -16,51 +16,50 @@
 #endif

 #include <boost/range/begin.hpp>
-#include <boost/range/reverse_result_iterator.hpp>
 #include <boost/range/reverse_iterator.hpp>
-#include <boost/range/const_reverse_iterator.hpp>

 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_iterator<C>::type
 rend( C& c )
 {
-    return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( begin( c ) );
+    return BOOST_DEDUCED_TYPENAME range_reverse_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<C>::type
 rend( C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type 
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::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_reverse_iterator<const C>::type
 rend( const C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
        iter_type;
-    return iter_type( begin( c ) );
+    return iter_type( boost::begin( c ) );
 }

 #endif

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
 const_rend( const T& r )
 {
-    return rend( r );
+    return boost::rend( r );
 }

 } // namespace 'boost'

 #endif
+
--- a/include/boost/range/result_iterator.hpp
+++ b/include/boost/range/result_iterator.hpp
@ -15,29 +15,19 @@
 # pragma once
 #endif

-#include <boost/range/config.hpp>
 #include <boost/range/iterator.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/type_traits/is_const.hpp>
-#include <boost/mpl/if.hpp>

 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
+    //
+    // This interface is deprecated, use range_iterator<T>
+    //
    
    template< typename C >
-    struct range_result_iterator
-    {
-        typedef BOOST_RANGE_DEDUCED_TYPENAME 
-            mpl::if_< BOOST_DEDUCED_TYPENAME is_const<C>::type, 
-                      BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type,
-                      BOOST_DEDUCED_TYPENAME range_iterator<C>::type >::type type;
-    };
+    struct range_result_iterator : range_iterator<C>
+    { };
    
 } // namespace boost

-//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

 #endif
--- a/include/boost/range/reverse_result_iterator.hpp
+++ b/include/boost/range/reverse_result_iterator.hpp
@ -15,22 +15,17 @@
 # pragma once
 #endif

-#include <boost/range/config.hpp>
-#include <boost/range/result_iterator.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
+#include <boost/range/reverse_iterator.hpp>

 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
+    //
+    // This interface is deprecated, use range_reverse_iterator<T>
+    //
   
    template< typename C >
-    struct range_reverse_result_iterator
-    {
-        typedef reverse_iterator< 
-            BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type > type;
-    };
+    struct range_reverse_result_iterator : range_reverse_iterator<C>
+    { };
    
 } // namespace boost

--- a/include/boost/range/size.hpp
+++ b/include/boost/range/size.hpp
@ -15,109 +15,19 @@
 # pragma once
 #endif

-#include <boost/range/config.hpp>
-
-#ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-#include <boost/range/detail/size.hpp>
-#else
-
-#include <boost/range/detail/implementation_help.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
 #include <boost/range/size_type.hpp>
-#include <cstddef>
-#include <iterator>
-#include <utility>

 namespace boost 
 {

-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))    
-namespace range_detail 
-{
-#endif
-        //////////////////////////////////////////////////////////////////////
-        // primary template
-        //////////////////////////////////////////////////////////////////////
-        
-        template< typename C >
-        inline BOOST_DEDUCED_TYPENAME C::size_type
-        boost_range_size(  const C& c )
-        {
-            return c.size(); 
-        }
-
-        //////////////////////////////////////////////////////////////////////
-        // pair
-        //////////////////////////////////////////////////////////////////////
-
-        template< typename Iterator >
-        inline std::size_t boost_range_size(  const std::pair<Iterator,Iterator>& p )
-        {
-            return std::distance( p.first, p.second );
-        }
-
-        //////////////////////////////////////////////////////////////////////
-        // array
-        //////////////////////////////////////////////////////////////////////
-
-        template< typename T, std::size_t sz >
-        inline std::size_t boost_range_size(  const T (&array)[sz] )
-        {
-            return range_detail::array_size<T,sz>( array ); 
-        }
-        
-        template< typename T, std::size_t sz >
-        inline std::size_t boost_range_size(  T (&array)[sz] )
-        {
-            return boost::range_detail::array_size<T,sz>( array );
-        }
-        
-        //////////////////////////////////////////////////////////////////////
-        // string
-        //////////////////////////////////////////////////////////////////////
-
-        inline std::size_t boost_range_size(  const char* const& s )
-        {
-            return boost::range_detail::str_size( s );
-        }
-
-        inline std::size_t boost_range_size(  const wchar_t* const& s )
-        {
-            return boost::range_detail::str_size( s );
-        }
-
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))                
-} // namespace 'range_detail'
-#endif
-
-template< class T >
-inline BOOST_DEDUCED_TYPENAME range_size<T>::type size(  const T& r )
-{
-#if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))        
-    using namespace range_detail;
-#endif    
-    return boost_range_size( r );
-}
-
-
-#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003 ) || BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
-// BCB and CW are not able to overload pointer when class overloads are also available.
-inline range_size<const char*>::type size(  const char* r ) {
-    return range_detail::str_size( r );
-}
-inline range_size<char*>::type size(  char* r ) {
-    return range_detail::str_size( r );
-}
-inline range_size<const wchar_t*>::type size(  const wchar_t* r ) {
-    return range_detail::str_size( r );
-}
-inline range_size<wchar_t*>::type size(  wchar_t* r ) {
-    return range_detail::str_size( r );
-}
-#endif
-
+    template< class T >
+    inline BOOST_DEDUCED_TYPENAME range_size<T>::type size( const T& r )
+    {
+        return boost::end( r ) - boost::begin( r );
+    }

 } // namespace 'boost'

-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
 #endif
--- a/include/boost/range/size_type.hpp
+++ b/include/boost/range/size_type.hpp
@ -21,107 +21,58 @@
 #include <boost/range/detail/size_type.hpp>
 #else

+#include <boost/type_traits/remove_const.hpp>
 #include <cstddef>
 #include <utility>

 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
+    namespace detail
+    {
+
+        //////////////////////////////////////////////////////////////////////////
+        // default
+        //////////////////////////////////////////////////////////////////////////
    
-    template< typename C >
-    struct range_size
-    {
-        typedef BOOST_DEDUCED_TYPENAME C::size_type type;
-    };
+        template< typename C >
+        struct range_size
+        {
+            typedef BOOST_DEDUCED_TYPENAME C::size_type type;
+        };
    
-    //////////////////////////////////////////////////////////////////////////
-    // pair
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename Iterator >
-    struct range_size< std::pair<Iterator,Iterator> >
-    {
-        typedef std::size_t type;
-    };
+        //////////////////////////////////////////////////////////////////////////
+        // pair
+        //////////////////////////////////////////////////////////////////////////
    
-    template< typename Iterator >
-    struct range_size< const std::pair<Iterator,Iterator> >
-    {
-        typedef std::size_t type;
-    };
+        template< typename Iterator >
+        struct range_size< std::pair<Iterator,Iterator> >
+        {
+            typedef std::size_t type;
+        };
+    
+        //////////////////////////////////////////////////////////////////////////
+        // array
+        //////////////////////////////////////////////////////////////////////////
+    
+        template< typename T, std::size_t sz >
+        struct range_size< T[sz] >
+        {
+            typedef std::size_t type;
+        };
+    }

-    //////////////////////////////////////////////////////////////////////////
-    // array
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename T, std::size_t sz >
-    struct range_size< T[sz] >
-    {
-        typedef std::size_t type;
-    };
-
-    template< typename T, std::size_t sz >
-    struct range_size< const T[sz] >
-    {
-        typedef std::size_t type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // string
-    //////////////////////////////////////////////////////////////////////////
-
-    template<>
-    struct range_size< char* >
-    {
-        typedef std::size_t type;
-    };
-
-    template<>
-    struct range_size< wchar_t* >
-    {
-        typedef std::size_t type;
-    };
-
-    template<>
-    struct range_size< const char* >
-    {
-        typedef std::size_t type;
-    };
-
-    template<>
-    struct range_size< const wchar_t* >
-    {
-        typedef std::size_t type;
-    };
-
-    template<>
-    struct range_size< char* const >
-    {
-        typedef std::size_t type;
-    };
-
-    template<>
-    struct range_size< wchar_t* const >
-    {
-        typedef std::size_t type;
-    };
-
-    template<>
-    struct range_size< const char* const >
-    {
-        typedef std::size_t type;
-    };
-
-    template<>
-    struct range_size< const wchar_t* const >
-    {
-        typedef std::size_t type;
-    };
+    template< class T >
+    struct range_size : 
+        detail::range_size<T>
+    { };

+    template< class T >
+    struct range_size<const T > : range_size<T>
+    { };
+    
 } // namespace boost

 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

+
 #endif
--- a/include/boost/range/sub_range.hpp
+++ b/include/boost/range/sub_range.hpp
@ -14,7 +14,6 @@
 #include <boost/range/config.hpp>
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/value_type.hpp>
-#include <boost/range/result_iterator.hpp>
 #include <boost/range/size_type.hpp>
 #include <boost/range/difference_type.hpp>
 #include <boost/assert.hpp>
@ -23,37 +22,33 @@ namespace boost
 {
    
    template< class ForwardRange > 
-    class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type > 
+    class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type > 
    {
-        typedef BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type iterator_t;
+        typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator_t;
        typedef iterator_range< iterator_t  > base;

        typedef BOOST_DEDUCED_TYPENAME base::impl impl;
    public:
        typedef BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type            value_type;
-        typedef BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type  iterator;
-        typedef BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type   const_iterator;
+        typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type         iterator;
+        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;

    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 +87,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:
        
@ -160,3 +165,4 @@ namespace boost
 } // namespace 'boost'

 #endif
+
--- a/include/boost/range/value_type.hpp
+++ b/include/boost/range/value_type.hpp
@ -16,117 +16,19 @@
 #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
+//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//#include <boost/range/detail/value_type.hpp>
+//#else

 #include <boost/iterator/iterator_traits.hpp>
-#include <cstddef>
-#include <utility>
-

 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
-    
-    template< typename C >
-    struct range_value
-    {
-        typedef BOOST_DEDUCED_TYPENAME C::value_type type;
-    };
-    
-    //////////////////////////////////////////////////////////////////////////
-    // pair
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename Iterator >
-    struct range_value< std::pair<Iterator,Iterator> >
-    {
-        typedef BOOST_DEDUCED_TYPENAME 
-            iterator_value<Iterator>::type type;
-    };
-    
-    
-    template< typename Iterator >
-    struct range_value< const std::pair<Iterator,Iterator> >
-    {
-        typedef BOOST_DEDUCED_TYPENAME 
-            iterator_value<Iterator>::type type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // array
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename T, std::size_t sz >
-    struct range_value< T[sz] >
-    {
-        typedef T type;
-    };
-
-    template< typename T, std::size_t sz >
-    struct range_value< const T[sz] >
-    {
-        typedef const T type;
-    };
-    
-    //////////////////////////////////////////////////////////////////////////
-    // string
-    //////////////////////////////////////////////////////////////////////////
-
-    template<>
-    struct range_value< char* >
-    {
-        typedef char type;
-    };
-
-    template<>
-    struct range_value< wchar_t* >
-    {
-        typedef wchar_t type;
-    };
-
-    template<>
-    struct range_value< const char* >
-    {
-        typedef const char type;
-    };
-
-    template<>
-    struct range_value< const wchar_t* >
-    {
-        typedef const wchar_t type;
-    };
-
-    template<>
-    struct range_value< char* const >
-    {
-        typedef char type;
-    };
-
-    template<>
-    struct range_value< wchar_t* const >
-    {
-        typedef wchar_t type;
-    };
-
-    template<>
-    struct range_value< const char* const >
-    {
-        typedef const char type;
-    };
-
-    template<>
-    struct range_value< const wchar_t* const >
-    {
-        typedef const wchar_t type;
-    };
-
-} // namespace boost
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+    template< class T >
+    struct range_value : iterator_value< typename range_iterator<T>::type >
+    { };
+}

 #endif
--- a/test/Jamfile
+++ b/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 ] 
-    ;
-
--- a/test/Jamfile.v2
+++ b/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 ] 
    ;

--- a/test/algorithm_example.cpp
+++ b/test/algorithm_example.cpp
@ -17,6 +17,7 @@

 #include <boost/range/functions.hpp>
 #include <boost/range/metafunctions.hpp>
+#include <boost/range/as_literal.hpp>
 #include <boost/test/test_tools.hpp>
 #include <iostream>
 #include <algorithm>
@ -70,12 +71,8 @@ void check_algorithm()
    typedef std::vector<int>::iterator iterator;
    std::pair<iterator,iterator>       my_view( boost::begin( my_vector ), 
                                                boost::begin( my_vector ) + N );
-    char  str_val[] = "a string";
-    char* str       = str_val;
-    
    BOOST_CHECK_EQUAL( my_generic_replace( my_vector, 4, 2 ), 3u );
    BOOST_CHECK_EQUAL( my_generic_replace( my_view, 4, 2 ), N );
-    BOOST_CHECK_EQUAL( my_generic_replace( str, 'a', 'b' ), 0u );

 }

--- a/test/array.cpp
+++ b/test/array.cpp
@ -42,16 +42,16 @@ void check_array()
    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<array_t>::type, const int* >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<array_t>::type, std::ptrdiff_t >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<array_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<array_t>::type, int* >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const array_t>::type, const int* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<array_t>::type, int* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const array_t>::type, const int* >::value ));
    
    BOOST_STATIC_ASSERT(( is_same< range_value<const array_t>::type, const int >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_iterator<const array_t>::type, const int* >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const array_t>::type, const int* >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<const array_t>::type, std::ptrdiff_t >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<const array_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const array_t>::type, const int* >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const array_t>::type, const int* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const array_t>::type, const int* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const array_t>::type, const int* >::value ));
 #endif
    
    BOOST_CHECK_EQUAL( begin( my_array ), my_array );
--- a/test/extension_mechanism.cpp
+++ b/test/extension_mechanism.cpp
@ -0,0 +1,108 @@
+// 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_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 range_begin( X& x )
+        {
+                return x.vec.begin();
+        }
+
+
+        inline X::const_iterator range_begin( const X& x )
+        {
+                return x.vec.begin();
+        }
+
+
+        inline X::iterator range_end( X& x )
+        {
+                return x.vec.end();
+        }
+
+        inline X::const_iterator range_end( const X& x )
+        {
+                return x.vec.end();
+        }
+
+}
+
+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;
+}
+
+
+
+
+
--- a/test/iterator_pair.cpp
+++ b/test/iterator_pair.cpp
@ -46,18 +46,20 @@ void check_iterator_pair()
    BOOST_STATIC_ASSERT(( is_same< range_difference<pair_t>::type,                           
                          detail::iterator_traits<pair_t::first_type>::difference_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<pair_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<pair_t>::type, pair_t::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const_pair_t>::type, const_pair_t::first_type >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<pair_t>::type, pair_t::first_type >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_t>::type, const_pair_t::first_type >::value ));
    
    BOOST_STATIC_ASSERT(( is_same< range_value<const_pair_tt>::type, 
                          detail::iterator_traits<const_pair_t::first_type>::value_type>::value ));
    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
+    //
+    // This behavior is not supported with v2.
+    //BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<const_pair_tt>::type,                           
                          detail::iterator_traits<const_pair_tt::first_type>::difference_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<const_pair_tt>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));

    BOOST_CHECK( begin( pair ) == pair.first );
    BOOST_CHECK( end( pair )   == pair.second );
--- a/test/iterator_range.cpp
+++ b/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)
@ -8,6 +8,7 @@
 // For more information, see http://www.boost.org/libs/range/
 //

+//#include <boost/range/as_array.hpp>

 #include <boost/detail/workaround.hpp>

@ -16,7 +17,6 @@
 #  pragma warn -8057 // unused argument argc/argv in Boost.Test
 #endif

-
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/functions.hpp>
 #include <boost/test/test_tools.hpp>
@ -27,6 +27,8 @@
 using namespace boost;
 using namespace std;

+void check_reference_type();
+
 void check_iterator_range()
 {
   
@ -63,6 +65,12 @@ void check_iterator_range()
    BOOST_CHECK_EQUAL( distance( r.begin(), r.end() ), 
                       distance( begin( r2 ), end( r2 ) ) );
    cout << r << r2;
+
+        
+#ifndef BOOST_NO_STD_WSTRING
+    wcout << make_iterator_range( wstring( L"a wide string" ) ) 
+          << make_iterator_range( L"another wide string" );
+#endif    
    
    string res  = copy_range<string>( r );
    BOOST_CHECK( equal( res.begin(), res.end(), r.begin() ) );
@ -91,6 +99,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 +115,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_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);
+}
--- a/test/partial_workaround.cpp
+++ b/test/partial_workaround.cpp
@ -17,18 +17,15 @@
 #endif

 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//#define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 1

 #include <boost/range/iterator.hpp>
 #include <boost/range/const_iterator.hpp>
 #include <boost/range/size_type.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/range/difference_type.hpp>
-#include <boost/range/result_iterator.hpp>

-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/size.hpp>
-#include <boost/range/empty.hpp>
+#include <boost/range/functions.hpp>
 #include <boost/range/detail/sfinae.hpp>

 #include <boost/static_assert.hpp>
@ -90,6 +87,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 +106,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
-
--- a/test/reversible_range.cpp
+++ b/test/reversible_range.cpp
@ -23,6 +23,7 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
 #include <vector>
 #include <algorithm>

@ -31,7 +32,7 @@ using namespace std;

 void check_iterator()
 {
-    typedef vector<char>                          vec_t;
+    typedef vector<int>                           vec_t;
    typedef vec_t::iterator                       iterator;
    typedef pair<iterator,iterator>               pair_t;
    typedef range_reverse_iterator<pair_t>::type  rev_iterator;
@ -40,15 +41,8 @@ void check_iterator()
    vec_t                            vec;
    pair_t                           p    = make_pair( vec.begin(), vec.end() );
    rev_pair_t                       rp   = make_pair( rbegin( p ), rend( p ) );
-    char*                            str  = "mutable";
-    const char*                      cstr = "not mutable";
-    char                             a[]  = "mutable";
-    const char                       ca[] = "not mutable";                        
-    wchar_t*                         wstr = L"mutable";
-    const wchar_t*                   cwstr= L"not mutable";
-    wchar_t                          wa[] = L"mutable";
-    const wchar_t                    cwa[]= L"not mutable";
-         
+    int                             a[]  = {1,2,3,4,5,6,7,8,9,10};
+    const int                       ca[] = {1,2,3,4,5,6,7,8,9,10,11,12};                        
    BOOST_CHECK( rbegin( vec ) == range_reverse_iterator<vec_t>::type( vec.end() ) );
    BOOST_CHECK( rend( vec ) == range_reverse_iterator<vec_t>::type( vec.begin() ) );
    BOOST_CHECK( std::distance( rbegin( vec ), rend( vec ) ) == std::distance( begin( vec ), end( vec ) ) );
@ -58,33 +52,16 @@ void check_iterator()
    BOOST_CHECK( std::distance( rbegin( p ), rend( p ) ) == std::distance( begin( rp ), end( rp ) ) );
    BOOST_CHECK( std::distance( begin( p ), end( p ) ) == std::distance( rbegin( rp ), rend( rp ) ) );

-    BOOST_CHECK_EQUAL( &*begin( str ), &*( rend( str ) - 1 ) );
-    BOOST_CHECK_EQUAL( &*( end( str ) - 1 ), &*rbegin( str ) );
-    BOOST_CHECK_EQUAL( &*begin( cstr ), &*( rend( cstr ) - 1 ) );
-    BOOST_CHECK_EQUAL( &*( end( cstr ) - 1 ), &*rbegin( cstr ) );

    BOOST_CHECK_EQUAL( &*begin( a ), &*( rend( a ) - 1 ) );
    BOOST_CHECK_EQUAL( &*( end( a ) - 1 ), &*rbegin( a ) );
    BOOST_CHECK_EQUAL( &*begin( ca ), &*( rend( ca ) - 1 ) );
    BOOST_CHECK_EQUAL( &*( end( ca ) - 1 ), &*rbegin( ca ) );
-
-    BOOST_CHECK_EQUAL( &*begin( wstr ), &*( rend( wstr ) - 1 ) );
-    BOOST_CHECK_EQUAL( &*( end( wstr ) - 1 ), &*rbegin( wstr ) );
-    BOOST_CHECK_EQUAL( &*begin( cwstr ), &*( rend( cwstr ) - 1 ) );
-    BOOST_CHECK_EQUAL( &*( end( cwstr ) - 1 ), &*rbegin( cwstr ) );
-    
-    BOOST_CHECK_EQUAL( &*begin( wa ), &*( rend( wa ) - 1 ) );
-    BOOST_CHECK_EQUAL( &*( end( wa ) - 1 ), &*rbegin( wa ) );
-    BOOST_CHECK_EQUAL( &*begin( cwa ), &*( rend( cwa ) - 1 ) );
-    BOOST_CHECK_EQUAL( &*( end( cwa ) - 1 ), &*rbegin( cwa ) );
-
 }


-#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( "Range Test Suite" );
--- a/test/std_container.cpp
+++ b/test/std_container.cpp
@ -35,15 +35,13 @@ void check_std_container()

    BOOST_STATIC_ASSERT(( is_same< range_value<vec_t>::type, vec_t::value_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_iterator<vec_t>::type, vec_t::iterator >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<vec_t>::type, vec_t::const_iterator >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<vec_t>::type, vec_t::difference_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<vec_t>::type, vec_t::size_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<vec_t>::type, vec_t::iterator >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<vec_t>::type, vec_t::iterator >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
    
    BOOST_STATIC_ASSERT(( is_same< range_value<const vec_t>::type, vec_t::value_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<const vec_t>::type, vec_t::iterator >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<const vec_t>::type, vec_t::difference_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<const vec_t>::type, vec_t::size_type >::value ));

--- a/test/string.cpp
+++ b/test/string.cpp
@ -17,7 +17,10 @@
 #  pragma warn -8057 // unused argument argc/argv in Boost.Test
 #endif

-#include <boost/range.hpp>
+#include <boost/range/as_array.hpp>
+#include <boost/range/as_literal.hpp>
+#include <boost/range/functions.hpp>
+#include <boost/range/metafunctions.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/test/test_tools.hpp>
@ -26,36 +29,66 @@
 #include <fstream>
 #include <algorithm>

+template< class T >
+inline BOOST_DEDUCED_TYPENAME boost::range_iterator<T>::type
+str_begin( T& r )
+{
+    return boost::begin( 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) ); 
+}
+
+template< class T >
+inline BOOST_DEDUCED_TYPENAME boost::range_size<T>::type
+str_size( const T& r )
+{
+    return boost::size( as_literal(r) ); 
+}
+
+template< class T >
+inline bool
+str_empty( T& r )
+{
+    return boost::empty( as_literal(r) ); 
+}
+
 template< typename Container, typename T >
 BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type
 find( Container& c,  T value )
 {
-    return std::find( boost::begin( c ), boost::end( c ), value );
+    return std::find( str_begin(c), str_end(c), 
+                      value );
 }

 template< typename Container, typename T >
-BOOST_DEDUCED_TYPENAME boost::range_const_iterator<Container>::type
+BOOST_DEDUCED_TYPENAME boost::range_iterator<const Container>::type
 find( const Container& c, T value )
 {
-    return std::find( boost::begin( c ), boost::end( c ), value );
+    return std::find( str_begin(c), str_end(c), 
+                      value );
 }

 template< typename Container, typename T >
 BOOST_DEDUCED_TYPENAME boost::range_iterator<Container>::type
 find_mutable( Container& c,  T value )
-{
-    boost::size( c );
-    boost::end( c );
-    return std::find( boost::begin( c ), boost::end( c ), value );
+{ 
+    str_size( c );
+    return std::find( str_begin(c), str_end(c), 
+                      value );
 }

 template< typename Container, typename T >
-BOOST_DEDUCED_TYPENAME boost::range_const_iterator<Container>::type
+BOOST_DEDUCED_TYPENAME boost::range_iterator<const Container>::type
 find_const( const Container& c, T value )
 {
-    boost::size( c );
-    boost::end( c );
-    return std::find( boost::begin( c ), boost::end( c ), value );
+    str_size( c );
+    return std::find( str_begin(c), str_end(c), 
+                      value );
 }


@ -72,62 +105,66 @@ void check_char()
 {
    typedef char*                  char_iterator_t;
    typedef char                   char_array_t[10];
-    const char*      char_s           = "a string";
-    char             my_string[]      = "another string";
-    const unsigned   my_string_length = 14;
-    char*            char_s2          = "a string";
+    const char*      char_s            = "a string";
+    char             my_string[]       = "another string";
+    const char       my_const_string[] = "another string";
+    const unsigned   my_string_length  = 14;
+    char*            char_s2           = "a string";
    
    BOOST_STATIC_ASSERT(( is_same<  range_value<char_iterator_t>::type, 
                                    detail::iterator_traits<char_iterator_t>::value_type>::value ));
    BOOST_STATIC_ASSERT(( is_same<  range_iterator<char_iterator_t>::type, char_iterator_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same<  range_const_iterator<char_iterator_t>::type, const char* >::value ));
+
    BOOST_STATIC_ASSERT(( is_same<  range_difference<char_iterator_t>::type,                           
                                    ::std::ptrdiff_t >::value ));
    BOOST_STATIC_ASSERT(( is_same<  range_size<char_iterator_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same<  range_result_iterator<char_iterator_t>::type, char_iterator_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same<  range_result_iterator<const char*>::type, const char* >::value ));
+    BOOST_STATIC_ASSERT(( is_same<  range_iterator<char_iterator_t>::type, char_iterator_t >::value ));
+    BOOST_STATIC_ASSERT(( is_same<  range_iterator<const char*>::type, const char* >::value ));
    
    BOOST_STATIC_ASSERT(( is_same< range_value<char_array_t>::type, 
                                    char>::value ));
    BOOST_STATIC_ASSERT(( is_same< range_iterator<char_array_t>::type, char* >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<char_array_t>::type, const char* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const char_array_t>::type, const char* >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<char_array_t>::type,                           
                                    ::std::ptrdiff_t >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<char_array_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<char_array_t>::type, char* >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const char_array_t>::type, const char* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<char_array_t>::type, char* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const char_array_t>::type, const char* >::value ));

-    BOOST_CHECK_EQUAL( begin( char_s ), char_s );
-    std::size_t sz = size( char_s );
-    const char* end1 = begin( char_s ) + sz; 
-    BOOST_CHECK_EQUAL( end( char_s ), end1 );
-    BOOST_CHECK_EQUAL( empty( char_s ), (char_s == 0 || char_s[0] == char()) );
+    BOOST_CHECK_EQUAL( str_begin( char_s ), char_s );
+    std::size_t sz = str_size(char_s);
+    const char* str_end1 = str_begin( char_s ) + sz; 
+    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( begin( char_s2 ), char_s2 );
+    BOOST_CHECK_EQUAL( str_begin( char_s2 ), char_s2 );
    std::size_t sz2 = size( char_s2 );
-    const char* end12 = begin( char_s2 ) + sz;
-    BOOST_CHECK_EQUAL( end( char_s2 ), end12 );
+    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( begin( my_string ), my_string );
-    range_iterator<char_array_t>::type end2 = begin( my_string ) + size( my_string );
-    range_iterator<char_array_t>::type end3 = end( my_string );
-    BOOST_CHECK_EQUAL( end3, end2 );
-    BOOST_CHECK_EQUAL( empty( my_string ), (my_string == 0 || my_string[0] == char()) );
-    BOOST_CHECK_EQUAL( size( my_string ), my_string_length );
-    BOOST_CHECK_EQUAL( size( my_string ), std::char_traits<char>::length( my_string ) );
+    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);
+    BOOST_CHECK_EQUAL( str_end3, str_end2 );
+    BOOST_CHECK_EQUAL( str_empty( my_string ), (my_string == 0 || my_string[0] == char()) );
+    BOOST_CHECK_EQUAL( str_size( my_string ), my_string_length );
+    BOOST_CHECK_EQUAL( str_size( my_string ), std::char_traits<char>::length( my_string ) );

    char to_search = 'n';
-    BOOST_CHECK( find_mutable( char_s, to_search ) != end( char_s ) );
-    BOOST_CHECK( find_const( char_s, to_search ) != end( char_s ) );
+    BOOST_CHECK( find_mutable( char_s, to_search ) != str_end( char_s ) );
+    BOOST_CHECK( find_const( char_s, to_search ) != str_end(char_s) );

-    BOOST_CHECK( find_mutable( my_string, to_search ) != end( my_string ) );
-    BOOST_CHECK( find_const( my_string, to_search ) != end( my_string ) );
+    BOOST_CHECK( find_mutable( my_string, to_search ) != str_end(my_string) );
+    BOOST_CHECK( find_const( my_string, to_search ) != str_end(my_string) );

-    BOOST_CHECK( find_mutable( char_s2, to_search ) != end( char_s2 ) );   
-    BOOST_CHECK( find_const( char_s2, to_search ) != end( char_s2 ) );   
+    BOOST_CHECK( find_mutable( char_s2, to_search ) != str_end(char_s) );   
+    BOOST_CHECK( find_const( char_s2, to_search ) != str_end(char_s2) );
+
+    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) );
 }


@ -148,31 +185,31 @@ void check_string()
    BOOST_STATIC_ASSERT(( is_same< range_value<wchar_iterator_t>::type, 
                                   detail::iterator_traits<wchar_iterator_t>::value_type>::value ));
    BOOST_STATIC_ASSERT(( is_same< range_iterator<wchar_iterator_t>::type, wchar_iterator_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<wchar_iterator_t>::type, const wchar_t* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const wchar_t*>::type, const wchar_t* >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<wchar_iterator_t>::type,                           
                                   detail::iterator_traits<wchar_iterator_t>::difference_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<wchar_iterator_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<wchar_iterator_t>::type, wchar_iterator_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const wchar_t*>::type, const wchar_t* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<wchar_iterator_t>::type, wchar_iterator_t >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const wchar_t*>::type, const wchar_t* >::value ));
    
-    std::size_t sz = size( char_ws );
-    BOOST_CHECK_EQUAL( begin( char_ws ), char_ws );
-    BOOST_CHECK_EQUAL( end( char_ws ), (begin( char_ws ) + sz) );
-    BOOST_CHECK_EQUAL( empty( char_ws ), (char_ws == 0 || char_ws[0] == wchar_t()) );
+    std::size_t sz = str_size( char_ws );
+    BOOST_CHECK_EQUAL( str_begin( char_ws ), char_ws );
+    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( begin( char_ws2 ), char_ws2 );
-    BOOST_CHECK_EQUAL( end( char_ws2 ), (begin( char_ws2 ) + sz2) );
+    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 ) != end( char_ws ) );    
+    BOOST_CHECK( find( char_ws, to_search ) != str_end(char_ws) );    

 #if BOOST_WORKAROUND(_MSC_VER, BOOST_TESTED_AT(1300))

-    BOOST_CHECK( find( my_wstring, to_search ) != end( my_wstring ) );
+    BOOST_CHECK( find( my_wstring, to_search ) != str_end(my_wstring) );

 #endif  
 #endif
@ -181,7 +218,6 @@ void check_string()

 }

-
 #include <boost/test/unit_test.hpp>
 using boost::unit_test::test_suite;

--- a/test/sub_range.cpp
+++ b/test/sub_range.cpp
@ -90,17 +90,21 @@ 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 ) );
+    //
+    // As of range v2 not legal anymore.
+    //
+    //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 ) );
Author	SHA1	Message	Date
Ronald Garcia	f98d3eeb30	Created a branch from trunk [SVN r38959]	2007-08-26 05:34:35 +00:00
Vladimir Prus	51650f1aa2	Remove V1 Jamfiles [SVN r38516]	2007-08-08 19:02:26 +00:00
Thorsten Jørgen Ottosen	aeb47120e3	fixed typo [SVN r36684]	2007-01-10 18:57:20 +00:00
Thorsten Jørgen Ottosen	22b7b4ec8e	commented out old array code [SVN r36683]	2007-01-10 18:50:13 +00:00
Vladimir Prus	a933622ae1	Allow building of shared versions of some Boost.Test libraries. Adjust tests to use always use static linking to Boost.Test, since linking to the shared version requires test changes. Patch from Juergen Hunold. [SVN r35989]	2006-11-10 19:09:56 +00:00
Thorsten Jørgen Ottosen	f49be0b382	* empty log message * [SVN r35717]	2006-10-24 10:37:46 +00:00
Daniel James	007117cefb	Merge in recent fixes for inspect errors. [SVN r34973]	2006-08-27 10:40:36 +00:00
Thorsten Jørgen Ottosen	73bb3d899a	* empty log message * [SVN r34034]	2006-05-19 18:01:02 +00:00
Thorsten Jørgen Ottosen	4a8987865e	dos2unix on some files [SVN r34025]	2006-05-19 10:30:02 +00:00
Thorsten Jørgen Ottosen	f885495565	* empty log message * [SVN r34015]	2006-05-18 21:27:29 +00:00
Thorsten Jørgen Ottosen	dc34cd6079	* empty log message * [SVN r34014]	2006-05-18 21:11:55 +00:00
Thorsten Jørgen Ottosen	5850d7ce3e	new traits and functions for v2 [SVN r34013]	2006-05-18 20:53:21 +00:00
Thorsten Jørgen Ottosen	554f832234	upgrade to v2 [SVN r34012]	2006-05-18 20:52:17 +00:00
Thorsten Jørgen Ottosen	dc96b440be	v2 upgrade [SVN r34011]	2006-05-18 19:17:04 +00:00
Thorsten Jørgen Ottosen	1ac9efbd6a	* empty log message * [SVN r33301]	2006-03-10 09:16:22 +00:00
Thorsten Jørgen Ottosen	d2f0c15826	* empty log message * [SVN r33271]	2006-03-08 21:40:14 +00:00
Thorsten Jørgen Ottosen	ae953cda6b	* empty log message * [SVN r33260]	2006-03-07 21:11:19 +00:00
Thorsten Jørgen Ottosen	b22773b2e3	applied bug fixes [SVN r33038]	2006-02-20 21:15:05 +00:00
Vladimir Prus	e50a544c2a	Update Jamfile.v2 [SVN r32704]	2006-02-07 11:55:46 +00:00
Vladimir Prus	4b362a9cff	Rearrange the test to prevent undefined reference to init_unit_test_suite, when: - BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION is not defined - Toolset is gcc/Linux - Boost.Test is built as shared library [SVN r32703]	2006-02-07 11:55:10 +00:00
Thorsten Jørgen Ottosen	c75dc3ae02	added pass test for good compilers [SVN r32088]	2005-12-17 15:15:32 +00:00
Thorsten Jørgen Ottosen	fa03f39333	* empty log message * [SVN r32016]	2005-12-13 22:50:57 +00:00
Thorsten Jørgen Ottosen	6478f85444	* empty log message * [SVN r32015]	2005-12-13 22:50:00 +00:00
Thorsten Jørgen Ottosen	51f7fe9878	added new convinience funcs [SVN r31969]	2005-12-09 22:33:57 +00:00
Thorsten Jørgen Ottosen	c08103b1c5	merge from 1.33.1 [SVN r31968]	2005-12-09 22:22:32 +00:00
Thorsten Jørgen Ottosen	a2b6c3f5ec	fixed vc7.1 iterator conversion problems [SVN r31942]	2005-12-07 01:26:57 +00:00