Created a branch from trunk

[SVN r38959]
Remove V1 Jamfiles
2025-06-25 20:12:13 +02:00 · 2007-08-26 05:34:35 +00:00 · 2007-08-08 19:02:26 +00:00 · 2007-01-10 18:57:20 +00:00 · 2007-01-10 18:50:13 +00:00 · 2006-11-10 19:09:56 +00:00
48 changed files with 1215 additions and 1468 deletions
--- a/include/boost/range/as_array.hpp
+++ b/include/boost/range/as_array.hpp
@ -0,0 +1,45 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2006. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_AS_ARRAY_HPP
+#define BOOST_RANGE_AS_ARRAY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/detail/str_types.hpp>
+
+namespace boost
+{
+
+    template< class R >
+    inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<R>::type > 
+    as_array( R& r )
+    {
+        return boost::make_iterator_range( r );
+    }
+
+#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+    template< class Range >
+    inline boost::iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type > 
+    as_array( const Range& r )
+    {
+        return boost::make_iterator_range( r );
+    }
+    
+#endif
+    
+}
+
+#endif
+
--- a/include/boost/range/as_literal.hpp
+++ b/include/boost/range/as_literal.hpp
@ -0,0 +1,120 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2006. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_AS_LITERAL_HPP
+#define BOOST_RANGE_DETAIL_AS_LITERAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#if BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+#include <boost/range/detail/as_literal.hpp>
+#else
+
+#include <boost/range/iterator_range.hpp>
+#include <boost/range/detail/str_types.hpp>
+#include <cstring>
+#include <cwchar>
+
+namespace boost
+{
+    namespace range_detail
+    {
+        inline std::size_t length( const char* s )
+        {
+            return strlen( s );
+        }
+
+        inline std::size_t length( const wchar_t* s )
+        {
+            return wcslen( s );
+        }
+
+        //
+        // Remark: the compiler cannot choose between T* and T[sz]
+        // overloads, so we must put the T* internal to the
+        // unconstrained version.
+        // 
+
+        inline bool is_char_ptr( char* )
+        {
+            return true;
+        }
+        
+        inline bool is_char_ptr( const char* )
+        {
+            return true;
+        }
+
+        
+        inline bool is_char_ptr( wchar_t* )
+        {
+            return true;
+        }
+        
+        inline bool is_char_ptr( const wchar_t* )
+        {
+            return true;
+        }
+        
+        template< class T >
+        inline long is_char_ptr( T r )
+        {
+            return 0L;
+        }
+
+        template< class T >
+        inline iterator_range<T*> 
+        make_range( T* const r, bool )
+        {
+            return iterator_range<T*>( r, r + length(r) );
+        }
+
+        template< class T >
+        inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<T>::type> 
+        make_range( T& r, long )
+        {
+            return boost::make_iterator_range( r );
+        }
+
+    }
+    
+    template< class Range >
+    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type> 
+    as_literal( Range& r )
+    {
+        return range_detail::make_range( r, range_detail::is_char_ptr(r) );
+    }
+
+    template< class Range >
+    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type> 
+    as_literal( const Range& r )
+    {
+        return range_detail::make_range( r, range_detail::is_char_ptr(r) );
+    }
+
+    template< class Char, std::size_t sz >
+    inline iterator_range<Char*> as_literal( Char (&arr)[sz] )
+    {
+        return boost::make_iterator_range( arr, arr + sz - 1 );
+    }
+
+    
+    template< class Char, std::size_t sz >
+    inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] )
+    {
+        return boost::make_iterator_range( arr, arr + sz - 1 );
+    }
+}
+
+#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
+
+#endif
--- a/include/boost/range/begin.hpp
+++ b/include/boost/range/begin.hpp
@ -15,7 +15,6 @@
 # pragma once
 #endif

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

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

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

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

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

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

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

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

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


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


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

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

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

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

 #endif
+
--- a/include/boost/range/category.hpp
+++ b/include/boost/range/category.hpp
@ -0,0 +1,29 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2006. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_CATEGORY_HPP
+#define BOOST_RANGE_CATEGORY_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+    template< class T >
+    struct range_category : iterator_category< typename range_iterator<T>::type >
+    { };
+}
+
+#endif
--- a/include/boost/range/const_iterator.hpp
+++ b/include/boost/range/const_iterator.hpp
@ -21,6 +21,7 @@
 #include <boost/range/detail/const_iterator.hpp>
 #else

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

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

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

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

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

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

--- a/include/boost/range/detail/as_literal.hpp
+++ b/include/boost/range/detail/as_literal.hpp
@ -0,0 +1,33 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2006. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_AS_LITERAL_HPP
+#define BOOST_RANGE_AS_LITERAL_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/detail/detail_str.hpp>
+#include <boost/range/iterator_range.hpp>
+
+namespace boost
+{
+    template< class Range >
+    inline iterator_range<BOOST_DEDUCED_TYPENAME range_iterator<Range>::type> 
+    as_literal( Range& r )
+    {
+        return ::boost::make_iterator_range( ::boost::range_detail::str_begin(r),
+                                             ::boost::range_detail::str_end(r) );
+    }
+
+}
+
+#endif
--- a/include/boost/range/detail/begin.hpp
+++ b/include/boost/range/detail/begin.hpp
@ -13,7 +13,7 @@

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

-        //////////////////////////////////////////////////////////////////////
-        // string
-        //////////////////////////////////////////////////////////////////////
-     
-        template<>
-        struct range_begin<char_ptr_>
-        {
-            static char* fun( char* s )
-            {
-                return s;
-            }
-        };
-
-        template<>
-        struct range_begin<const_char_ptr_>
-        {
-            static const char* fun( const char* s )
-            {
-                return s;
-            }
-        };
-        
-        template<>
-        struct range_begin<wchar_t_ptr_>
-        {
-            
-            static wchar_t* fun( wchar_t* s )
-            {
-                return s;
-            }
-        };
-
-        template<>
-        struct range_begin<const_wchar_t_ptr_>
-        {
-            static const wchar_t* fun( const wchar_t* s )
-            {
-                return s;
-            }
-        };
-
    } // namespace 'range_detail'
    
    template< typename C >
-    inline BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type 
+    inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
    begin( C& c )
    {
        return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
--- a/include/boost/range/detail/common.hpp
+++ b/include/boost/range/detail/common.hpp
@ -114,3 +114,4 @@ namespace boost
 }
        
 #endif
+
--- a/include/boost/range/detail/const_iterator.hpp
+++ b/include/boost/range/detail/const_iterator.hpp
@ -56,58 +56,6 @@ namespace boost
                    remove_extent<T>::type* type;
            };
        };
-        
-        template<>
-        struct range_const_iterator_<char_array_>
-        { 
-            template< typename T >
-            struct pts
-            {
-                typedef const BOOST_RANGE_DEDUCED_TYPENAME 
-                    remove_extent<T>::type* type;
-            };
-        };
-
-        template<>
-        struct range_const_iterator_<char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef const char* type; 
-            };         
-        };
-        
-        template<>
-        struct range_const_iterator_<const_char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef const char* type; 
-            };         
-        };
-
-        template<>
-        struct range_const_iterator_<wchar_t_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef const wchar_t* type; 
-            };         
-        };
-
-        template<>
-        struct range_const_iterator_<const_wchar_t_ptr_>
-        {
-             template< typename S >
-             struct pts
-             {
-                 typedef const wchar_t* type; 
-             };         
-         };
-
    } 
    
    template< typename C >
--- a/include/boost/range/detail/detail_str.hpp
+++ b/include/boost/range/detail/detail_str.hpp
@ -0,0 +1,376 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_DETAIL_STR_HPP
+#define BOOST_RANGE_DETAIL_DETAIL_STR_HPP
+
+#include <boost/config.hpp> // BOOST_MSVC
+#include <boost/range/iterator.hpp>
+
+namespace boost 
+{
+    
+    namespace range_detail
+    {
+        //
+        // iterator
+        //
+        
+        template<>
+        struct range_iterator_<char_array_>
+        { 
+            template< typename T >
+            struct pts
+            {
+                 typedef BOOST_RANGE_DEDUCED_TYPENAME 
+                    remove_extent<T>::type* type;
+            };
+        };
+
+        template<>
+        struct range_iterator_<char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef char* type; 
+            };         
+        };
+
+        template<>
+        struct range_iterator_<const_char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const char* type;
+            };         
+        };
+
+        template<>
+        struct range_iterator_<wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef wchar_t* type; 
+            };         
+        };
+
+        template<>
+        struct range_iterator_<const_wchar_t_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef const wchar_t* type; 
+             };         
+        };
+
+
+        //
+        // const iterator
+        //
+
+        template<>
+        struct range_const_iterator_<char_array_>
+        { 
+            template< typename T >
+            struct pts
+            {
+                typedef const BOOST_RANGE_DEDUCED_TYPENAME 
+                    remove_extent<T>::type* type;
+            };
+        };
+
+        template<>
+        struct range_const_iterator_<char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const char* type; 
+            };         
+        };
+
+        template<>
+        struct range_const_iterator_<const_char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const char* type; 
+            };         
+        };
+
+        template<>
+        struct range_const_iterator_<wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const wchar_t* type; 
+            };         
+        };
+
+        template<>
+        struct range_const_iterator_<const_wchar_t_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef const wchar_t* type; 
+             };         
+        };
+    }
+}
+
+#include <boost/range/detail/begin.hpp>
+#include <boost/range/detail/end.hpp>
+#include <boost/range/detail/size_type>
+#include <boost/range/detail/value_type>
+#include <boost/range/detail/common.hpp>
+
+namespace boost 
+{
+    
+    namespace range_detail
+    {
+        //
+        // str_begin()
+        //
+        template<>
+        struct range_begin<char_ptr_>
+        {
+            static char* fun( char* s )
+            {
+                return s;
+            }
+        };
+
+        template<>
+        struct range_begin<const_char_ptr_>
+        {
+            static const char* fun( const char* s )
+            {
+                return s;
+            }
+        };
+        
+        template<>
+        struct range_begin<wchar_t_ptr_>
+        {
+            
+            static wchar_t* fun( wchar_t* s )
+            {
+                return s;
+            }
+        };
+
+        template<>
+        struct range_begin<const_wchar_t_ptr_>
+        {
+            static const wchar_t* fun( const wchar_t* s )
+            {
+                return s;
+            }
+        };
+        
+        template< typename C >
+        inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
+        str_begin( C& c )
+        {
+            return range_detail::range_begin< BOOST_RANGE_DEDUCED_TYPENAME 
+                range_detail::range<C>::type >::fun( c );
+        }
+
+        //
+        // str_end()
+        //
+
+        template<>
+        struct range_end<char_array_>
+        {
+            template< typename T, std::size_t sz >
+            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            {
+                return boost::range_detail::array_end( boost_range_array );
+            }
+        };
+        
+        template<>
+        struct range_end<wchar_t_array_>
+        {
+            template< typename T, std::size_t sz >
+            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
+            {
+                return boost::range_detail::array_end( boost_range_array );
+            }
+        };
+        
+        template<>
+        struct range_end<char_ptr_>
+        {
+            static char* fun( char* s )
+            {
+                return boost::range_detail::str_end( s );
+            }
+        };
+
+        template<>
+        struct range_end<const_char_ptr_>
+        {
+            static const char* fun( const char* s )
+            {
+                return boost::range_detail::str_end( s );
+            }
+        };
+
+        template<>
+        struct range_end<wchar_t_ptr_>
+        {
+            static wchar_t* fun( wchar_t* s )
+            {
+                return boost::range_detail::str_end( s );
+            }
+        };
+
+
+        template<>
+        struct range_end<const_wchar_t_ptr_>
+        {
+            static const wchar_t* fun( const wchar_t* s )
+            {
+                return boost::range_detail::str_end( s );
+            }
+        };
+
+        template< typename C >
+        inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
+        str_end( C& c )
+        {
+            return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME 
+                range_detail::range<C>::type >::fun( c );
+        }
+
+        //
+        // size_type
+        //
+
+        template<>
+        struct range_size_type_<char_array_>
+        { 
+            template< typename A >
+            struct pts
+            {
+                typedef std::size_t type;
+            };
+        };
+
+        template<>
+        struct range_size_type_<char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef std::size_t type;
+            };         
+        };
+        
+        template<>
+        struct range_size_type_<const_char_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef std::size_t type;
+            };         
+        };
+        
+        template<>
+        struct range_size_type_<wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef std::size_t type;
+            };         
+        };
+        
+        template<>
+        struct range_size_type_<const_wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef std::size_t type;
+            };         
+        };  
+
+        //
+        // value_type
+        //
+        
+        template<>
+        struct range_value_type_<char_array_>
+        { 
+            template< typename T >
+            struct pts
+            {
+                typedef char type;
+            };
+        };
+
+        template<>
+        struct range_value_type_<char_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef char type; 
+             };         
+        };
+        
+        template<>
+        struct range_value_type_<const_char_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef const char type;
+             };         
+        };
+        
+        template<>
+        struct range_value_type_<wchar_t_ptr_>
+        {
+             template< typename S >
+             struct pts
+             {
+                 typedef wchar_t type;
+             };         
+        };
+        
+        template<>
+        struct range_value_type_<const_wchar_t_ptr_>
+        {
+            template< typename S >
+            struct pts
+            {
+                typedef const wchar_t type;
+            };         
+        };
+
+    } // namespace 'range_detail'
+
+} // namespace 'boost'
+
+
+#endif
--- a/include/boost/range/detail/end.hpp
+++ b/include/boost/range/detail/end.hpp
@ -18,8 +18,7 @@
 # include <boost/range/detail/vc6/end.hpp>
 #else
 # include <boost/range/detail/implementation_help.hpp>
-# include <boost/range/detail/implementation_help.hpp>
-# include <boost/range/result_iterator.hpp>
+# include <boost/range/iterator.hpp>
 # include <boost/range/detail/common.hpp>
 # if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
 #  include <boost/range/detail/remove_extent.hpp>
@ -40,7 +39,7 @@ namespace boost
        struct range_end<std_container_>
        {
            template< typename C >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type 
+            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
            fun( C& c )
            {
                return c.end();
@ -55,7 +54,7 @@ namespace boost
        struct range_end<std_pair_>
        {
            template< typename P >
-            static BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<P>::type 
+            static BOOST_RANGE_DEDUCED_TYPENAME range_iterator<P>::type 
            fun( const P& p )
            {
                return p.second;
@ -83,73 +82,11 @@ namespace boost
            }
        #endif
        };
-
-                
-        template<>
-        struct range_end<char_array_>
-        {
-            template< typename T, std::size_t sz >
-            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
-            {
-                return boost::range_detail::array_end( boost_range_array );
-            }
-        };
-        
-        template<>
-        struct range_end<wchar_t_array_>
-        {
-            template< typename T, std::size_t sz >
-            static T* fun( T BOOST_RANGE_ARRAY_REF()[sz] )
-            {
-                return boost::range_detail::array_end( boost_range_array );
-            }
-        };
-
-        //////////////////////////////////////////////////////////////////////
-        // string
-        //////////////////////////////////////////////////////////////////////
-        
-        template<>
-        struct range_end<char_ptr_>
-        {
-            static char* fun( char* s )
-            {
-                return boost::range_detail::str_end( s );
-            }
-        };
-
-        template<>
-        struct range_end<const_char_ptr_>
-        {
-            static const char* fun( const char* s )
-            {
-                return boost::range_detail::str_end( s );
-            }
-        };
-
-        template<>
-        struct range_end<wchar_t_ptr_>
-        {
-            static wchar_t* fun( wchar_t* s )
-            {
-                return boost::range_detail::str_end( s );
-            }
-        };
-
-
-        template<>
-        struct range_end<const_wchar_t_ptr_>
-        {
-            static const wchar_t* fun( const wchar_t* s )
-            {
-                return boost::range_detail::str_end( s );
-            }
-        };
        
    } // namespace 'range_detail'
    
    template< typename C >
-    inline BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type 
+    inline BOOST_RANGE_DEDUCED_TYPENAME range_iterator<C>::type 
    end( C& c )
    {
        return range_detail::range_end< BOOST_RANGE_DEDUCED_TYPENAME range_detail::range<C>::type >::fun( c );
--- a/include/boost/range/detail/implementation_help.hpp
+++ b/include/boost/range/detail/implementation_help.hpp
@ -43,7 +43,7 @@ namespace boost
 #else
        inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
        {
-            if( s == 0 && s[0] == 0 )
+            if( s == 0 || s[0] == 0 )
                return s;
            while( *++s != 0 )
                ;
@ -57,6 +57,7 @@ namespace boost
            return const_cast<Char*>( str_end( s, s ) );
        }

+        /*
        template< class T, std::size_t sz >
        inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz], int )
        {
@ -80,25 +81,32 @@ namespace boost
        {
            return boost_range_array + sz - 1;
        }
+        */

        template< class T, std::size_t sz >
        inline T* array_end( T BOOST_RANGE_ARRAY_REF()[sz] )
        {
+            /*
            typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<char,T>::value || is_same<wchar_t,T>::value,
                                                                char_or_wchar_t_array_tag,
                                                                int >::type tag;

            return array_end<T,sz>( boost_range_array, tag() );
+            */
+            return boost_range_array + sz;
        }
        
        template< class T, std::size_t sz >
        inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
        {
+            /*
            typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<char,T>::value || is_same<wchar_t,T>::value,
                                                                char_or_wchar_t_array_tag,
                                                                int >::type tag;
        
            return array_end<T,sz>( boost_range_array, tag() );
+            */
+            return boost_range_array + sz;
        }

        /////////////////////////////////////////////////////////////////////
@ -110,7 +118,8 @@ namespace boost
        {
            return str_end( s ) - s;
        }
-         
+
+        /*
        template< class T, std::size_t sz >
        inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz], int )
        {
@ -134,24 +143,31 @@ namespace boost
        {
            return sz - 1;
        }
-
+        */
+        
        template< class T, std::size_t sz >
        inline std::size_t array_size( T BOOST_RANGE_ARRAY_REF()[sz] )
        {
+            /*
            typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<const char,T>::value || is_same<const wchar_t,T>::value ||
                                                                   is_same<char,T>::value       || is_same<wchar_t,T>::value,
                                                                char_or_wchar_t_array_tag,
                                                                int >::type tag;
            return array_size<T,sz>( boost_range_array, tag() );
+            */
+            return sz;
        }

        template< class T, std::size_t sz >
        inline std::size_t array_size( const T BOOST_RANGE_ARRAY_REF()[sz] )
        {
+            /*
            typedef BOOST_RANGE_DEDUCED_TYPENAME boost::mpl::if_c< is_same<char,T>::value || is_same<wchar_t,T>::value,
                                                                char_or_wchar_t_array_tag,
                                                                int >::type tag;
            return array_size<T,sz>( boost_range_array, tag() );
+            */
+            return sz;
        }

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

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

-        template<>
-        struct range_size_type_<char_array_>
-        { 
-            template< typename A >
-            struct pts
-            {
-                typedef std::size_t type;
-            };
-        };
-
-        template<>
-        struct range_size_type_<char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef std::size_t type;
-            };         
-        };
-        
-        template<>
-        struct range_size_type_<const_char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef std::size_t type;
-            };         
-        };
-        
-        template<>
-        struct range_size_type_<wchar_t_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef std::size_t type;
-            };         
-        };
-        
-        template<>
-        struct range_size_type_<const_wchar_t_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef std::size_t type;
-            };         
-        };  
+  
    } 
    
    template< typename C >
--- a/include/boost/range/detail/str_types.hpp
+++ b/include/boost/range/detail/str_types.hpp
@ -0,0 +1,38 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2006. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_DETAIL_STR_TYPES_HPP
+#define BOOST_RANGE_DETAIL_STR_TYPES_HPP
+
+#include <boost/range/size_type.hpp>
+#include <boost/range/iterator.hpp>
+
+namespace boost
+{
+    template< class T >
+    struct range_mutable_iterator<T*>
+    {
+        typedef T* type;
+    };
+
+    template< class T >
+    struct range_const_iterator<T*>
+    {
+        typedef const T* type;
+    };
+
+    template< class T >
+    struct range_size<T*>
+    {
+       typedef std::size_t type;
+    };    
+}
+
+#endif
--- a/include/boost/range/detail/value_type.hpp
+++ b/include/boost/range/detail/value_type.hpp
@ -56,56 +56,6 @@ namespace boost
            };
        };
        
-        template<>
-        struct range_value_type_<char_array_>
-        { 
-            template< typename T >
-            struct pts
-            {
-                typedef char type;
-            };
-        };
-
-        template<>
-        struct range_value_type_<char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef char type; 
-            };         
-        };
-        
-        template<>
-        struct range_value_type_<const_char_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef const char type;
-            };         
-        };
-
-        template<>
-        struct range_value_type_<wchar_t_ptr_>
-        {
-            template< typename S >
-            struct pts
-            {
-                typedef wchar_t type;
-            };         
-        };
-
-        template<>
-        struct range_value_type_<const_wchar_t_ptr_>
-        {
-             template< typename S >
-             struct pts
-             {
-                 typedef const wchar_t type;
-             };         
-         };
-
    } 
    
    template< typename C >
--- a/include/boost/range/difference_type.hpp
+++ b/include/boost/range/difference_type.hpp
@ -16,130 +16,14 @@
 #endif

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

 namespace boost
 {
-        template< class T >
-        struct range_difference
-        {
-                typedef BOOST_DEDUCED_TYPENAME iterator_difference<
-                        BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type >::type
-                                type;
-        };
+    template< class T >
+    struct range_difference : iterator_difference< typename range_iterator<T>::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
@ -0,0 +1,34 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2006. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_DISTANCE_HPP
+#define BOOST_RANGE_DISTANCE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/range/difference_type.hpp>
+
+namespace boost 
+{
+
+    template< class T >
+    inline BOOST_DEDUCED_TYPENAME range_difference<T>::type 
+    distance( const T& r )
+    {
+        return std::distance( boost::begin( r ), boost::end( r ) );
+    }
+
+} // namespace 'boost'
+
+#endif
--- a/include/boost/range/empty.hpp
+++ b/include/boost/range/empty.hpp
@ -16,52 +16,19 @@
 #endif

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

 namespace boost 
 { 
-namespace range_detail 
-{

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

 } // namepace 'boost'

-//#endif //  BOOST_NO_FUNCTION_TEMPLATE_ORDERING

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

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

 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
@ -39,18 +38,9 @@ namespace range_detail
        //////////////////////////////////////////////////////////////////////
        // primary template
        //////////////////////////////////////////////////////////////////////
-
        template< typename C >
-        inline BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type
-        boost_range_end( const C& c )
-        {
-            return c.end();
-        }
-
-        template< typename C >
-                inline BOOST_DEDUCED_TYPENAME range_iterator<
-                                        typename remove_const<C>::type >::type
-        boost_range_end( C& c )
+        inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
+        range_end( C& c )
        {
            return c.end();
        }
@ -60,13 +50,13 @@ namespace range_detail
        //////////////////////////////////////////////////////////////////////

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

        template< typename Iterator >
-        inline Iterator boost_range_end( std::pair<Iterator,Iterator>& p )
+        inline Iterator range_end( std::pair<Iterator,Iterator>& p )
        {
            return p.second;
        }
@ -76,64 +66,17 @@ namespace range_detail
        //////////////////////////////////////////////////////////////////////

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

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

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

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

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


@ -191,7 +115,7 @@ inline range_const_iterator<const wchar_t*>::type end<const wchar_t*>( const wch
 namespace boost
 {
    template< class T >
-    inline BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type
+    inline BOOST_DEDUCED_TYPENAME range_iterator<const T>::type
    const_end( const T& r )
    {
        return boost::end( r );
@ -199,3 +123,4 @@ namespace boost
 }

 #endif
+
--- a/include/boost/range/functions.hpp
+++ b/include/boost/range/functions.hpp
@ -1,6 +1,6 @@
 // Boost.Range library
 //
-//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
+//  Copyright Thorsten Ottosen 2003-2006. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
@ -18,8 +18,10 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/size.hpp>
+#include <boost/range/distance.hpp>
 #include <boost/range/empty.hpp>
 #include <boost/range/rbegin.hpp>
 #include <boost/range/rend.hpp>

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

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

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

 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
-    
    template< typename C >
    struct range_iterator
    {
-        typedef BOOST_DEDUCED_TYPENAME C::iterator type;
+        typedef BOOST_RANGE_DEDUCED_TYPENAME 
+            mpl::eval_if_c< is_const<C>::value, 
+                            range_const_iterator< typename remove_const<C>::type >,
+                            range_mutable_iterator<C> >::type type;
    };
    
-    //////////////////////////////////////////////////////////////////////////
-    // pair
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename Iterator >
-    struct range_iterator< std::pair<Iterator,Iterator> >
-    {
-        typedef Iterator type;
-    };
-    
-    template< typename Iterator >
-    struct range_iterator< const std::pair<Iterator,Iterator> >
-    {
-        typedef Iterator type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // array
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename T, std::size_t sz >
-    struct range_iterator< T[sz] >
-    {
-        typedef T* type;
-    };
-
-    template< typename T, std::size_t sz >
-    struct range_iterator< const T[sz] >
-    {
-        typedef const T* type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // string
-    //////////////////////////////////////////////////////////////////////////
-
-    template<>
-    struct range_iterator< char* >
-    {
-        typedef char* type;
-    };
-
-    template<>
-    struct range_iterator< wchar_t* >
-    {
-        typedef wchar_t* type;
-    };
-
-    template<>
-    struct range_iterator< const char* >
-    {
-        typedef const char* type;
-    };
-
-    template<>
-    struct range_iterator< const wchar_t* >
-    {
-        typedef const wchar_t* type;
-    };
-
-    template<>
-    struct range_iterator< char* const >
-    {
-        typedef char* type;
-    };
-
-    template<>
-    struct range_iterator< wchar_t* const >
-    {
-        typedef wchar_t* type;
-    };
-
-    template<>
-    struct range_iterator< const char* const >
-    {
-        typedef const char* type;
-    };
-
-    template<>
-    struct range_iterator< const wchar_t* const >
-    {
-        typedef const wchar_t* type;
-    };
-
 } // namespace boost

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

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

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

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

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

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

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

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

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

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

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

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

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

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


@ -296,17 +316,20 @@ namespace boost

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

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

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

 #endif            
@ -327,19 +350,20 @@ namespace boost
    
           reference operator[]( size_type sz ) const
           {
-               //BOOST_STATIC_ASSERT( is_random_access );
               BOOST_ASSERT( sz < size() );
               return m_Begin[sz];
           }

           iterator_range& advance_begin( difference_type n )
           {
+               BOOST_ASSERT( !is_singular() );
               std::advance( m_Begin, n );
               return *this;
           }
           
           iterator_range& advance_end( difference_type n )
           {
+               BOOST_ASSERT( !is_singular() );
               std::advance( m_End, n );
               return *this;
           }
@ -348,24 +372,29 @@ namespace boost
            // 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
@ -380,7 +409,7 @@ namespace boost
        {
            std::copy( r.begin(), r.end(), 
                       std::ostream_iterator< BOOST_DEDUCED_TYPENAME 
-                                            iterator_value<IteratorT>::type, 
+                                              iterator_value<IteratorT>::type, 
                                              Elem, Traits>(Os) );
            return Os;
        }
@ -496,10 +525,10 @@ namespace boost
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

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

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

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

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

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

        template< class Range >
-        inline iterator_range< BOOST_DEDUCED_TYPENAME range_const_iterator<Range>::type >
+        inline iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<const Range>::type >
        make_iterator_range( const Range& r, 
                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_begin,
                    BOOST_DEDUCED_TYPENAME range_difference<Range>::type advance_end )
@ -602,3 +635,4 @@ namespace boost
 #undef BOOST_OLD_IOSTREAMS

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

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

 #endif
--- a/include/boost/range/mutable_iterator.hpp
+++ b/include/boost/range/mutable_iterator.hpp
@ -0,0 +1,64 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_MUTABLE_ITERATOR_HPP
+#define BOOST_RANGE_MUTABLE_ITERATOR_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+
+#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+#include <boost/range/detail/iterator.hpp>
+#else
+
+#include <boost/iterator/iterator_traits.hpp>
+#include <cstddef>
+#include <utility>
+
+namespace boost
+{
+    //////////////////////////////////////////////////////////////////////////
+    // default
+    //////////////////////////////////////////////////////////////////////////
+    
+    template< typename C >
+    struct range_mutable_iterator
+    {
+        typedef BOOST_DEDUCED_TYPENAME C::iterator type;
+    };
+    
+    //////////////////////////////////////////////////////////////////////////
+    // pair
+    //////////////////////////////////////////////////////////////////////////
+
+    template< typename Iterator >
+    struct range_mutable_iterator< std::pair<Iterator,Iterator> >
+    {
+        typedef Iterator type;
+    };
+
+    //////////////////////////////////////////////////////////////////////////
+    // array
+    //////////////////////////////////////////////////////////////////////////
+
+    template< typename T, std::size_t sz >
+    struct range_mutable_iterator< T[sz] >
+    {
+        typedef T* type;
+    };
+
+} // namespace boost
+
+#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+
+#endif
--- a/include/boost/range/pointer.hpp
+++ b/include/boost/range/pointer.hpp
@ -0,0 +1,29 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2006. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_POINTER_TYPE_HPP
+#define BOOST_RANGE_POINTER_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+    template< class T >
+    struct range_pointer : iterator_pointer< typename range_iterator<T>::type >
+    { };
+}
+
+#endif
--- a/include/boost/range/rbegin.hpp
+++ b/include/boost/range/rbegin.hpp
@ -16,9 +16,7 @@
 #endif

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

 namespace boost
 {
@ -26,30 +24,28 @@ namespace boost
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

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

 #else

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

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
 rbegin( const C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
        iter_type;
    return iter_type( boost::end( c ) );
 }
@ -57,7 +53,7 @@ rbegin( const C& c )
 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
 const_rbegin( const T& r )
 {
    return boost::rbegin( r );
@ -66,3 +62,4 @@ const_rbegin( const T& r )
 } // namespace 'boost'

 #endif
+
--- a/include/boost/range/reference.hpp
+++ b/include/boost/range/reference.hpp
@ -0,0 +1,29 @@
+// Boost.Range library
+//
+//  Copyright Thorsten Ottosen 2003-2004. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+
+#ifndef BOOST_RANGE_REFERENCE_TYPE_HPP
+#define BOOST_RANGE_REFERENCE_TYPE_HPP
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1200)
+# pragma once
+#endif
+
+#include <boost/range/config.hpp>
+#include <boost/range/iterator.hpp>
+#include <boost/iterator/iterator_traits.hpp>
+
+namespace boost
+{
+    template< class T >
+    struct range_reference : iterator_reference< typename range_iterator<T>::type >
+    { };
+}
+
+#endif
--- a/include/boost/range/rend.hpp
+++ b/include/boost/range/rend.hpp
@ -16,9 +16,7 @@
 #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
 {
@ -26,30 +24,28 @@ namespace boost
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING

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

 #else

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

 template< class C >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
 rend( const C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<C>::type
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<const C>::type
        iter_type;
    return iter_type( boost::begin( c ) );
 }
@ -57,7 +53,7 @@ rend( const C& c )
 #endif

 template< class T >
-inline BOOST_DEDUCED_TYPENAME range_const_reverse_iterator<T>::type
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<const T>::type
 const_rend( const T& r )
 {
    return boost::rend( r );
@ -66,3 +62,4 @@ const_rend( const T& r )
 } // namespace 'boost'

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

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

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

-//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

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

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

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

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

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

 namespace boost 
 {

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

 } // namespace 'boost'

-#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
-
 #endif
--- a/include/boost/range/size_type.hpp
+++ b/include/boost/range/size_type.hpp
@ -16,158 +16,60 @@
 #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
 {
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename C >
-    struct range_size
+    namespace detail
    {
-        typedef BOOST_DEDUCED_TYPENAME C::size_type type;
-    };

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

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

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

        typedef BOOST_DEDUCED_TYPENAME base::impl impl;
    public:
        typedef BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type            value_type;
-        typedef BOOST_DEDUCED_TYPENAME range_result_iterator<ForwardRange>::type  iterator;
-        typedef BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type   const_iterator;
+        typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type         iterator;
+        typedef BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type   const_iterator;
        typedef BOOST_DEDUCED_TYPENAME range_difference<ForwardRange>::type       difference_type;
        typedef BOOST_DEDUCED_TYPENAME range_size<ForwardRange>::type             size_type;
-        typedef BOOST_DEDUCED_TYPENAME base::reference                            reference;
-        typedef BOOST_DEDUCED_TYPENAME iterator_reference<const_iterator>::type   const_reference;

    public:
        sub_range() : base() 
@ -111,32 +108,32 @@ namespace boost

        
    public: // convenience
-        reference front()
+        value_type& front()
        {
            return base::front();
        }

-        const_reference front() const
+        const value_type& front() const
        {
            return base::front();
        }

-        reference back()
+        value_type& back()
        {
            return base::back();
        }

-        const_reference back() const
+        const value_type& back() const
        {
            return base::back();
        }

-        reference operator[]( size_type sz )
+        value_type& operator[]( size_type sz )
        {
            return base::operator[](sz);
        }

-        const_reference operator[]( size_type sz ) const
+        const value_type& operator[]( size_type sz ) const
        {
            return base::operator[](sz);
        }
@ -168,3 +165,4 @@ namespace boost
 } // namespace 'boost'

 #endif
+
--- a/include/boost/range/value_type.hpp
+++ b/include/boost/range/value_type.hpp
@ -18,129 +18,17 @@
 #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
-        {
-                typedef BOOST_DEDUCED_TYPENAME iterator_value<
-                        BOOST_DEDUCED_TYPENAME range_iterator<T>::type >::type
-                                type;
-        };
+    template< class T >
+    struct range_value : iterator_value< typename range_iterator<T>::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
@ -1,41 +0,0 @@
-# Boost.Range library
-#
-#  Copyright Thorsten Ottosen 2003-2004. Use, modification and
-#  distribution is subject to the Boost Software License, Version
-#  1.0. (See accompanying file LICENSE_1_0.txt or copy at
-#  http://www.boost.org/LICENSE_1_0.txt)
-#
-# For more information, see http://www.boost.org/libs/range/
-#
-
-subproject libs/range/test ;
-
-import testing ;
-
-rule range-test ( name : includes * )
-{
-    return [
-        run $(name).cpp
-        <lib>../../test/build/boost_unit_test_framework
-        : 
-        : 
-        : <include>$(BOOST_ROOT)
-          $(includes)
-        ] ;
-}
-
-test-suite range :
-    [ range-test array ]
-    [ range-test iterator_pair ]
-    [ range-test std_container ]
-    [ range-test string ]
-    [ range-test iterator_range ]
-    [ range-test sub_range ]
-    [ range-test partial_workaround ]
-    [ range-test algorithm_example ]
-    [ range-test reversible_range ]
-    [ range-test const_ranges ]
-    [ range-test 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
+        run $(name).cpp /boost/test//boost_unit_test_framework/<link>static
        : 
        : 
        : $(includes)
--- a/test/algorithm_example.cpp
+++ b/test/algorithm_example.cpp
@ -17,6 +17,7 @@

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

 }

--- a/test/array.cpp
+++ b/test/array.cpp
@ -42,16 +42,16 @@ void check_array()
    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<array_t>::type, const int* >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<array_t>::type, std::ptrdiff_t >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<array_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<array_t>::type, int* >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const array_t>::type, const int* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<array_t>::type, int* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const array_t>::type, const int* >::value ));
    
    BOOST_STATIC_ASSERT(( is_same< range_value<const array_t>::type, const int >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_iterator<const array_t>::type, const int* >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const array_t>::type, const int* >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<const array_t>::type, std::ptrdiff_t >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<const array_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const array_t>::type, const int* >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const array_t>::type, const int* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const array_t>::type, const int* >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const array_t>::type, const int* >::value ));
 #endif
    
    BOOST_CHECK_EQUAL( begin( my_array ), my_array );
--- a/test/extension_mechanism.cpp
+++ b/test/extension_mechanism.cpp
@ -25,7 +25,7 @@
 // Generic range algorithm
 //
 template< class Rng >
-typename boost::range_result_iterator<Rng>::type foo_algo( Rng& r )
+typename boost::range_iterator<Rng>::type foo_algo( Rng& r )
 {
        //
        // This will only compile for Rng = UDT if the qualified calls
@ -57,32 +57,28 @@ namespace Foo
        // to be defined because X defines the proper set of
        // nested types.
        //
-        inline X::iterator boost_range_begin( X& x )
+        inline X::iterator range_begin( X& x )
        {
                return x.vec.begin();
        }


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


-    inline X::iterator boost_range_end( X& x )
+        inline X::iterator range_end( X& x )
        {
                return x.vec.end();
        }

-        inline X::const_iterator boost_range_end( const X& x )
+        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()
--- a/test/iterator_pair.cpp
+++ b/test/iterator_pair.cpp
@ -46,18 +46,20 @@ void check_iterator_pair()
    BOOST_STATIC_ASSERT(( is_same< range_difference<pair_t>::type,                           
                          detail::iterator_traits<pair_t::first_type>::difference_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<pair_t>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<pair_t>::type, pair_t::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const_pair_t>::type, const_pair_t::first_type >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<pair_t>::type, pair_t::first_type >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_t>::type, const_pair_t::first_type >::value ));
    
    BOOST_STATIC_ASSERT(( is_same< range_value<const_pair_tt>::type, 
                          detail::iterator_traits<const_pair_t::first_type>::value_type>::value ));
    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
+    //
+    // This behavior is not supported with v2.
+    //BOOST_STATIC_ASSERT(( is_same< range_const_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_difference<const_pair_tt>::type,                           
                          detail::iterator_traits<const_pair_tt::first_type>::difference_type >::value ));
    BOOST_STATIC_ASSERT(( is_same< range_size<const_pair_tt>::type, std::size_t >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
-    BOOST_STATIC_ASSERT(( is_same< range_result_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));
+    BOOST_STATIC_ASSERT(( is_same< range_iterator<const_pair_tt>::type, const_pair_tt::first_type >::value ));

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

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

 #include <boost/detail/workaround.hpp>

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

-
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/functions.hpp>
 #include <boost/test/test_tools.hpp>
@ -26,7 +26,7 @@

 using namespace boost;
 using namespace std;
-	
+
 void check_reference_type();

 void check_iterator_range()
@ -65,6 +65,12 @@ void check_iterator_range()
    BOOST_CHECK_EQUAL( distance( r.begin(), r.end() ), 
                       distance( begin( r2 ), end( r2 ) ) );
    cout << r << r2;
+
+        
+#ifndef BOOST_NO_STD_WSTRING
+    wcout << make_iterator_range( wstring( L"a wide string" ) ) 
+          << make_iterator_range( L"another wide string" );
+#endif    
    
    string res  = copy_range<string>( r );
    BOOST_CHECK( equal( res.begin(), res.end(), r.begin() ) );
@ -94,7 +100,7 @@ void check_iterator_range()
    rrr = make_iterator_range( rrr, -1, 1 );
    BOOST_CHECK( rrr == str );

-	check_reference_type();
+    check_reference_type();
 }


@ -121,13 +127,13 @@ test_suite* init_unit_test_suite( int argc, char* argv[] )
 template< class Container >
 int test_iter_range( Container& a_cont )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_result_iterator<Container>::type citer_type;
+    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;
+    a_riter.front();
+    a_riter.back();
+    int i = a_riter[0];
+    return i;
 }


--- a/test/partial_workaround.cpp
+++ b/test/partial_workaround.cpp
@ -17,18 +17,15 @@
 #endif

 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+//#define BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION 1

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

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

 #include <boost/static_assert.hpp>
--- a/test/reversible_range.cpp
+++ b/test/reversible_range.cpp
@ -23,6 +23,7 @@
 #include <boost/static_assert.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
 #include <vector>
 #include <algorithm>

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

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

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

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


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

-
 test_suite* init_unit_test_suite( int argc, char* argv[] )
 {
    test_suite* test = BOOST_TEST_SUITE( "Range Test Suite" );
--- a/test/std_container.cpp
+++ b/test/std_container.cpp
@ -35,15 +35,13 @@ void check_std_container()

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

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

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

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

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

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

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


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

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

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

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

-    BOOST_CHECK( find_mutable( char_s2, to_search ) != end( char_s2 ) );   
-    BOOST_CHECK( find_const( char_s2, to_search ) != end( char_s2 ) );   
+    BOOST_CHECK( find_mutable( char_s2, to_search ) != str_end(char_s) );   
+    BOOST_CHECK( find_const( char_s2, to_search ) != str_end(char_s2) );
+
+    BOOST_CHECK( find_const( as_array( my_string ), to_search ) != str_end(my_string) );
+    BOOST_CHECK( find_const( as_array( my_const_string ), to_search ) != str_end(my_string) );
 }


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

 #if BOOST_WORKAROUND(_MSC_VER, BOOST_TESTED_AT(1300))

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

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

 }

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

--- a/test/sub_range.cpp
+++ b/test/sub_range.cpp
@ -90,17 +90,21 @@ void check_sub_range()
    s.empty();
    r.size();
    s.size();
-    
-    irange singular_irange;
-    BOOST_CHECK( singular_irange.empty() );
-    BOOST_CHECK( singular_irange.size() == 0 );
-    
-    srange singular_srange;
-    BOOST_CHECK( singular_srange.empty() );
-    BOOST_CHECK( singular_srange.size() == 0 );

-    BOOST_CHECK( empty( singular_irange ) );
-    BOOST_CHECK( empty( singular_srange ) );
+    //
+    // As of range v2 not legal anymore.
+    //
+    //irange singular_irange;
+    //BOOST_CHECK( singular_irange.empty() );
+    //BOOST_CHECK( singular_irange.size() == 0 );
+    //
+    //srange singular_srange;
+    //BOOST_CHECK( singular_srange.empty() );
+    //BOOST_CHECK( singular_srange.size() == 0 );
+    //
+    //BOOST_CHECK( empty( singular_irange ) );
+    //BOOST_CHECK( empty( singular_srange ) );
+    //

    srange rr = make_iterator_range( str );
    BOOST_CHECK( rr.equal( r ) );
Author	SHA1	Message	Date
Ronald Garcia	f98d3eeb30	Created a branch from trunk [SVN r38959]	2007-08-26 05:34:35 +00:00
Vladimir Prus	51650f1aa2	Remove V1 Jamfiles [SVN r38516]	2007-08-08 19:02:26 +00:00
Thorsten Jørgen Ottosen	aeb47120e3	fixed typo [SVN r36684]	2007-01-10 18:57:20 +00:00
Thorsten Jørgen Ottosen	22b7b4ec8e	commented out old array code [SVN r36683]	2007-01-10 18:50:13 +00:00
Vladimir Prus	a933622ae1	Allow building of shared versions of some Boost.Test libraries. Adjust tests to use always use static linking to Boost.Test, since linking to the shared version requires test changes. Patch from Juergen Hunold. [SVN r35989]	2006-11-10 19:09:56 +00:00
Thorsten Jørgen Ottosen	f49be0b382	* empty log message * [SVN r35717]	2006-10-24 10:37:46 +00:00
Daniel James	007117cefb	Merge in recent fixes for inspect errors. [SVN r34973]	2006-08-27 10:40:36 +00:00
Thorsten Jørgen Ottosen	73bb3d899a	* empty log message * [SVN r34034]	2006-05-19 18:01:02 +00:00
Thorsten Jørgen Ottosen	4a8987865e	dos2unix on some files [SVN r34025]	2006-05-19 10:30:02 +00:00
Thorsten Jørgen Ottosen	f885495565	* empty log message * [SVN r34015]	2006-05-18 21:27:29 +00:00
Thorsten Jørgen Ottosen	dc34cd6079	* empty log message * [SVN r34014]	2006-05-18 21:11:55 +00:00
Thorsten Jørgen Ottosen	5850d7ce3e	new traits and functions for v2 [SVN r34013]	2006-05-18 20:53:21 +00:00
Thorsten Jørgen Ottosen	554f832234	upgrade to v2 [SVN r34012]	2006-05-18 20:52:17 +00:00
Thorsten Jørgen Ottosen	dc96b440be	v2 upgrade [SVN r34011]	2006-05-18 19:17:04 +00:00