upgrade to v2

[SVN r34012]

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
+    inline BOOST_DEDUCED_TYPENAME range_iterator<C>::type
-    boost_range_begin( const C& c )
+    range_begin( C& c )
-    {
-        return c.begin();
-    }
-
-    template< typename C >
-    inline BOOST_DEDUCED_TYPENAME range_iterator<
-                                                                        typename remove_const<C>::type >::type
-    boost_range_begin( C& c )
     {
         return c.begin();
     }
@@ -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<
+inline BOOST_DEDUCED_TYPENAME range_iterator<T>::type begin( T& r )
-                        typename remove_const<T>::type >::type begin( T& r )
 {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \
     !BOOST_WORKAROUND(__GNUC__, < 3) \
     /**/
     using namespace range_detail;
 #endif
-    return 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
+

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

include/boost/range/const_reverse_iterator.hpp

@@ -15,22 +15,17 @@
 # pragma once
 #endif
 
-#include <boost/range/config.hpp>
+#include <boost/range/reverse_iterator.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
 
 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
+    //
-    // default
+    // This interface is deprecated, use range_reverse_iterator<const T>
-    //////////////////////////////////////////////////////////////////////////
+    //
     
     template< typename C >
-    struct range_const_reverse_iterator
+    struct range_const_reverse_iterator : range_reverse_iterator<const C>
-    {
+    { };
-        typedef reverse_iterator< 
-            BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type > type;
-    };
     
 } // namespace boost
 

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

include/boost/range/detail/common.hpp

@@ -114,3 +114,4 @@ namespace boost
 }
         
 #endif
+

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 >

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/iterator.hpp>
-# include <boost/range/result_iterator.hpp>
 # include <boost/range/detail/common.hpp>
 # if BOOST_WORKAROUND(BOOST_MSVC, < 1310)
 #  include <boost/range/detail/remove_extent.hpp>
@@ -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;
@@ -84,72 +83,10 @@ 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 );

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:

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 >

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 >

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
+    struct range_difference : iterator_difference< typename range_iterator<T>::type >
-        {
+    { };
-                typedef BOOST_DEDUCED_TYPENAME iterator_difference<
-                        BOOST_DEDUCED_TYPENAME range_const_iterator<T>::type >::type
-                                type;
-        };
 }
 
-//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-//#include <boost/range/detail/difference_type.hpp>
-//#else
-
-/*
-#include <cstddef>
-#include <utility>
-
-namespace boost
-{
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename C >
-    struct range_difference
-    {
-        typedef BOOST_DEDUCED_TYPENAME C::difference_type type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // pair
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename Iterator >
-    struct range_difference< std::pair<Iterator,Iterator> >
-    {
-        typedef BOOST_DEDUCED_TYPENAME
-            iterator_difference<Iterator>::type type;
-    };
-
-    template< typename Iterator >
-    struct range_difference< const std::pair<Iterator,Iterator> >
-    {
-        typedef BOOST_DEDUCED_TYPENAME
-            iterator_difference<Iterator>::type type;
-    };
-
-
-    //////////////////////////////////////////////////////////////////////////
-    // array
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename T, std::size_t sz >
-    struct range_difference< T[sz] >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template< typename T, std::size_t sz >
-    struct range_difference< const T[sz] >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // string
-    //////////////////////////////////////////////////////////////////////////
-
-    template<>
-    struct range_difference< char* >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< wchar_t* >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< const char* >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< const wchar_t* >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< char* const >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< wchar_t* const >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< const char* const >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-    template<>
-    struct range_difference< const wchar_t* const >
-    {
-        typedef std::ptrdiff_t type;
-    };
-
-} // namespace boost
-
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-*/
-
 #endif

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

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

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
+

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

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,11 @@ namespace boost
             //! iterator type
             typedef IteratorT iterator;
 
-            iterator_range() : m_Begin( iterator() ), m_End( iterator() ), 
+            iterator_range() : m_Begin( iterator() ), m_End( iterator() )
-                               singular( true )
+
+                 #ifndef NDEBUG
+            , singular( true )
+                #endif
             { }
 /*
 #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))  
@@ -178,41 +181,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 ) ), 
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
-                singular(false) {}
+                #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 ) ), 
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
-                singular(false) {}
+                #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 ) ), 
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
-                singular(false) {}
+                 #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 ) ), 
+                m_Begin( impl::adl_begin( r ) ), m_End( impl::adl_end( r ) )
-                singular(false) {}
+                 #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 +241,9 @@ namespace boost
             {
                 m_Begin  = r.begin(); 
                 m_End    = r.end();
-                //
+                #ifndef NDEBUG
-                // remark: this need not necessarily be true, but it does no harm
+                singular = r.is_singular();
-                //
+                #endif
-                singular = r.empty();
                 return *this;
             }
                                       
@@ -234,7 +252,9 @@ namespace boost
             {
                 m_Begin  = impl::adl_begin( r ); 
                 m_End    = impl::adl_end( r );
+                #ifndef NDEBUG
                 singular = false;
+                #endif
                 return *this;
             }
 
@@ -243,33 +263,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 )
+                BOOST_ASSERT( !is_singular() );
-                    return 0;
+                return m_End - m_Begin;
-                
-                return std::distance( m_Begin, m_End );
             }
             
             bool empty() const
             {
-                if( singular )
+                BOOST_ASSERT( !is_singular() );
-                    return true;
-                
                 return m_Begin == m_End;
             }
 
@@ -288,7 +308,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,16 +317,19 @@ namespace boost
 
             bool operator==( const iterator_range& r ) const
             {
+                BOOST_ASSERT( !is_singular() );
                 return iterator_range_detail::equal( *this, r );
             }
 
             bool operator!=( const iterator_range& r ) const
             {
+                BOOST_ASSERT( !is_singular() );
                 return !operator==(r);
             }
 
            bool operator<( const iterator_range& r ) const
            {
+               BOOST_ASSERT( !is_singular() );
                return iterator_range_detail::less_than( *this, r );
            }
 
@@ -327,19 +351,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 +373,23 @@ 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
+
         };
 
 //  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
@@ -496,10 +520,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 +542,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 +554,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 +578,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 +600,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 +630,4 @@ namespace boost
 #undef BOOST_OLD_IOSTREAMS
 
 #endif
+

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

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<
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
-                                                                typename remove_const<C>::type >::type
 rbegin( C& c )
 {
-    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
-                                                                typename remove_const<C>::type >::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
+

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<
+inline BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
-                                                                typename remove_const<C>::type >::type
 rend( C& c )
 {
-        typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<
+    typedef BOOST_DEDUCED_TYPENAME range_reverse_iterator<C>::type
-                                                                typename remove_const<C>::type >::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
+

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
+    struct range_result_iterator : range_iterator<C>
-    {
+    { };
-        typedef BOOST_RANGE_DEDUCED_TYPENAME 
-            mpl::if_< BOOST_DEDUCED_TYPENAME is_const<C>::type, 
-                      BOOST_DEDUCED_TYPENAME range_const_iterator<C>::type,
-                      BOOST_DEDUCED_TYPENAME range_iterator<C>::type >::type type;
-    };
     
 } // namespace boost
 
-//#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 
 #endif

include/boost/range/reverse_result_iterator.hpp

@@ -15,22 +15,17 @@
 # pragma once
 #endif
 
-#include <boost/range/config.hpp>
+#include <boost/range/reverse_iterator.hpp>
-#include <boost/range/result_iterator.hpp>
-#include <boost/iterator/reverse_iterator.hpp>
 
 namespace boost
 {
-    //////////////////////////////////////////////////////////////////////////
+    //
-    // default
+    // This interface is deprecated, use range_reverse_iterator<T>
-    //////////////////////////////////////////////////////////////////////////
+    //
    
     template< typename C >
-    struct range_reverse_result_iterator
+    struct range_reverse_result_iterator : range_reverse_iterator<C>
-    {
+    { };
-        typedef reverse_iterator< 
-            BOOST_RANGE_DEDUCED_TYPENAME range_result_iterator<C>::type > type;
-    };
     
 } // namespace boost
 

include/boost/range/size.hpp

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

include/boost/range/size_type.hpp

@@ -16,64 +16,20 @@
 #endif
 
 #include <boost/range/config.hpp>
-/*
-#include <boost/range/difference_type.hpp>
-
-namespace boost
-{
-        namespace range_detail
-        {
-                template< class T >
-                struct add_unsigned;
-
-                template<>
-                struct add_unsigned<short>
-                {
-                        typedef unsigned short type;
-                };
-
-                template<>
-                struct add_unsigned<int>
-                {
-                        typedef unsigned int type;
-                };
-
-                template<>
-                struct add_unsigned<long>
-                {
-                        typedef unsigned long type;
-                };
-
-#ifdef BOOST_HAS_LONG_LONG
-
-                template<>
-                struct add_unsigned<long long>
-                {
-                        typedef unsigned long long type;
-                };
-#endif
-
-        }
-
-        template< class T >
-        struct range_size
-        {
-                typedef BOOST_DEDUCED_TYPENAME range_detail::add_unsigned<
-                                        BOOST_DEDUCED_TYPENAME range_difference<T>::type >::type
-                        type;
-        };
-}
-*/
 
 #ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
 #include <boost/range/detail/size_type.hpp>
 #else
 
+#include <boost/type_traits/remove_const.hpp>
 #include <cstddef>
 #include <utility>
 
 namespace boost
 {
+    namespace detail
+    {
+
         //////////////////////////////////////////////////////////////////////////
         // default
         //////////////////////////////////////////////////////////////////////////
@@ -94,12 +50,6 @@ namespace boost
             typedef std::size_t type;
         };
     
-    template< typename Iterator >
-    struct range_size< const std::pair<Iterator,Iterator> >
-    {
-        typedef std::size_t type;
-    };
-
         //////////////////////////////////////////////////////////////////////////
         // array
         //////////////////////////////////////////////////////////////////////////
@@ -109,64 +59,16 @@ namespace boost
         {
             typedef std::size_t type;
         };
+    }
 
-    template< typename T, std::size_t sz >
+    template< class T >
-    struct range_size< const T[sz] >
+    struct range_size : 
-    {
+        detail::range_size<T>
-        typedef std::size_t type;
+    { };
-    };
 
-    //////////////////////////////////////////////////////////////////////////
+    template< class T >
-    // string
+    struct range_size<const T > : range_size<T>
-    //////////////////////////////////////////////////////////////////////////
+    { };
-
-    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;
-    };
     
 } // namespace boost
 

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_iterator<ForwardRange>::type         iterator;
-        typedef BOOST_DEDUCED_TYPENAME range_const_iterator<ForwardRange>::type   const_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
+

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
+//#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-#include <boost/range/detail/value_type.hpp>
+//#include <boost/range/detail/value_type.hpp>
-#else
+//#else
 
 #include <boost/iterator/iterator_traits.hpp>
 
 namespace boost
 {
     template< class T >
-    struct range_value
+    struct range_value : iterator_value< typename range_iterator<T>::type >
-        {
+    { };
-                typedef BOOST_DEDUCED_TYPENAME iterator_value<
-                        BOOST_DEDUCED_TYPENAME range_iterator<T>::type >::type
-                                type;
-        };
 }
 
-/*
-#include <cstddef>
-#include <utility>
-
-
-namespace boost
-{
-    //////////////////////////////////////////////////////////////////////////
-    // default
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename C >
-    struct range_value
-    {
-        typedef BOOST_DEDUCED_TYPENAME C::value_type type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // pair
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename Iterator >
-    struct range_value< std::pair<Iterator,Iterator> >
-    {
-        typedef BOOST_DEDUCED_TYPENAME
-            iterator_value<Iterator>::type type;
-    };
-
-
-    template< typename Iterator >
-    struct range_value< const std::pair<Iterator,Iterator> >
-    {
-        typedef BOOST_DEDUCED_TYPENAME
-            iterator_value<Iterator>::type type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // array
-    //////////////////////////////////////////////////////////////////////////
-
-    template< typename T, std::size_t sz >
-    struct range_value< T[sz] >
-    {
-        typedef T type;
-    };
-
-    template< typename T, std::size_t sz >
-    struct range_value< const T[sz] >
-    {
-        typedef const T type;
-    };
-
-    //////////////////////////////////////////////////////////////////////////
-    // string
-    //////////////////////////////////////////////////////////////////////////
-
-    template<>
-    struct range_value< char* >
-    {
-        typedef char type;
-    };
-
-    template<>
-    struct range_value< wchar_t* >
-    {
-        typedef wchar_t type;
-    };
-
-    template<>
-    struct range_value< const char* >
-    {
-        typedef const char type;
-    };
-
-    template<>
-    struct range_value< const wchar_t* >
-    {
-        typedef const wchar_t type;
-    };
-
-    template<>
-    struct range_value< char* const >
-    {
-        typedef char type;
-    };
-
-    template<>
-    struct range_value< wchar_t* const >
-    {
-        typedef wchar_t type;
-    };
-
-    template<>
-    struct range_value< const char* const >
-    {
-        typedef const char type;
-    };
-
-    template<>
-    struct range_value< const wchar_t* const >
-    {
-        typedef const wchar_t type;
-    };
-
-} // namespace boost
-*/
-#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-
 #endif