This commit was manufactured by cvs2svn to create tag

'Version_1_33_1_beta'. [SVN r31604]
*** empty log message ***
2005-11-08 23:18:41 +00:00 · 2005-10-31 23:11:00 +00:00 · 2005-10-31 13:29:56 +00:00 · 2005-09-14 17:05:05 +00:00 · 2005-09-12 20:08:14 +00:00 · 2005-09-09 16:11:29 +00:00
55 changed files with 1697 additions and 1719 deletions
--- a/doc/example.cpp
+++ b/doc/example.cpp
@@ -3,106 +3,106 @@

 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;
-        };
+	//
+	// 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;
-        };
-        */
+	//
+	// 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_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_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;
-        };
-        */
+	struct range_difference< Foo::Pair<T> >
+	{
+		typedef typename std::iterator_traits<T>::difference_type type;
+	};
+	*/

-        template< class T >
+	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;
-        };
+	{
+		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;
-        }
+	//
+	// 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;
-        }
+	inline T boost_range_begin( const Pair<T>& x )
+	{ 
+		return x.first;
+	}

-        template< class T >
+	template< class T >
    inline T boost_range_end( Pair<T>& x )
-        {
-                return x.last;
-        }
+	{ 
+		return x.last;
+	}

-        template< class T >
+	template< class T >
    inline T boost_range_end( const Pair<T>& x )
-        {
-                return x.last;
-        }
+	{ 
+		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);
-        }
+	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'

@@ -110,32 +110,32 @@ namespace Foo

 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 );
+	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
+	//

-        //
-        // Test metafunctions
-        //
+	boost::range_value< Foo::Pair<iter> >::type 
+	v = *boost::begin(pair);

-        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);
+	boost::range_difference< Foo::Pair<iter> >::type 
+	d = boost::end(pair) - boost::begin(pair);
 }

--- a/doc/headers.html
+++ b/doc/headers.html
@@ -141,11 +141,6 @@
            <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,12 +56,9 @@ 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-2006
+    (C) Copyright Thorsten Ottosen 2003-2005
    </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=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=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=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,8 +36,6 @@
            <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>
@@ -452,59 +450,6 @@ 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
@@ -1,45 +0,0 @@
-// 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
@@ -1,120 +0,0 @@
-// 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
@@ -15,6 +15,7 @@
 # pragma once
 #endif

+#include <boost/type_traits/remove_const.hpp>
 #include <boost/range/config.hpp>

 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -22,6 +23,7 @@
 #else

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

 namespace boost
 {
@@ -38,8 +40,16 @@ namespace range_detail
    //////////////////////////////////////////////////////////////////////

    template< typename C >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
-    range_begin( C& 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< 
+									typename remove_const<C>::type >::type
+    boost_range_begin( C& c )
    {
        return c.begin();
    }
@@ -49,13 +59,13 @@ namespace range_detail
    //////////////////////////////////////////////////////////////////////

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

    template< typename Iterator >
-    inline Iterator range_begin( std::pair<Iterator,Iterator>& p )
+    inline Iterator boost_range_begin( std::pair<Iterator,Iterator>& p )
    {
        return p.first;
    }
@@ -64,22 +74,66 @@ 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* range_begin( const T (&array)[sz] )
+    inline const T* boost_range_begin( const T (&array)[sz] )
    {
        return array;
    }

    template< typename T, std::size_t sz >
-    inline T* range_begin( T (&array)[sz] )
+    inline T* boost_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) \
    /**/
@@ -88,27 +142,44 @@ namespace range_detail


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

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
+inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type begin( const T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
    /**/
    using namespace range_detail;
 #endif
-    return range_begin( r );
+    return boost_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
@@ -116,12 +187,11 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type begin( const T& r )
 namespace boost
 {
    template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
+    inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
    const_begin( const T& r )
    {
-        return boost::begin( r );
+        return begin( r );
    }
 }

 #endif
-
--- a/include/boost/range/category.hpp
+++ b/include/boost/range/category.hpp
@@ -1,29 +0,0 @@
-// 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
@@ -1,155 +0,0 @@
-// 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/config.hpp
+++ b/include/boost/range/config.hpp
@@ -37,7 +37,7 @@
 #error "macro already defined!"
 #endif

-//#if BOOST_WORKAROUND( BOOST_MSVC, < 1300 ) || __MWERKS__ <= 0x3003
+//#if BOOST_WORKAROUND( BOOST_MSVC, <= 1200 ) || __MWERKS__ <= 0x3003
 #if _MSC_VER <= 1300 && !defined( __COMO__ ) && !defined( __GNUC__ ) && __MWERKS__ <= 0x3003
 #define BOOST_RANGE_NO_ARRAY_SUPPORT 1
 #endif
--- a/include/boost/range/const_iterator.hpp
+++ b/include/boost/range/const_iterator.hpp
@@ -21,7 +21,6 @@
 #include <boost/range/detail/const_iterator.hpp>
 #else

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

@@ -47,6 +46,12 @@ namespace boost
        typedef Iterator type;
    };
    
+    template< typename Iterator >
+    struct range_const_iterator< const std::pair<Iterator,Iterator> >
+    {
+        typedef Iterator type;
+    };
+
    //////////////////////////////////////////////////////////////////////////
    // array
    //////////////////////////////////////////////////////////////////////////
@@ -57,6 +62,64 @@ 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,17 +15,22 @@
 # pragma once
 #endif

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

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

--- a/include/boost/range/detail/as_literal.hpp
+++ b/include/boost/range/detail/as_literal.hpp
@@ -1,33 +0,0 @@
-// 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/iterator.hpp>
+#include <boost/range/result_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_iterator<C>::type fun( C& c )
+            static BOOST_RANGE_DEDUCED_TYPENAME range_result_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_iterator<P>::type fun( const P& p )
+            static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type fun( const P& p )
            {
                return p.first;
            }
@@ -77,10 +77,51 @@ 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_iterator<C>::type 
+    inline BOOST_RANGE_DEDUCED_TYPENAME range_result_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,4 +114,3 @@ namespace boost
 }
        
 #endif
-
--- a/include/boost/range/detail/const_iterator.hpp
+++ b/include/boost/range/detail/const_iterator.hpp
@@ -56,6 +56,58 @@ 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
@@ -1,376 +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/
-//
-
-#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,7 +18,8 @@
 # include <boost/range/detail/vc6/end.hpp>
 #else
 # include <boost/range/detail/implementation_help.hpp>
-# include <boost/range/iterator.hpp>
+# include <boost/range/detail/implementation_help.hpp>
+# include <boost/range/result_iterator.hpp>
 # include <boost/range/detail/common.hpp>
 # if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
 #  include <boost/range/detail/remove_extent.hpp>
@@ -39,7 +40,7 @@ namespace boost
        struct range_end<std_container_>
        {
            template< typename C >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
+            static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type 
            fun( C& c )
            {
                return c.end();
@@ -54,7 +55,7 @@ namespace boost
        struct range_end<std_pair_>
        {
            template< typename P >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type 
+            static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type 
            fun( const P& p )
            {
                return p.second;
@@ -82,11 +83,73 @@ 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_iterator<C>::type 
+    inline BOOST_RANGE_DEDUCED_TYPENAME range_result_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 )
                ;
@@ -54,10 +54,9 @@ namespace boost
        template< class Char >
        inline Char* str_end( Char* s )
        {
-            return const_cast<Char*>( str_end( s, s ) );
+            return (Char*)str_end( s, s );
        }

-        /*
        template< class T, std::size_t sz >
        inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz], int )
        {
@@ -81,32 +80,25 @@ 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;
        }

        /////////////////////////////////////////////////////////////////////
@@ -118,8 +110,7 @@ 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 )
        {
@@ -143,31 +134,24 @@ 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,10 +64,60 @@ 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_mutable_iterator
+    class range_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,7 +54,55 @@ 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
@@ -1,38 +0,0 @@
-// 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,6 +56,56 @@ 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,14 +16,130 @@
 #endif

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

 namespace boost
 {
-    template< class T >
-    struct range_difference : iterator_difference< typename range_iterator<T>::type >
-    { };
+	template< class T >
+	struct range_difference
+	{
+		typedef BOOST_DEDUCED_TYPENAME iterator_difference<
+			BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type >::type 
+				type;
+	};
 }

+//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//#include <boost/range/detail/difference_type.hpp>
+//#else
+
+/*
+#include <cstddef>
+#include <utility>
+
+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
+*/
+
 #endif
--- a/include/boost/range/distance.hpp
+++ b/include/boost/range/distance.hpp
@@ -1,34 +0,0 @@
-// 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,19 +16,52 @@
 #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 
+{

-    template< class T >
-    inline bool empty( const T& r )
-    {
-        return boost::begin( r ) == boost::end( r );
-    }
+        //////////////////////////////////////////////////////////////////////
+        // 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 );
+}

 } // namepace 'boost'

+//#endif //  BOOST_NO_FUNCTION_TEMPLATE_ORDERING

 #endif
--- a/include/boost/range/end.hpp
+++ b/include/boost/range/end.hpp
@@ -15,6 +15,7 @@
 # pragma once
 #endif

+#include <boost/type_traits/remove_const.hpp>
 #include <boost/range/config.hpp>

 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@@ -25,86 +26,161 @@
 #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_iterator<C>::type
-        range_end( C& 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< 
+					typename remove_const<C>::type >::type
+        boost_range_end( C& c )
+        {
+            return c.end();
+        }
+      
        //////////////////////////////////////////////////////////////////////
        // pair
        //////////////////////////////////////////////////////////////////////

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

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

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

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type end( T& r )
+inline BOOST_DEDUCED_TYPENAME range_iterator< 
+		typename remove_const<T>::type >::type end( T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
    /**/
    using namespace range_detail;
-#endif
-    return range_end( r );
+#endif        
+    return boost_range_end( r );
 }

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
+inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type end( const T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
    !BOOST_WORKAROUND(__GNUC__, < 3) \
    /**/
    using namespace range_detail;
-#endif
-    return range_end( r );
+#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
+
 } // namespace 'boost'


@@ -115,12 +191,11 @@ inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type end( const T& r )
 namespace boost
 {
    template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
+    inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
    const_end( const T& r )
    {
-        return boost::end( r );
+        return 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-2006. Use, modification and
+//  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)
@@ -18,10 +18,8 @@
 #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,30 +11,118 @@
 #ifndef BOOST_RANGE_ITERATOR_HPP
 #define BOOST_RANGE_ITERATOR_HPP

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

 #include <boost/range/config.hpp>
-#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>
+
+#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_iterator
    {
-        typedef BOOST_RANGE_DEDUCED_TYPENAME 
-            mpl::eval_if_c< is_const<C>::value, 
-                            range_const_iterator< typename remove_const<C>::type >,
-                            range_mutable_iterator<C> >::type type;
+        typedef BOOST_DEDUCED_TYPENAME C::iterator 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/iterator.hpp>
+#include <boost/range/result_iterator.hpp>
 #include <boost/range/difference_type.hpp>
 #include <boost/iterator/iterator_traits.hpp>    
 #include <boost/assert.hpp>
@@ -57,13 +57,15 @@ namespace boost
            template< class ForwardRange >
            static IteratorT adl_begin( ForwardRange& r )
            {
-                return IteratorT( boost::begin( r ) );
+                using boost::begin;
+                return IteratorT( begin( r ) );
            }
            
            template< class ForwardRange >
            static IteratorT adl_end( ForwardRange& r )
            {
-                return IteratorT( boost::end( r ) );
+                using boost::end;
+                return IteratorT( end( r ) );
            }
        };
 
@@ -72,23 +74,23 @@ namespace boost
        {
            typedef BOOST_DEDUCED_TYPENAME boost::range_size<Left>::type sz_type;

-            sz_type l_size = boost::size( l ),
-                    r_size = boost::size( r );
+            sz_type l_size = size( l ),
+                    r_size = size( r );

            if( l_size != r_size )
                return false;

-            return std::equal( boost::begin(l), boost::end(l), 
-                               boost::begin(r) );                
+            return std::equal( begin(l), end(l), 
+                               begin(r) );                
        }

        template< class Left, class Right >
        inline bool less_than( const Left& l, const Right& r )
        {                
-            return std::lexicographical_compare( boost::begin(l), 
-                                                 boost::end(l), 
-                                                 boost::begin(r), 
-                                                 boost::end(r) );                
+            return std::lexicographical_compare( begin(l), 
+                                                 end(l), 
+                                                 begin(r), 
+                                                 end(r) );                
        }
           
        struct range_tag { };
@@ -140,14 +142,6 @@ 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
            /*! 
@@ -158,10 +152,8 @@ namespace boost
            //! iterator type
            typedef IteratorT iterator;

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

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

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

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

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

@@ -262,33 +237,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
            { 
-                BOOST_ASSERT( !is_singular() );
-                return m_End - m_Begin;
+                if( singular )
+                    return 0;
+                
+                return std::distance( m_Begin, m_End );
            }
            
            bool empty() const
            {
-                BOOST_ASSERT( !is_singular() );
+                if( singular )
+                    return true;
+                
                return m_Begin == m_End;
            }

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

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


@@ -316,85 +290,64 @@ 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
           {
-               BOOST_ASSERT( !is_singular() );
-               return iterator_range_detail::less_than( *this, r );
+                return iterator_range_detail::less_than( *this, r );
           }

 #endif            

        public: // convenience
-           reference front() const
+           value_type& front() const
           {
               BOOST_ASSERT( !empty() );
               return *m_Begin;
           }
    
-           reference back() const
+           value_type& back() const
           {
               BOOST_ASSERT( !empty() );
               IteratorT last( m_End );
               return *--last;
           }
    
-           reference operator[]( size_type sz ) const
+           value_type& 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
@@ -407,10 +360,7 @@ namespace boost
                    std::basic_ostream<Elem, Traits>& Os,
                    const iterator_range<IteratorT>& r )
        {
-            std::copy( r.begin(), r.end(), 
-                       std::ostream_iterator< BOOST_DEDUCED_TYPENAME 
-                                              iterator_value<IteratorT>::type, 
-                                              Elem, Traits>(Os) );
+            std::copy( r.begin(), r.end(), std::ostream_iterator<Elem>(Os));
            return Os;
        }

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

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

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

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

-                BOOST_DEDUCED_TYPENAME range_iterator<Range>::type 
-                    new_begin = boost::begin( r ),
-                    new_end   = boost::end( r );
+                BOOST_DEDUCED_TYPENAME range_result_iterator<Range>::type 
+                    new_begin = begin( r ),
+                    new_end   = end( r );
                std::advance( new_begin, advance_begin );
                std::advance( new_end, advance_end );
                return make_iterator_range( new_begin, new_end );
@@ -583,7 +529,7 @@ namespace boost
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

        template< class Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<Range>::type >
+        inline iterator_range< BOOST_DEDUCED_TYPENAME range_result_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 )
@@ -605,7 +551,7 @@ namespace boost
        }

        template< class Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
+        inline iterator_range< BOOST_DEDUCED_TYPENAME range_const_iterator<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 )
@@ -627,7 +573,7 @@ namespace boost
        template< typename SeqT, typename Range >
        inline SeqT copy_range( const Range& r )
        {
-            return SeqT( boost::begin( r ), boost::end( r ) );
+            return SeqT( begin( r ), end( r ) );
        }

 } // namespace 'boost'
@@ -635,4 +581,3 @@ namespace boost
 #undef BOOST_OLD_IOSTREAMS

 #endif
-
--- a/include/boost/range/metafunctions.hpp
+++ b/include/boost/range/metafunctions.hpp
@@ -16,15 +16,13 @@
 #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
@@ -1,64 +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/
-//
-
-#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
@@ -1,29 +0,0 @@
-// 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,7 +16,9 @@
 #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
 {
@@ -24,42 +26,43 @@ namespace boost
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type 
 rbegin( C& c )
 {
-    return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( boost::end( c ) );
+    return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( end( c ) );
 }

 #else

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator< 
+								typename remove_const<C>::type >::type 
 rbegin( C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator< 
+								typename remove_const<C>::type >::type
        iter_type;
-    return iter_type( boost::end( c ) );
+    return iter_type( end( c ) );
 }

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

 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING

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

 } // namespace 'boost'

 #endif
-
--- a/include/boost/range/reference.hpp
+++ b/include/boost/range/reference.hpp
@@ -1,29 +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/
-//
-
-#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,50 +16,53 @@
 #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_iterator<C>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type 
 rend( C& c )
 {
-    return BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type( boost::begin( c ) );
+    return BOOST_DEDUCED_TYPENAME range_reverse_result_iterator<C>::type( begin( c ) );
 }

 #else
-
+    
 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator< 
+								typename remove_const<C>::type >::type
 rend( C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
+	typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator< 
+								typename remove_const<C>::type >::type 
               iter_type;
-    return iter_type( boost::begin( c ) );
+    return iter_type( begin( c ) );
 }

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type 
 rend( const C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
+    typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
        iter_type;
-    return iter_type( boost::begin( c ) );
+    return iter_type( begin( c ) );
 }

 #endif

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

 } // namespace 'boost'

 #endif
-
--- a/include/boost/range/result_iterator.hpp
+++ b/include/boost/range/result_iterator.hpp
@@ -15,19 +15,29 @@
 # 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
 {
-    //
-    // This interface is deprecated, use range_iterator<T>
-    //
+    //////////////////////////////////////////////////////////////////////////
+    // default
+    //////////////////////////////////////////////////////////////////////////
    
    template< typename C >
-    struct range_result_iterator : range_iterator<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;
+    };
    
 } // 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,17 +15,22 @@
 # pragma once
 #endif

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

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

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

-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
+#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/size_type.hpp>
+#include <cstddef>
+#include <iterator>
+#include <utility>

 namespace boost 
 {

-    template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_size<T>::type size( const T& r )
-    {
-        return boost::end( r ) - boost::begin( r );
-    }
+#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
+

 } // namespace 'boost'

+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
 #endif
--- a/include/boost/range/size_type.hpp
+++ b/include/boost/range/size_type.hpp
@@ -16,60 +16,158 @@
 #endif

 #include <boost/range/config.hpp>
+/*
+#include <boost/range/difference_type.hpp>
+
+namespace boost
+{
+	namespace range_detail
+	{
+		template< class T >
+		struct add_unsigned;
+
+		template<>
+		struct add_unsigned<short>
+		{
+			typedef unsigned short type;
+		};
+    
+		template<>
+		struct add_unsigned<int>
+		{
+			typedef unsigned int type;
+		};
+
+		template<>
+		struct add_unsigned<long>
+		{
+			typedef unsigned long type;
+		};
+
+#ifdef BOOST_HAS_LONG_LONG
+		
+		template<>
+		struct add_unsigned<long long>
+		{
+			typedef unsigned long long type;
+		};
+#endif
+
+	}
+
+	template< class T >
+	struct range_size
+	{
+		typedef BOOST_DEDUCED_TYPENAME range_detail::add_unsigned<
+					BOOST_DEDUCED_TYPENAME range_difference<T>::type >::type
+			type;
+	};
+}
+*/

 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #include <boost/range/detail/size_type.hpp>
 #else

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

 namespace boost
 {
-    namespace detail
+    //////////////////////////////////////////////////////////////////////////
+    // default
+    //////////////////////////////////////////////////////////////////////////
+    
+    template< typename C >
+    struct range_size
    {
+        typedef BOOST_DEDUCED_TYPENAME C::size_type type;
+    };
+    
+    //////////////////////////////////////////////////////////////////////////
+    // pair
+    //////////////////////////////////////////////////////////////////////////

-        //////////////////////////////////////////////////////////////////////////
-        // default
-        //////////////////////////////////////////////////////////////////////////
+    template< typename Iterator >
+    struct range_size< std::pair<Iterator,Iterator> >
+    {
+        typedef std::size_t 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;
-        };
-    
-        //////////////////////////////////////////////////////////////////////////
-        // array
-        //////////////////////////////////////////////////////////////////////////
-    
-        template< typename T, std::size_t sz >
-        struct range_size< T[sz] >
-        {
-            typedef std::size_t type;
-        };
-    }
+    template< typename Iterator >
+    struct range_size< const std::pair<Iterator,Iterator> >
+    {
+        typedef std::size_t type;
+    };

-    template< class T >
-    struct range_size : 
-        detail::range_size<T>
-    { };
+    //////////////////////////////////////////////////////////////////////////
+    // 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<const T > : range_size<T>
-    { };
-    
 } // namespace boost

 #endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
--- a/include/boost/range/sub_range.hpp
+++ b/include/boost/range/sub_range.hpp
@@ -14,6 +14,7 @@
 #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>
@@ -22,33 +23,37 @@ namespace boost
 {
    
    template< class ForwardRange > 
-    class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type > 
+    class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type > 
    {
-        typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator_t;
+        typedef BOOST_DEDUCED_TYPENAME range_result_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_iterator<ForwardRange>::type         iterator;
-        typedef BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type   const_iterator;
+        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_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 )
+        { }

-/*        
-        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 */
-
+        this_type& operator=( this_type r )
+        {
+            base::operator=( r );
+            return *this;
+        }
+#endif
+*/
        template< class ForwardRange2 >
        sub_range( ForwardRange2& r ) : 
            
@@ -87,16 +92,6 @@ 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:
        
@@ -165,4 +160,3 @@ namespace boost
 } // namespace 'boost'

 #endif
-
--- a/include/boost/range/value_type.hpp
+++ b/include/boost/range/value_type.hpp
@@ -18,17 +18,129 @@
 #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>

 namespace boost
 {
-    template< class T >
-    struct range_value : iterator_value< typename range_iterator<T>::type >
-    { };
+	template< class T >
+    struct range_value
+	{
+		typedef BOOST_DEDUCED_TYPENAME iterator_value< 
+			BOOST_DEDUCED_TYPENAME range_iterator<T>::type >::type
+				type;
+	};
 }

+/*
+#include <cstddef>
+#include <utility>
+
+
+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
+
 #endif
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -0,0 +1,41 @@
+# 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 extension_mechanism ]
+#    [ 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/<link>static
+        run $(name).cpp /boost/test//boost_unit_test_framework
        : 
        : 
        : $(includes)
@@ -29,7 +29,6 @@ test-suite range :
    [ range-test algorithm_example ]
    [ range-test reversible_range ]
    [ range-test const_ranges ]
-    [ range-test extension_mechanism ]
-#    [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ] 
+    [ range-test mfc : <include>$(VC71_ROOT)/atlmfc/include ] 
    ;

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

 #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>
@@ -71,8 +70,12 @@ 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_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_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_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_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_result_iterator<const array_t>::type, const int* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_result_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
@@ -25,70 +25,74 @@
 // Generic range algorithm
 //
 template< class Rng >
-typename boost::range_iterator<Rng>::type foo_algo( Rng& r )
+typename boost::range_result_iterator<Rng>::type foo_algo( Rng& r )
 {
-        //
-        // This will only compile for Rng = UDT if the qualified calls
-        // find boost_range_XXX via ADL.
-        //
-        return boost::size(r) == 0u ? boost::begin(r) : boost::end(r);
+	//
+	// 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;
+	//
+	// 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;
+		data_t vec;

-                void push_back( int i )
-                { vec.push_back(i); }
-        };
+		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();
-        }
+	//
+	// The required functions. No type-traits need
+	// to be defined because X defines the proper set of
+	// nested types. 
+	//
+	inline X::iterator boost_range_begin( X& x )
+	{ 
+		return x.vec.begin();
+	}

+	
+	inline X::const_iterator boost_range_begin( const X& x )
+	{
+		return x.vec.begin();
+	}
+	

-        inline X::const_iterator range_begin( const X& x )
-        {
-                return x.vec.begin();
-        }
+    inline X::iterator boost_range_end( X& x )
+	{ 
+		return x.vec.end();
+	}

+	inline X::const_iterator boost_range_end( const X& x )
+	{
+		return x.vec.end();
+	}

-        inline X::iterator range_end( X& x )
-        {
-                return x.vec.end();
-        }
-
-        inline X::const_iterator range_end( const X& x )
-        {
-                return x.vec.end();
-        }
-
+	inline X::size_type boost_range_size( const X& x )
+	{
+		return x.vec.size();
+	}
 }

 void check_extension()
 {
-        Foo::X x;
-        x.push_back(3);
-        const Foo::X x2;
+	Foo::X x;
+	x.push_back(3);
+	const Foo::X x2;

-        foo_algo( x );
-        foo_algo( x2 );
+	foo_algo( x );
+	foo_algo( x2 );
 }

 using boost::unit_test::test_suite;
--- a/test/iterator_pair.cpp
+++ b/test/iterator_pair.cpp
@@ -46,20 +46,18 @@ 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_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_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_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 ));
-    //
-    // 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_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_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_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_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 & Larry Evans 2003-2005. Use, modification and
+//  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)
@@ -8,7 +8,6 @@
 // For more information, see http://www.boost.org/libs/range/
 //

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

 #include <boost/detail/workaround.hpp>

@@ -17,6 +16,7 @@
 #  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,8 +27,6 @@
 using namespace boost;
 using namespace std;

-void check_reference_type();
-
 void check_iterator_range()
 {
   
@@ -65,12 +63,6 @@ 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() ) );
@@ -99,8 +91,6 @@ void check_iterator_range()
    BOOST_CHECK( rrr == "ello worl" );
    rrr = make_iterator_range( rrr, -1, 1 );
    BOOST_CHECK( rrr == str );
-
-    check_reference_type();
 }


@@ -115,34 +105,3 @@ 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,15 +17,18 @@
 #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/functions.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/size.hpp>
+#include <boost/range/empty.hpp>
 #include <boost/range/detail/sfinae.hpp>

 #include <boost/static_assert.hpp>
@@ -87,13 +90,6 @@ 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;
@@ -106,3 +102,18 @@ 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,7 +23,6 @@
 #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>

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

 void check_iterator()
 {
-    typedef vector<int>                           vec_t;
+    typedef vector<char>                          vec_t;
    typedef vec_t::iterator                       iterator;
    typedef pair<iterator,iterator>               pair_t;
    typedef range_reverse_iterator<pair_t>::type  rev_iterator;
@@ -41,8 +40,15 @@ 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 ) );
-    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};                        
+    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";
+         
    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 ) ) );
@@ -52,16 +58,33 @@ 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,13 +35,15 @@ 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_iterator<const vec_t>::type, vec_t::const_iterator >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<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_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_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_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,10 +17,7 @@
 #  pragma warn -8057 // unused argument argc/argv in Boost.Test
 #endif

-#include <boost/range/as_array.hpp>
-#include <boost/range/as_literal.hpp>
-#include <boost/range/functions.hpp>
-#include <boost/range/metafunctions.hpp>
+#include <boost/range.hpp>
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/test/test_tools.hpp>
@@ -29,66 +26,36 @@
 #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( str_begin(c), str_end(c), 
-                      value );
+    return std::find( boost::begin( c ), boost::end( c ), value );
 }

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

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

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


@@ -105,66 +72,62 @@ 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 char       my_const_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 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_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_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_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_iterator<const char_array_t>::type, const char* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<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_iterator<char_array_t>::type, char* >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<const char_array_t>::type, const char* >::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_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( 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( sz, std::char_traits<char>::length( char_s ) );
 /*    
-    BOOST_CHECK_EQUAL( str_begin( char_s2 ), char_s2 );
+    BOOST_CHECK_EQUAL( begin( char_s2 ), char_s2 );
    std::size_t sz2 = size( char_s2 );
-    const char* str_end12 = str_begin( char_s2 ) + sz;
-    BOOST_CHECK_EQUAL( str_end( char_s2 ), str_end12 );
+    const char* end12 = begin( char_s2 ) + sz;
+    BOOST_CHECK_EQUAL( end( char_s2 ), end12 );
    BOOST_CHECK_EQUAL( empty( char_s2 ), (char_s2 == 0 || char_s2[0] == char()) );
    BOOST_CHECK_EQUAL( sz2, std::char_traits<char>::length( char_s2 ) );
 */
-    BOOST_CHECK_EQUAL( str_begin( my_string ), my_string );
-    range_iterator<char_array_t>::type str_end2 = str_begin( my_string ) + str_size(my_string);
-    range_iterator<char_array_t>::type str_end3 = str_end(my_string);
-    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 ) );
+    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 ) );

    char to_search = 'n';
-    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( char_s, to_search ) != end( char_s ) );
+    BOOST_CHECK( find_const( char_s, to_search ) != end( char_s ) );

-    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( my_string, to_search ) != end( my_string ) );
+    BOOST_CHECK( find_const( my_string, to_search ) != end( my_string ) );

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


@@ -185,31 +148,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_iterator<const wchar_t*>::type, const wchar_t* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<wchar_iterator_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_iterator<wchar_iterator_t>::type, wchar_iterator_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_iterator<const wchar_t*>::type, const wchar_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 ));
    
-    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()) );
+    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()) );
    BOOST_CHECK_EQUAL( sz, std::char_traits<wchar_t>::length( char_ws ) );
 /*       
    std::size_t sz2 = size( char_ws2 );
-    BOOST_CHECK_EQUAL( str_begin( char_ws2 ), char_ws2 );
-    BOOST_CHECK_EQUAL( str_end( char_ws2 ), (begin( char_ws2 ) + sz2) );
+    BOOST_CHECK_EQUAL( begin( char_ws2 ), char_ws2 );
+    BOOST_CHECK_EQUAL( end( char_ws2 ), (begin( char_ws2 ) + sz2) );
    BOOST_CHECK_EQUAL( empty( char_ws2 ), (char_ws2 == 0 || char_ws2[0] == wchar_t()) );
    BOOST_CHECK_EQUAL( sz2, std::char_traits<wchar_t>::length( char_ws2 ) );
   */ 
    wchar_t to_search = L'n';
-    BOOST_CHECK( find( char_ws, to_search ) != str_end(char_ws) );    
+    BOOST_CHECK( find( char_ws, to_search ) != end( char_ws ) );    

 #if BOOST_WORKAROUND(_MSC_VER, BOOST_TESTED_AT(1300))

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

 #endif  
 #endif
@@ -218,6 +181,7 @@ 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,21 +90,17 @@ 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 );

-    //
-    // 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 ) );
-    //
+    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
nobody	40920f5879	This commit was manufactured by cvs2svn to create tag 'Version_1_33_1_beta'. [SVN r31604]	2005-11-08 23:18:41 +00:00
Thorsten Jørgen Ottosen	99378979c2	* empty log message * [SVN r31520]	2005-10-31 23:11:00 +00:00
John Maddock	848c11831e	Re-enable broken compiler workarounds (they cause regressions if not present). [SVN r31512]	2005-10-31 13:29:56 +00:00
Thorsten Jørgen Ottosen	823d513129	* empty log message * [SVN r30988]	2005-09-14 17:05:05 +00:00
Thorsten Jørgen Ottosen	21c1285cd0	* empty log message * [SVN r30927]	2005-09-12 20:08:14 +00:00
Thorsten Jørgen Ottosen	a47b8664f7	simplified metafunctions interface [SVN r30889]	2005-09-09 16:11:29 +00:00
Thorsten Jørgen Ottosen	19d2d83d29	added remove_const to parameters to avoid common instantiations errors [SVN r30855]	2005-09-07 16:13:23 +00:00
Thorsten Jørgen Ottosen	06e624858b	added discussion on extension mechanism [SVN r30854]	2005-09-07 16:12:03 +00:00
Thorsten Jørgen Ottosen	43a83f500e	added test for extension mechanism [SVN r30815]	2005-09-05 19:44:09 +00:00
Thorsten Jørgen Ottosen	9b66041b25	* empty log message * [SVN r30508]	2005-08-08 20:58:56 +00:00
Thorsten Jørgen Ottosen	b4f01b66bb	* empty log message * [SVN r30490]	2005-08-05 15:16:37 +00:00
Jonathan Turkanis	59f118601a	fixed broken links [SVN r30421]	2005-08-03 19:43:36 +00:00
nobody	d0f9bf8cc0	This commit was manufactured by cvs2svn to create branch 'RC_1_33_0'. [SVN r30300]	2005-07-28 18:22:24 +00:00