Release 1.46.0

[SVN r69125]

doc/reference/adaptors/examples/adjacent_filtered.cpp

@@ -11,7 +11,7 @@
 #include <boost/range/algorithm/copy.hpp>
 #include <boost/assign.hpp>
 #include <algorithm>
-#include <functional>
+#include <functinoal>
 #include <iostream>
 #include <vector>
 

doc/reference/adaptors/examples/indexed.cpp

@@ -41,5 +41,5 @@ int main(int argc, const char* argv[])
     display_element_and_index( input | indexed(0) );
     
     return 0;
-}
+]
 

doc/reference/adaptors/examples/transformed.cpp

@@ -9,7 +9,7 @@
 //
 #include <boost/range/adaptor/transformed.hpp>
 #include <boost/range/algorithm/copy.hpp>
-#include <boost/assign.hpp>
+#include <boost/range/assign.hpp>
 #include <algorithm>
 #include <iostream>
 #include <vector>

include/boost/range.hpp

@@ -15,7 +15,7 @@
 # pragma once
 #endif
 
-#if defined(_MSC_VER) && (_MSC_VER == 1300)
+#if _MSC_VER == 1300 // experiment
 
 #include <boost/range/detail/collection_traits.hpp>
 #include <boost/range/iterator_range.hpp>
@@ -28,6 +28,6 @@
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/sub_range.hpp>
 
-#endif // _MSC_VER == 1300
+#endif // _MSC_VER == 1300 // experiment
 
 #endif

include/boost/range/adaptor/adjacent_filtered.hpp

@@ -143,6 +143,10 @@ namespace boost
                          skip_iter(boost::end(r), boost::end(r), p))
             {
             }
+
+        private:
+            P m_pred;
+            R* m_range;
         };
 
         template< class T >

include/boost/range/adaptor/define_adaptor.hpp

@@ -44,6 +44,24 @@
         return range_adaptor <const Range>(rng); \
     }
 
+#define BOOST_DEFINE_RANGE_ADAPTOR_1( adaptor_name, range_adaptor, adaptor_class ) \
+    template<typename Range> range_adaptor <Range> \
+        operator|(Range& rng, const adaptor_name & args) \
+    { \
+        return range_adaptor <Range>(rng, args.arg1); \
+    } \
+    template<typename Range> range_adaptor <const Range> \
+        operator|(const Range& rng, const adaptor_name & args) \
+    { \
+        return range_adaptor <Range>(rng, args.arg1); \
+    } \
+    template<typename Range, typename Arg1> \
+    range_adaptor<Range> \
+    make_##adaptor_name(Range& rng, Arg1 arg1) \
+    { \
+        return range_adaptor<Range>(rng, arg1); \
+    }
+
 #define BOOST_DEFINE_RANGE_ADAPTOR_1( adaptor_name, range_adaptor, arg1_type ) \
     struct adaptor_name \
     { \

include/boost/range/adaptor/strided.hpp

@@ -176,7 +176,6 @@ namespace boost
             strided_iterator()
                 : m_first()
                 , m_last()
-                , m_index(0)
                 , m_stride()
             {
             }
@@ -185,7 +184,6 @@ namespace boost
                 : super_t(it)
                 , m_first(first)
                 , m_last(last)
-                , m_index(stride ? (it - first) / stride : 0)
                 , m_stride(stride)
             {
             }
@@ -196,7 +194,6 @@ namespace boost
                 : super_t(other.base())
                 , m_first(other.base_begin())
                 , m_last(other.base_end())
-                , m_index(other.get_index())
                 , m_stride(other.get_stride())
             {
             }
@@ -204,37 +201,44 @@ namespace boost
             base_iterator base_begin() const { return m_first; }
             base_iterator base_end() const { return m_last; }
             difference_type get_stride() const { return m_stride; }
-            difference_type get_index() const { return m_index; }
 
         private:
             void increment()
             {
-                m_index += m_stride;
-                if (m_index < (m_last - m_first))
-                    this->base_reference() = m_first + m_index;
+                base_iterator& it = this->base_reference();
+                if ((m_last - it) > m_stride)
+                    it += m_stride;
                 else
-                    this->base_reference() = m_last;
+                    it = m_last;
             }
 
             void decrement()
             {
-                m_index -= m_stride;
-                if (m_index >= 0)
-                    this->base_reference() = m_first + m_index;
+                base_iterator& it = this->base_reference();
+                if ((it - m_first) > m_stride)
+                    it -= m_stride;
                 else
-                    this->base_reference() = m_first;
+                    it = m_first;
             }
 
             void advance(difference_type offset)
             {
+                base_iterator& it = this->base_reference();
                 offset *= m_stride;
-                m_index += offset;
-                if (m_index < 0)
-                    this->base_reference() = m_first;
-                else if (m_index > (m_last - m_first))
-                    this->base_reference() = m_last;
+                if (offset >= 0)
+                {
+                    if ((m_last - it) > offset)
+                        it += offset;
+                    else
+                        it = m_last;
+                }
                 else
-                    this->base_reference() = m_first + m_index;
+                {
+                    if ((m_first - it) > offset)
+                        it += offset;
+                    else
+                        it = m_first;
+                }
             }
 
             template<class OtherIterator>
@@ -248,13 +252,12 @@ namespace boost
 
             bool equal(const strided_iterator& other) const
             {
-                return this->base() == other.base();
+                return other.base() == this->base();
             }
 
         private:
             base_iterator m_first;
             base_iterator m_last;
-            difference_type m_index;
             difference_type m_stride;
         };
 

include/boost/range/adaptor/transformed.hpp

@@ -42,8 +42,8 @@ namespace boost
             typedef R source_range_type;
 
             transformed_range( F f, R& r )
-                : base( boost::make_transform_iterator( boost::begin(r), f ),
-                        boost::make_transform_iterator( boost::end(r), f ) )
+                : base( make_transform_iterator( boost::begin(r), f ),
+                        make_transform_iterator( boost::end(r), f ) )
 
             { }
         };

include/boost/range/algorithm/for_each.hpp

@@ -13,53 +13,13 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/concepts.hpp>
-#include <boost/ref.hpp>
-#include <boost/utility.hpp>
 #include <algorithm>
 
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
-#include <xutility>
-#endif
-
 namespace boost
 {
     namespace range
     {
 
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
-        namespace for_each_detail
-        {
-            template<typename Iterator, typename UnaryFunction>
-            inline UnaryFunction
-            for_each_impl(Iterator first, Iterator last, UnaryFunction fun,
-                          typename enable_if<
-                            is_reference_wrapper<UnaryFunction>,
-                            void
-                          >::type* = 0)
-            {
-                    typedef typename std::_Get_unchecked_type<Iterator>::type
-                                unchecked_iterator;
-
-                    unchecked_iterator unchecked_last = std::_Unchecked(last);
-                    for (unchecked_iterator unchecked_first = std::_Unchecked(first); first != last; ++first)
-                            fun.get()(*unchecked_first);
-
-                    return fun;
-            }
-
-            template<typename Iterator, typename UnaryFunction>
-            inline UnaryFunction
-            for_each_impl(Iterator first, Iterator last, UnaryFunction fn,
-                          typename disable_if<
-                            is_reference_wrapper<UnaryFunction>,
-                            void
-                          >::type* = 0)
-            {
-                return std::for_each<Iterator, UnaryFunction>(first, last, fn);
-            }
-        }
-#endif
-
 /// \brief template function for_each
 ///
 /// range-based version of the for_each std algorithm
@@ -70,18 +30,7 @@ template< class SinglePassRange, class UnaryFunction >
 inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> ));
-    
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
-        return for_each_detail::for_each_impl<
-                typename range_iterator<SinglePassRange>::type,
-                UnaryFunction
-        >(boost::begin(rng), boost::end(rng), fun);
-#else
-    return std::for_each<
-        BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type,
-        UnaryFunction
-    >(boost::begin(rng),boost::end(rng),fun);
-#endif    
+    return std::for_each(boost::begin(rng),boost::end(rng),fun);
 }
 
 /// \overload
@@ -89,18 +38,7 @@ template< class SinglePassRange, class UnaryFunction >
 inline UnaryFunction for_each(const SinglePassRange& rng, UnaryFunction fun)
 {
     BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> ));
-    
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1600)
-        return for_each_detail::for_each_impl<
-                typename range_iterator<const SinglePassRange>::type,
-                UnaryFunction
-        >(boost::begin(rng), boost::end(rng), fun);
-#else    
-    return std::for_each<
-        BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type,
-        UnaryFunction
-    >(boost::begin(rng), boost::end(rng), fun);
-#endif    
+    return std::for_each(boost::begin(rng), boost::end(rng), fun);
 }
 
     } // namespace range

include/boost/range/algorithm_ext/is_sorted.hpp

@@ -1,4 +1,3 @@
-//  Copyright Bryce Lelbach 2010
 //  Copyright Neil Groves 2009. Use, modification and
 //  distribution is subject to the Boost Software License, Version
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
@@ -15,26 +14,45 @@
 #include <boost/range/end.hpp>
 #include <boost/range/concepts.hpp>
 #include <boost/range/value_type.hpp>
-#include <boost/detail/is_sorted.hpp>
 #include <algorithm>
 
 namespace boost
 {
+    namespace range_detail
+    {
+        template<class ForwardIterator>
+        inline bool is_sorted(ForwardIterator first, ForwardIterator last)
+        {
+            for (ForwardIterator next = first; first != last && ++next != last; ++first)
+                if (*next < *first)
+                    return false;
+            return true;
+        }
+
+        template<class ForwardIterator, class BinaryPredicate>
+        inline bool is_sorted(ForwardIterator first, ForwardIterator last, BinaryPredicate pred)
+        {
+            for (ForwardIterator next = first; first != last && ++next != last; ++first)
+                if (pred(*next, *first))
+                    return false;
+            return true;
+        }
+    }
+
     namespace range
     {
 
-/// \brief template function is_sorted
+/// \brief template function count
 ///
-/// range-based version of the is_sorted std algorithm
+/// range-based version of the count std algorithm
 ///
 /// \pre SinglePassRange is a model of the SinglePassRangeConcept
 template<class SinglePassRange>
 inline bool is_sorted(const SinglePassRange& rng)
 {
     BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<BOOST_DEDUCED_TYPENAME
-      range_value<const SinglePassRange>::type>));
-    return ::boost::detail::is_sorted(boost::begin(rng), boost::end(rng));
+    BOOST_RANGE_CONCEPT_ASSERT((LessThanComparableConcept<BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
+    return range_detail::is_sorted(boost::begin(rng), boost::end(rng));
 }
 
 /// \overload
@@ -42,16 +60,12 @@ template<class SinglePassRange, class BinaryPredicate>
 inline bool is_sorted(const SinglePassRange& rng, BinaryPredicate pred)
 {
     BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>));
-    BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate,
-      BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type,
-      BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
-    return ::boost::detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
+    BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type, BOOST_DEDUCED_TYPENAME range_value<const SinglePassRange>::type>));
+    return range_detail::is_sorted(boost::begin(rng), boost::end(rng), pred);
 }
 
     } // namespace range
-
-using range::is_sorted;
-
+    using range::is_sorted;
 } // namespace boost
 
 #endif // include guard

include/boost/range/any_range.hpp

@@ -15,7 +15,6 @@
 #include <boost/iterator/iterator_facade.hpp>
 #include <boost/iterator/iterator_adaptor.hpp>
 #include <boost/range/detail/any_iterator.hpp>
-#include <boost/range/concepts.hpp>
 #include <boost/range/reference.hpp>
 #include <boost/range/value_type.hpp>
 #include <boost/range/iterator_range_core.hpp>

include/boost/range/as_literal.hpp

@@ -25,7 +25,7 @@
 #include <boost/detail/workaround.hpp>
 
 #include <cstring>
-#ifndef BOOST_NO_CWCHAR 
+#ifndef BOOST_NO_CWCHAR
 #include <cwchar>
 #endif
 
@@ -38,41 +38,41 @@ namespace boost
             return strlen( s );
         }
 
-#ifndef BOOST_NO_CWCHAR  
+#ifndef BOOST_NO_CWCHAR
         inline std::size_t length( const wchar_t* s )
         {
             return wcslen( s );
         }
-#endif        
+#endif
 
         //
         // 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;
         }
 
-#ifndef BOOST_NO_CWCHAR  
+#ifndef BOOST_NO_CWCHAR
         inline bool is_char_ptr( wchar_t* )
         {
             return true;
         }
-        
+
         inline bool is_char_ptr( const wchar_t* )
         {
             return true;
         }
 #endif
-        
+
         template< class T >
         inline long is_char_ptr( T /* r */ )
         {
@@ -80,30 +80,30 @@ namespace boost
         }
 
         template< class T >
-        inline iterator_range<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> 
+        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> 
+    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> 
+    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) );
@@ -112,9 +112,9 @@ namespace boost
     template< class Char, std::size_t sz >
     inline iterator_range<Char*> as_literal( Char (&arr)[sz] )
     {
-        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );        
+        return range_detail::make_range( arr, range_detail::is_char_ptr(arr) );
     }
-    
+
     template< class Char, std::size_t sz >
     inline iterator_range<const Char*> as_literal( const Char (&arr)[sz] )
     {

include/boost/range/detail/demote_iterator_traversal_tag.hpp

@@ -5,9 +5,6 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-// Acknowledgements:
-// aschoedl supplied a fix to supply the level of interoperability I had
-// originally intended, but failed to implement.
 //
 // For more information, see http://www.boost.org/libs/range/
 //
@@ -22,12 +19,12 @@ namespace boost
     {
 
 template<class IteratorTraversalTag1, class IteratorTraversalTag2>
-struct inner_demote_iterator_traversal_tag
+struct demote_iterator_traversal_tag
 {
 };
 
 #define BOOST_DEMOTE_TRAVERSAL_TAG( Tag1, Tag2, ResultTag ) \
-template<> struct inner_demote_iterator_traversal_tag< Tag1 , Tag2 > \
+template<> struct demote_iterator_traversal_tag< Tag1 , Tag2 > \
 { \
     typedef ResultTag type; \
 };
@@ -76,15 +73,6 @@ BOOST_DEMOTE_TRAVERSAL_TAG( random_access_traversal_tag, random_access_traversal
 
 #undef BOOST_DEMOTE_TRAVERSAL_TAG
 
-template<class IteratorTraversalTag1, class IteratorTraversalTag2>
-struct demote_iterator_traversal_tag
-    : inner_demote_iterator_traversal_tag<
-        typename boost::detail::pure_traversal_tag< IteratorTraversalTag1 >::type,
-        typename boost::detail::pure_traversal_tag< IteratorTraversalTag2 >::type
-      >
-{
-};
-
     } // namespace range_detail
 } // namespace boost
 

include/boost/range/detail/detail_str.hpp

@@ -134,8 +134,8 @@ namespace boost
 
 #include <boost/range/detail/begin.hpp>
 #include <boost/range/detail/end.hpp>
-#include <boost/range/detail/size_type.hpp>
-#include <boost/range/detail/value_type.hpp>
+#include <boost/range/detail/size_type>
+#include <boost/range/detail/value_type>
 #include <boost/range/detail/common.hpp>
 
 namespace boost 

include/boost/range/detail/implementation_help.hpp

@@ -21,13 +21,13 @@
 #include <wchar.h>
 #endif
 
-namespace boost 
+namespace boost
 {
     namespace range_detail
     {
         template <typename T>
         inline void boost_range_silence_warning( const T& ) { }
-        
+
         /////////////////////////////////////////////////////////////////////
         // end() help
         /////////////////////////////////////////////////////////////////////
@@ -36,7 +36,7 @@ namespace boost
         {
             return s + strlen( s );
         }
-        
+
 #ifndef BOOST_NO_CWCHAR
         inline const wchar_t* str_end( const wchar_t* s, const wchar_t* )
         {
@@ -51,7 +51,7 @@ namespace boost
                 ;
             return s;
         }
-#endif         
+#endif
 
         template< class Char >
         inline Char* str_end( Char* s )
@@ -64,7 +64,7 @@ namespace boost
         {
             return boost_range_array + sz;
         }
-        
+
         template< class T, std::size_t sz >
         inline const T* array_end( const T BOOST_RANGE_ARRAY_REF()[sz] )
         {
@@ -74,7 +74,7 @@ namespace boost
         /////////////////////////////////////////////////////////////////////
         // size() help
         /////////////////////////////////////////////////////////////////////
-        
+
         template< class Char >
         inline std::size_t str_size( const Char* const& s )
         {
@@ -96,7 +96,7 @@ namespace boost
         }
 
     } // namespace 'range_detail'
-    
+
 } // namespace 'boost'
 
 

include/boost/range/detail/join_iterator.hpp

@@ -5,9 +5,6 @@
 //  1.0. (See accompanying file LICENSE_1_0.txt or copy at
 //  http://www.boost.org/LICENSE_1_0.txt)
 //
-// Acknowledgements:
-// aschoedl contributed an improvement to the determination
-// of the Reference type parameter.
 //
 // For more information, see http://www.boost.org/libs/range/
 //
@@ -123,32 +120,7 @@ private:
 template<typename Iterator1
        , typename Iterator2
        , typename ValueType = typename iterator_value<Iterator1>::type
-       // find least demanding, commonly supported reference type, in the order &, const&, and by-value:
-       , typename Reference = typename mpl::if_c<
-                !is_reference<typename iterator_reference<Iterator1>::type>::value
-             || !is_reference<typename iterator_reference<Iterator2>::type>::value,
-                        typename remove_const<
-                            typename remove_reference<
-                                typename iterator_reference<Iterator1>::type
-                            >::type
-                        >::type,
-                        typename mpl::if_c<
-                            is_const<
-                                typename remove_reference<
-                                    typename iterator_reference<Iterator1>::type
-                                >::type
-                            >::value
-                            || is_const<
-                                typename remove_reference<
-                                    typename iterator_reference<Iterator2>::type
-                                >::type
-                            >::value,
-                            typename add_const<
-                                typename iterator_reference<Iterator2>::type
-                            >::type,
-                            typename iterator_reference<Iterator1>::type
-                        >::type
-                    >::type
+       , typename Reference = typename iterator_reference<Iterator1>::type
        , typename Traversal = typename demote_iterator_traversal_tag<
                                   typename iterator_traversal<Iterator1>::type
                                 , typename iterator_traversal<Iterator2>::type>::type

include/boost/range/has_range_iterator.hpp

@@ -19,7 +19,7 @@ namespace boost
 {
     namespace range_detail
     {
-        BOOST_MPL_HAS_XXX_TRAIT_DEF(type)
+        BOOST_MPL_HAS_XXX_TRAIT_DEF(type);
 
         template<class T, class Enabler = void>
         struct has_range_iterator_impl

include/boost/range/irange.hpp

@@ -124,11 +124,13 @@ namespace boost
             typedef typename base_t::difference_type difference_type;
             typedef typename base_t::reference reference;
 
-            integer_iterator_with_step(value_type first, difference_type step, value_type step_size)
+            integer_iterator_with_step(value_type first, value_type step, difference_type step_size)
                 : m_first(first)
                 , m_step(step)
                 , m_step_size(step_size)
             {
+                BOOST_ASSERT( step >= 0 );
+                BOOST_ASSERT( step_size != 0 );
             }
 
         private:
@@ -211,18 +213,16 @@ namespace boost
     {
         BOOST_ASSERT( step_size != 0 );
         BOOST_ASSERT( (step_size > 0) ? (last >= first) : (last <= first) );
-        
+
         typedef typename range_detail::integer_iterator_with_step<Integer> iterator_t;
 
-        const std::ptrdiff_t sz = static_cast<std::ptrdiff_t>(step_size >= 0 ? step_size : -step_size);
-        const Integer l = step_size >= 0 ? last : first;
-        const Integer f = step_size >= 0 ? first : last;
-        const std::ptrdiff_t num_steps = (l + ((l-f) % sz) - f) / sz;
-        BOOST_ASSERT(num_steps >= 0);
-       
+        const std::ptrdiff_t last_step
+            = (static_cast<std::ptrdiff_t>(last) - static_cast<std::ptrdiff_t>(first))
+            / (static_cast<std::ptrdiff_t>(step_size));
+
         return strided_integer_range<Integer>(
             iterator_t(first, 0, step_size),
-            iterator_t(first, num_steps, step_size));
+            iterator_t(first, last_step, step_size));
     }
 
 } // namespace boost

include/boost/range/iterator.hpp

@@ -25,46 +25,46 @@
 namespace boost
 {
 
-#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)  
+#if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
 
-    namespace range_detail_vc7_1  
-    {  
-       template< typename C, typename Sig = void(C) >  
-       struct range_iterator  
-       {  
-           typedef BOOST_RANGE_DEDUCED_TYPENAME   
-               mpl::eval_if_c< is_const<C>::value,   
-                               range_const_iterator< typename remove_const<C>::type >,  
-                               range_mutable_iterator<C> >::type type;  
-       };  
-    
-       template< typename C, typename T >  
-       struct range_iterator< C, void(T[]) >  
-       {  
-           typedef T* type;  
-       };       
-    }  
-    
-#endif  
+    namespace range_detail_vc7_1
+    {
+       template< typename C, typename Sig = void(C) >
+       struct range_iterator
+       {
+           typedef BOOST_RANGE_DEDUCED_TYPENAME
+               mpl::eval_if_c< is_const<C>::value,
+                               range_const_iterator< typename remove_const<C>::type >,
+                               range_mutable_iterator<C> >::type type;
+       };
+
+       template< typename C, typename T >
+       struct range_iterator< C, void(T[]) >
+       {
+           typedef T* type;
+       };
+    }
+
+#endif
 
     template< typename C >
     struct range_iterator
     {
 #if BOOST_WORKAROUND(BOOST_MSVC, == 1310)
-  
-        typedef BOOST_RANGE_DEDUCED_TYPENAME  
-               range_detail_vc7_1::range_iterator<C>::type type;  
-           
-#else  
 
-        typedef BOOST_RANGE_DEDUCED_TYPENAME 
-            mpl::eval_if_c< is_const<C>::value, 
+        typedef BOOST_RANGE_DEDUCED_TYPENAME
+               range_detail_vc7_1::range_iterator<C>::type type;
+
+#else
+
+        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;
-        
-#endif         
+
+#endif
     };
-    
+
 } // namespace boost
 
 //#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

include/boost/range/iterator_range_core.hpp

@@ -53,13 +53,13 @@ namespace boost
             template< class ForwardRange >
             static IteratorT adl_begin( ForwardRange& r )
             {
-                return static_cast<IteratorT>( boost::begin( r ) );
+                return IteratorT( boost::begin( r ) );
             }
 
             template< class ForwardRange >
             static IteratorT adl_end( ForwardRange& r )
             {
-                return static_cast<IteratorT>( boost::end( r ) );
+                return IteratorT( boost::end( r ) );
             }
         };
 
@@ -71,24 +71,6 @@ namespace boost
                                                  boost::begin(r),
                                                  boost::end(r) );
         }
-        
-        template< class Left, class Right >
-        inline bool greater_than( const Left& l, const Right& r )
-        {
-            return less_than(r,l);
-        }
-        
-        template< class Left, class Right >
-        inline bool less_or_equal_than( const Left& l, const Right& r )
-        {
-            return !iterator_range_detail::less_than(r,l);
-        }
-        
-        template< class Left, class Right >
-        inline bool greater_or_equal_than( const Left& l, const Right& r )
-        {
-            return !iterator_range_detail::less_than(l,r);
-        }
 
         // This version is maintained since it is used in other boost libraries
         // such as Boost.Assign
@@ -249,7 +231,7 @@ namespace boost
 
             difference_type size() const
             {
-                return m_End - m_Begin;
+				return m_End - m_Begin;
             }
 
             bool empty() const
@@ -289,21 +271,6 @@ namespace boost
            {
                return iterator_range_detail::less_than( *this, r );
            }
-           
-           bool operator>( const iterator_range& r ) const
-           {
-               return iterator_range_detail::greater_than( *this, r );
-           }
-           
-           bool operator<=( const iterator_range& r ) const
-           {
-               return iterator_range_detail::less_or_equal_than( *this, r );
-           }
-           
-           bool operator>=( const iterator_range& r ) const
-           {
-               return iterator_range_detail::greater_or_equal_than( *this, r );
-           }
 
 #endif
 
@@ -403,27 +370,6 @@ namespace boost
         {
             return iterator_range_detail::less_than( l, r );
         }
-        
-        template< class IteratorT, class ForwardRange >
-        inline bool operator<=( const ForwardRange& l,
-                                const iterator_range<IteratorT>& r )
-        {
-            return iterator_range_detail::less_or_equal_than( l, r );
-        }
-        
-        template< class IteratorT, class ForwardRange >
-        inline bool operator>( const ForwardRange& l,
-                               const iterator_range<IteratorT>& r )
-        {
-            return iterator_range_detail::greater_than( l, r );
-        }
-        
-        template< class IteratorT, class ForwardRange >
-        inline bool operator>=( const ForwardRange& l,
-                                const iterator_range<IteratorT>& r )
-        {
-            return iterator_range_detail::greater_or_equal_than( l, r );
-        }
 
 #ifdef BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 #else
@@ -470,48 +416,6 @@ namespace boost
         {
             return iterator_range_detail::less_than( l, r );
         }
-        
-        template< class Iterator1T, class Iterator2T >
-        inline bool operator<=( const iterator_range<Iterator1T>& l,
-                                const iterator_range<Iterator2T>& r )
-        {
-            return iterator_range_detail::less_or_equal_than( l, r );
-        }
-        
-        template< class IteratorT, class ForwardRange >
-        inline bool operator<=( const iterator_range<IteratorT>& l,
-                                const ForwardRange& r )
-        {
-            return iterator_range_detail::less_or_equal_than( l, r );
-        }
-        
-        template< class Iterator1T, class Iterator2T >
-        inline bool operator>( const iterator_range<Iterator1T>& l,
-                               const iterator_range<Iterator2T>& r )
-        {
-            return iterator_range_detail::greater_than( l, r );
-        }
-        
-        template< class IteratorT, class ForwardRange >
-        inline bool operator>( const iterator_range<IteratorT>& l,
-                               const ForwardRange& r )
-        {
-            return iterator_range_detail::greater_than( l, r );
-        }
-        
-        template< class Iterator1T, class Iterator2T >
-        inline bool operator>=( const iterator_range<Iterator1T>& l,
-                                const iterator_range<Iterator2T>& r )
-        {
-            return iterator_range_detail::greater_or_equal_than( l, r );
-        }
-        
-        template< class IteratorT, class ForwardRange >
-        inline bool operator>=( const iterator_range<IteratorT>& l,
-                                const ForwardRange& r )
-        {
-            return iterator_range_detail::greater_or_equal_than( l, r );
-        }
 
 #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING
 

include/boost/range/join.hpp

@@ -36,9 +36,6 @@ public:
 
     } // namespace range_detail
 
-namespace range
-{
-
 template<class SinglePassRange1, class SinglePassRange2>
 class joined_range
     : public range_detail::joined_type<SinglePassRange1, SinglePassRange2>::type
@@ -81,11 +78,6 @@ join(SinglePassRange1& r1, SinglePassRange2& r2)
     return joined_range<SinglePassRange1, SinglePassRange2>(r1, r2);
 }
 
-} // namespace range
-
-using ::boost::range::joined_range;
-using ::boost::range::join;
-
 } // namespace boost
 
 #endif // include guard

include/boost/range/sub_range.hpp

@@ -12,13 +12,12 @@
 #ifndef BOOST_RANGE_SUB_RANGE_HPP
 #define BOOST_RANGE_SUB_RANGE_HPP
 
-#include <boost/detail/workaround.hpp>
-
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) 
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
     #pragma warning( push )
     #pragma warning( disable : 4996 )
 #endif
 
+#include <boost/detail/workaround.hpp>
 #include <boost/range/config.hpp>
 #include <boost/range/iterator_range.hpp>
 #include <boost/range/value_type.hpp>
@@ -31,9 +30,9 @@
 
 namespace boost
 {
-    
-    template< class ForwardRange > 
-    class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type > 
+
+    template< class ForwardRange >
+    class sub_range : public iterator_range< BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >
     {
         typedef BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type iterator_t;
         typedef iterator_range< iterator_t  > base;
@@ -54,40 +53,40 @@ namespace boost
                                  reference >::type const_reference;
 
     public:
-        sub_range() : base() 
+        sub_range() : base()
+        { }
+
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) )
+        sub_range( const sub_range& r )
+            : base( static_cast<const base&>( r ) )
         { }
-        
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500) ) 
-        sub_range( const sub_range& r ) 
-            : base( static_cast<const base&>( r ) )  
-        { }  
 #endif
 
         template< class ForwardRange2 >
-        sub_range( ForwardRange2& r ) : 
-            
-#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
-            base( impl::adl_begin( r ), impl::adl_end( r ) )
-#else
-            base( r )
-#endif        
-        { }
-        
-        template< class ForwardRange2 >
-        sub_range( const ForwardRange2& r ) : 
+        sub_range( ForwardRange2& r ) :
 
 #if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
             base( impl::adl_begin( r ), impl::adl_end( r ) )
 #else
             base( r )
-#endif                
+#endif
+        { }
+
+        template< class ForwardRange2 >
+        sub_range( const ForwardRange2& r ) :
+
+#if BOOST_WORKAROUND(BOOST_INTEL_CXX_VERSION, <= 800 )
+            base( impl::adl_begin( r ), impl::adl_end( r ) )
+#else
+            base( r )
+#endif
         { }
 
         template< class Iter >
         sub_range( Iter first, Iter last ) :
             base( first, last )
         { }
-        
+
         template< class ForwardRange2 >
         sub_range& operator=( ForwardRange2& r )
         {
@@ -100,23 +99,23 @@ namespace boost
         {
             base::operator=( r );
             return *this;
-        }   
+        }
 
         sub_range& operator=( const sub_range& r )
         {
             base::operator=( static_cast<const base&>(r) );
-            return *this;            
+            return *this;
         }
-        
+
     public:
-        
+
         iterator        begin()          { return base::begin(); }
         const_iterator  begin() const    { return base::begin(); }
         iterator        end()            { return base::end();   }
         const_iterator  end() const      { return base::end();   }
-        difference_type size() const     { return base::size();  }   
+        difference_type size() const     { return base::size();  }
+
 
-        
     public: // convenience
         reference front()
         {
@@ -174,7 +173,7 @@ namespace boost
 
 } // namespace 'boost'
 
-#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500)) 
+#if BOOST_WORKAROUND(BOOST_MSVC, BOOST_TESTED_AT(1500))
     #pragma warning( pop )
 #endif