strided adaptor rewritten to correct defects and optimise performance.

include/boost/range/adaptor/strided.hpp

@@ -13,7 +13,7 @@
 
 #include <boost/range/adaptor/argument_fwd.hpp>
 #include <boost/range/iterator_range.hpp>
-#include <boost/iterator/iterator_adaptor.hpp>
+#include <boost/iterator/iterator_facade.hpp>
 #include <iterator>
 
 namespace boost
@@ -23,59 +23,102 @@ namespace boost
         // strided_iterator for wrapping a forward traversal iterator
         template<class BaseIterator, class Category>
         class strided_iterator
-            : public iterator_adaptor<
+            : public iterator_facade<
                 strided_iterator<BaseIterator, Category>
-              , BaseIterator
+                , typename iterator_value<BaseIterator>::type
-              , use_default
+                , forward_traversal_tag
-              , boost::forward_traversal_tag
+                , typename iterator_reference<BaseIterator>::type
+                , typename iterator_difference<BaseIterator>::type
             >
         {
             friend class ::boost::iterator_core_access;
 
-            typedef iterator_adaptor<
+            typedef iterator_facade<
-                        strided_iterator<BaseIterator, Category>
+                strided_iterator<BaseIterator, Category>
-                      , BaseIterator
+                , typename iterator_value<BaseIterator>::type
-                      , use_default
+                , forward_traversal_tag
-                      , boost::forward_traversal_tag
+                , typename iterator_reference<BaseIterator>::type
-                    > super_t;
+                , typename iterator_difference<BaseIterator>::type
+            > super_t;
 
         public:
-            typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type difference_type;
+            typedef typename super_t::difference_type difference_type;
+            typedef typename super_t::reference reference;
             typedef BaseIterator base_iterator;
+            typedef std::forward_iterator_tag iterator_category;
 
             strided_iterator()
-                : m_last()
+                : m_it()
+                , m_last()
                 , m_stride()
             {
             }
 
-            strided_iterator(base_iterator first, base_iterator it, base_iterator last, difference_type stride)
+            strided_iterator(base_iterator   it,
-                : super_t(it)
+                             base_iterator   last,
+                             difference_type stride)
+                : m_it(it)
                 , m_last(last)
                 , m_stride(stride)
             {
             }
 
             template<class OtherIterator>
-            strided_iterator(const strided_iterator<OtherIterator, Category>& other,
+            strided_iterator(
-                             BOOST_DEDUCED_TYPENAME enable_if_convertible<OtherIterator, base_iterator>::type* = 0)
+                const strided_iterator<OtherIterator, Category>& other,
-                : super_t(other)
+                typename enable_if_convertible<
+                    OtherIterator,
+                    base_iterator
+                >::type* = 0
+            )
+                : m_it(other.base())
                 , m_last(other.base_end())
                 , m_stride(other.get_stride())
             {
             }
 
-            base_iterator base_end() const { return m_last; }
+            base_iterator base() const
-            difference_type get_stride() const { return m_stride; }
+            {
+                return m_it;
+            }
+
+            base_iterator base_end() const
+            {
+                return m_last;
+            }
+
+            difference_type get_stride() const
+            {
+                return m_stride;
+            }
 
         private:
             void increment()
             {
-                base_iterator& it = this->base_reference();
+                for (difference_type i = 0;
-                for (difference_type i = 0; (it != m_last) && (i < m_stride); ++i)
+                        (m_it != m_last) && (i < m_stride); ++i)
-                    ++it;
+                {
+                    ++m_it;
+                }
             }
 
+            reference dereference() const
+            {
+                return *m_it;
+            }
+
+            template<class OtherIterator>
+            bool equal(
+                const strided_iterator<OtherIterator, Category>& other,
+                typename enable_if_convertible<
+                    OtherIterator,
+                    base_iterator
+                >::type* = 0) const
+            {
+                return m_it == other.m_it;
+            }
+
+            base_iterator m_it;
             base_iterator m_last;
             difference_type m_stride;
         };
@@ -83,214 +126,514 @@ namespace boost
         // strided_iterator for wrapping a bidirectional iterator
         template<class BaseIterator>
         class strided_iterator<BaseIterator, bidirectional_traversal_tag>
-            : public iterator_adaptor<
+            : public iterator_facade<
                 strided_iterator<BaseIterator, bidirectional_traversal_tag>
-              , BaseIterator
+                , typename iterator_value<BaseIterator>::type
-              , use_default
+                , bidirectional_traversal_tag
-              , bidirectional_traversal_tag
+                , typename iterator_reference<BaseIterator>::type
+                , typename iterator_difference<BaseIterator>::type
             >
         {
             friend class ::boost::iterator_core_access;
 
-            typedef iterator_adaptor<
+            typedef iterator_facade<
-                        strided_iterator<BaseIterator, bidirectional_traversal_tag>
+                strided_iterator<BaseIterator, bidirectional_traversal_tag>
-                      , BaseIterator
+                , typename iterator_value<BaseIterator>::type
-                      , use_default
+                , bidirectional_traversal_tag
-                      , bidirectional_traversal_tag
+                , typename iterator_reference<BaseIterator>::type
-                    > super_t;
+                , typename iterator_difference<BaseIterator>::type
+            > super_t;
         public:
-            typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type difference_type;
+            typedef typename super_t::difference_type difference_type;
+            typedef typename super_t::reference reference;
             typedef BaseIterator base_iterator;
+            typedef typename boost::make_unsigned<difference_type>::type
+                        size_type;
+            typedef std::bidirectional_iterator_tag iterator_category;
 
             strided_iterator()
-                : m_first()
+                : m_it()
-                , m_last()
+                , m_offset()
+                , m_index()
                 , m_stride()
             {
             }
 
-            strided_iterator(base_iterator first, base_iterator it, base_iterator last, difference_type stride)
+            strided_iterator(base_iterator   it,
-                : super_t(it)
+                             size_type       index,
-                , m_first(first)
+                             difference_type stride)
-                , m_last(last)
+                : m_it(it)
+                , m_offset()
+                , m_index(index)
                 , m_stride(stride)
             {
+                if (stride && ((m_index % stride) != 0))
+                    m_index += (stride - (m_index % stride));
             }
 
             template<class OtherIterator>
-            strided_iterator(const strided_iterator<OtherIterator, bidirectional_traversal_tag>& other,
+            strided_iterator(
-                             BOOST_DEDUCED_TYPENAME enable_if_convertible<OtherIterator, base_iterator>::type* = 0)
+                const strided_iterator<
-                : super_t(other.base())
+                    OtherIterator,
-                , m_first(other.base_begin())
+                    bidirectional_traversal_tag
-                , m_last(other.base_end())
+                >& other,
+                typename enable_if_convertible<
+                    OtherIterator,
+                    base_iterator
+                >::type* = 0
+            )
+                : m_it(other.base())
+                , m_offset(other.get_offset())
+                , m_index(other.get_index())
                 , m_stride(other.get_stride())
             {
             }
 
-            base_iterator base_begin() const { return m_first; }
+            base_iterator base() const
-            base_iterator base_end() const { return m_last; }
+            {
-            difference_type get_stride() const { return m_stride; }
+                return m_it;
+            }
+
+            difference_type get_offset() const
+            {
+                return m_offset;
+            }
+
+            size_type get_index() const
+            {
+                return m_index;
+            }
+
+            difference_type get_stride() const
+            {
+                return m_stride;
+            }
 
         private:
             void increment()
             {
-                base_iterator& it = this->base_reference();
+                m_offset += m_stride;
-                for (difference_type i = 0; (it != m_last) && (i < m_stride); ++i)
-                    ++it;
             }
 
             void decrement()
             {
-                base_iterator& it = this->base_reference();
+                m_offset -= m_stride;
-                for (difference_type i = 0; (it != m_first) && (i < m_stride); ++i)
-                    --it;
             }
 
-            base_iterator m_first;
+            reference dereference() const
-            base_iterator m_last;
+            {
+                update();
+                return *m_it;
+            }
+
+            void update() const
+            {
+                std::advance(m_it, m_offset);
+                m_index += m_offset;
+                m_offset = 0;
+            }
+
+            template<class OtherIterator>
+            bool equal(
+                const strided_iterator<
+                    OtherIterator,
+                    bidirectional_traversal_tag
+                >& other,
+                typename enable_if_convertible<
+                    OtherIterator,
+                    base_iterator
+                >::type* = 0) const
+            {
+                return (m_index + m_offset) ==
+                            (other.get_index() + other.get_offset());
+            }
+
+            mutable base_iterator m_it;
+            mutable difference_type m_offset;
+            mutable size_type m_index;
             difference_type m_stride;
         };
 
         // strided_iterator implementation for wrapping a random access iterator
         template<class BaseIterator>
         class strided_iterator<BaseIterator, random_access_traversal_tag>
-            : public iterator_adaptor<
+            : public iterator_facade<
-                        strided_iterator<BaseIterator, random_access_traversal_tag>
+                strided_iterator<BaseIterator, random_access_traversal_tag>
-                      , BaseIterator
+                , typename iterator_value<BaseIterator>::type
-                      , use_default
+                , random_access_traversal_tag
-                      , random_access_traversal_tag
+                , typename iterator_reference<BaseIterator>::type
-                    >
+                , typename iterator_difference<BaseIterator>::type
+            >
         {
             friend class ::boost::iterator_core_access;
 
-            typedef iterator_adaptor<
+            typedef iterator_facade<
-                        strided_iterator<BaseIterator, random_access_traversal_tag>
+                strided_iterator<BaseIterator, random_access_traversal_tag>
-                      , BaseIterator
+                , typename iterator_value<BaseIterator>::type
-                      , use_default
+                , random_access_traversal_tag
-                      , random_access_traversal_tag
+                , typename iterator_reference<BaseIterator>::type
-                    > super_t;
+                , typename iterator_difference<BaseIterator>::type
+            > super_t;
         public:
-            typedef BOOST_DEDUCED_TYPENAME super_t::difference_type difference_type;
+            typedef typename super_t::difference_type difference_type;
+            typedef typename super_t::reference reference;
             typedef BaseIterator base_iterator;
+            typedef std::random_access_iterator_tag iterator_category;
 
             strided_iterator()
-                : m_first()
+                : m_it()
-                , m_last()
+                , m_first()
                 , m_index(0)
                 , m_stride()
             {
             }
 
-            strided_iterator(BaseIterator first, BaseIterator it, BaseIterator last, difference_type stride)
+            strided_iterator(
-                : super_t(it)
+                base_iterator   first,
+                base_iterator   it,
+                difference_type stride
+            )
+                : m_it(it)
                 , m_first(first)
-                , m_last(last)
+                , m_index(stride ? (it - first) : difference_type())
-                , m_index(stride ? (it - first) / stride : 0)
                 , m_stride(stride)
             {
+                if (stride && ((m_index % stride) != 0))
+                    m_index += (stride - (m_index % stride));
             }
 
             template<class OtherIterator>
-            strided_iterator(const strided_iterator<OtherIterator, random_access_traversal_tag>& other,
+            strided_iterator(
-                             BOOST_DEDUCED_TYPENAME enable_if_convertible<OtherIterator, BaseIterator>::type* = 0)
+                const strided_iterator<
-                : super_t(other.base())
+                    OtherIterator,
+                    random_access_traversal_tag
+                >& other,
+                typename enable_if_convertible<
+                    OtherIterator,
+                    base_iterator
+                >::type* = 0
+            )
+                : m_it(other.base())
                 , m_first(other.base_begin())
-                , m_last(other.base_end())
                 , m_index(other.get_index())
                 , m_stride(other.get_stride())
             {
             }
 
-            base_iterator base_begin() const { return m_first; }
+            base_iterator base_begin() const
-            base_iterator base_end() const { return m_last; }
+            {
-            difference_type get_stride() const { return m_stride; }
+                return m_first;
-            difference_type get_index() const { return m_index; }
+            }
+
+            base_iterator base() const
+            {
+                return m_it;
+            }
+
+            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;
-                else
-                    this->base_reference() = m_last;
             }
 
             void decrement()
             {
                 m_index -= m_stride;
-                if (m_index >= 0)
-                    this->base_reference() = m_first + m_index;
-                else
-                    this->base_reference() = m_first;
             }
 
             void advance(difference_type offset)
             {
-                offset *= m_stride;
+                m_index += (m_stride * offset);
-                m_index += offset;
+            }
-                if (m_index < 0)
+
-                    this->base_reference() = m_first;
+            // Implementation detail: only update the actual underlying iterator
-                else if (m_index > (m_last - m_first))
+            // at the point of dereference. This is done so that the increment
-                    this->base_reference() = m_last;
+            // and decrement can overshoot the valid sequence as is required
-                else
+            // by striding. Since we can do all comparisons just with the index
-                    this->base_reference() = m_first + m_index;
+            // simply, and all dereferences must be within the valid range.
+            void update() const
+            {
+                m_it = m_first + m_index;
             }
 
             template<class OtherIterator>
-            difference_type distance_to(const strided_iterator<OtherIterator, random_access_traversal_tag>& other,
+            difference_type distance_to(
-                                        BOOST_DEDUCED_TYPENAME enable_if_convertible<OtherIterator, BaseIterator>::type* = 0) const
+                const strided_iterator<
+                    OtherIterator,
+                    random_access_traversal_tag
+                >& other,
+                typename enable_if_convertible<
+                            OtherIterator, base_iterator>::type* = 0) const
             {
-                if (other.base() >= this->base())
+                BOOST_ASSERT((other.m_index - m_index) % m_stride == difference_type());
-                    return (other.base() - this->base() + (m_stride - 1)) / m_stride;
+                return (other.m_index - m_index) / m_stride;
-                return (other.base() - this->base() - (m_stride - 1)) / m_stride;
             }
 
-            bool equal(const strided_iterator& other) const
+            template<class OtherIterator>
+            bool equal(
+                const strided_iterator<
+                    OtherIterator,
+                    random_access_traversal_tag
+                >& other,
+                typename enable_if_convertible<
+                            OtherIterator, base_iterator>::type* = 0) const
             {
-                return this->base() == other.base();
+                return m_index == other.m_index;
+            }
+
+            reference dereference() const
+            {
+                update();
+                return *m_it;
             }
 
         private:
+            mutable base_iterator m_it;
             base_iterator m_first;
-            base_iterator m_last;
             difference_type m_index;
             difference_type m_stride;
         };
 
-        template<class BaseIterator, class Difference> inline
+        template<class Rng, class Difference> inline
-        strided_iterator<BaseIterator, BOOST_DEDUCED_TYPENAME iterator_traversal<BaseIterator>::type>
+        strided_iterator<
-        make_strided_iterator(BaseIterator first, BaseIterator it,
+            typename range_iterator<Rng>::type,
-                              BaseIterator last, Difference stride)
+            forward_traversal_tag
+        >
+        make_begin_strided_iterator(
+            Rng& rng,
+            Difference stride,
+            forward_traversal_tag)
         {
-            BOOST_ASSERT( stride >= 0 );
+            return strided_iterator<
-            typedef BOOST_DEDUCED_TYPENAME iterator_traversal<BaseIterator>::type traversal_tag;
+                typename range_iterator<Rng>::type,
-            return strided_iterator<BaseIterator, traversal_tag>(first, it, last, stride);
+                forward_traversal_tag
+            >(boost::begin(rng), boost::end(rng), stride);
         }
 
-        template< class Rng
+        template<class Rng, class Difference> inline
-                , class Category = BOOST_DEDUCED_TYPENAME iterator_traversal<
+        strided_iterator<
-                                    BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type
+            typename range_iterator<const Rng>::type,
-                                   >::type
+            forward_traversal_tag
-         >
+        >
+        make_begin_strided_iterator(
+            const Rng& rng,
+            Difference stride,
+            forward_traversal_tag)
+        {
+            return strided_iterator<
+                typename range_iterator<const Rng>::type,
+                forward_traversal_tag
+            >(boost::begin(rng), boost::end(rng), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<Rng>::type,
+            forward_traversal_tag
+        >
+        make_end_strided_iterator(
+            Rng& rng,
+            Difference stride,
+            forward_traversal_tag)
+        {
+            return strided_iterator<
+                typename range_iterator<Rng>::type,
+                forward_traversal_tag
+            >(boost::end(rng), boost::end(rng), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<const Rng>::type,
+            forward_traversal_tag
+        >
+        make_end_strided_iterator(
+            const Rng& rng,
+            Difference stride,
+            forward_traversal_tag)
+        {
+            return strided_iterator<
+                typename range_iterator<const Rng>::type,
+                forward_traversal_tag
+            >(boost::end(rng), boost::end(rng), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<Rng>::type,
+            bidirectional_traversal_tag
+        >
+        make_begin_strided_iterator(
+            Rng& rng,
+            Difference stride,
+            bidirectional_traversal_tag)
+        {
+            typedef typename range_difference<Rng>::type difference_type;
+
+            return strided_iterator<
+                typename range_iterator<Rng>::type,
+                bidirectional_traversal_tag
+            >(boost::begin(rng), difference_type(), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<const Rng>::type,
+            bidirectional_traversal_tag
+        >
+        make_begin_strided_iterator(
+            const Rng& rng,
+            Difference stride,
+            bidirectional_traversal_tag)
+        {
+            typedef typename range_difference<const Rng>::type difference_type;
+
+            return strided_iterator<
+                typename range_iterator<const Rng>::type,
+                bidirectional_traversal_tag
+            >(boost::begin(rng), difference_type(), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<Rng>::type,
+            bidirectional_traversal_tag
+        >
+        make_end_strided_iterator(
+            Rng& rng,
+            Difference stride,
+            bidirectional_traversal_tag)
+        {
+            return strided_iterator<
+                typename range_iterator<Rng>::type,
+                bidirectional_traversal_tag
+            >(boost::end(rng), boost::size(rng), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<const Rng>::type,
+            bidirectional_traversal_tag
+        >
+        make_end_strided_iterator(
+            const Rng& rng,
+            Difference stride,
+            bidirectional_traversal_tag)
+        {
+            return strided_iterator<
+                typename range_iterator<const Rng>::type,
+                bidirectional_traversal_tag
+            >(boost::end(rng), boost::size(rng), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<Rng>::type,
+            random_access_traversal_tag
+        >
+        make_begin_strided_iterator(
+            Rng& rng,
+            Difference stride,
+            random_access_traversal_tag)
+        {
+            return strided_iterator<
+                typename range_iterator<Rng>::type,
+                random_access_traversal_tag
+            >(boost::begin(rng), boost::begin(rng), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<const Rng>::type,
+            random_access_traversal_tag
+        >
+        make_begin_strided_iterator(
+            const Rng& rng,
+            Difference stride,
+            random_access_traversal_tag)
+        {
+            return strided_iterator<
+                typename range_iterator<const Rng>::type,
+                random_access_traversal_tag
+            >(boost::begin(rng), boost::begin(rng), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<Rng>::type,
+            random_access_traversal_tag
+        >
+        make_end_strided_iterator(
+            Rng& rng,
+            Difference stride,
+            random_access_traversal_tag)
+        {
+            return strided_iterator<
+                typename range_iterator<Rng>::type,
+                random_access_traversal_tag
+            >(boost::begin(rng), boost::end(rng), stride);
+        }
+
+        template<class Rng, class Difference> inline
+        strided_iterator<
+            typename range_iterator<const Rng>::type,
+            random_access_traversal_tag
+        >
+        make_end_strided_iterator(
+            const Rng& rng,
+            Difference stride,
+            random_access_traversal_tag)
+        {
+            return strided_iterator<
+                typename range_iterator<const Rng>::type,
+                random_access_traversal_tag
+            >(boost::begin(rng), boost::end(rng), stride);
+        }
+
+        template<
+            class Rng,
+            class Category =
+                typename iterator_traversal<
+                    typename range_iterator<Rng>::type
+                >::type
+        >
         class strided_range
             : public iterator_range<
-                        range_detail::strided_iterator<
+                range_detail::strided_iterator<
-                            BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type,
+                    typename range_iterator<Rng>::type,
-                            Category
+                    Category
-                        >
+                >
-                     >
+            >
         {
             typedef range_detail::strided_iterator<
-                        BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type,
+                typename range_iterator<Rng>::type,
-                        Category
+                Category
-                    > iter_type;
+            > iter_type;
             typedef iterator_range<iter_type> super_t;
         public:
             template<class Difference>
             strided_range(Difference stride, Rng& rng)
-                : super_t(make_strided_iterator(boost::begin(rng), boost::begin(rng), boost::end(rng), stride),
+                : super_t(
-                          make_strided_iterator(boost::begin(rng), boost::end(rng), boost::end(rng), stride))
+                    range_detail::make_begin_strided_iterator(
+                        rng, stride,
+                        typename iterator_traversal<
+                            typename range_iterator<Rng>::type
+                        >::type()),
+                    range_detail::make_end_strided_iterator(
+                        rng, stride,
+                        typename iterator_traversal<
+                            typename range_iterator<Rng>::type
+                        >::type()))
             {
                 BOOST_ASSERT( stride >= 0 );
             }
@@ -300,7 +643,10 @@ namespace boost
         class strided_holder : public holder<Difference>
         {
         public:
-            explicit strided_holder(Difference value) : holder<Difference>(value) {}
+            explicit strided_holder(Difference value)
+                : holder<Difference>(value)
+            {
+            }
         };
 
         template<class Rng, class Difference>
@@ -327,7 +673,8 @@ namespace boost
         namespace
         {
             const range_detail::forwarder<range_detail::strided_holder>
-                strided = range_detail::forwarder<range_detail::strided_holder>();
+                strided = range_detail::forwarder<
+                            range_detail::strided_holder>();
         }
 
         template<class Range, class Difference>

include/boost/range/detail/has_member_size.hpp

@@ -0,0 +1,66 @@
+// Boost.Range library
+//
+// Copyright Neil Groves 2014.
+//
+// Use, modification and distribution are subject to the Boost Software License,
+// Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt).
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+#ifndef BOOST_RANGE_DETAIL_HAS_MEMBER_SIZE_HPP
+#define BOOST_RANGE_DETAIL_HAS_MEMBER_SIZE_HPP
+
+#include <boost/type_traits/is_class.hpp>
+#include <boost/type_traits/is_member_function_pointer.hpp>
+#include <boost/mpl/and.hpp>
+#include <boost/mpl/bool.hpp>
+#include <boost/cstdint.hpp>
+
+namespace boost
+{
+    namespace range_detail
+    {
+
+template<class T>
+class has_member_size_impl
+{
+private:
+    template<class U, U>
+    class check
+    {
+    };
+
+    template<class C>
+    static boost::uint8_t f(check<std::size_t(C::*)(void) const, &C::size>*);
+
+    template<class C>
+    static boost::uint16_t f(...);
+
+public:
+    static const bool value =
+        (sizeof(f<T>(0)) == sizeof(boost::uint8_t));
+
+    typedef typename mpl::if_c<
+        (sizeof(f<T>(0)) == sizeof(boost::uint8_t)),
+        mpl::true_,
+        mpl::false_
+    >::type type;
+};
+
+template<class T>
+struct has_member_size
+{
+    typedef typename mpl::and_<
+        typename is_class<T>::type,
+        typename has_member_size_impl<const T>::type
+    >::type type;
+
+    static const bool value =
+        is_class<T>::value && has_member_size_impl<const T>::value;
+};
+
+    } // namespace range_detail
+}// namespace boost
+ 
+#endif // include guard

include/boost/range/irange.hpp

@@ -51,6 +51,7 @@ namespace boost
             typedef typename base_t::value_type value_type;
             typedef typename base_t::difference_type difference_type;
             typedef typename base_t::reference reference;
+            typedef std::random_access_iterator_tag iterator_category;
 
             integer_iterator() : m_value() {}
             explicit integer_iterator(value_type x) : m_value(x) {}
@@ -73,7 +74,11 @@ namespace boost
 
             difference_type distance_to(const integer_iterator& other) const
             {
-                return other.m_value - m_value;
+                return is_signed<value_type>::value
+                    ? (other.m_value - m_value)
+                    : (other.m_value >= m_value)
+                        ? static_cast<difference_type>(other.m_value - m_value)
+                        : -static_cast<difference_type>(m_value - other.m_value);
             }
 
             bool equal(const integer_iterator& other) const
@@ -123,6 +128,7 @@ namespace boost
             typedef typename base_t::value_type value_type;
             typedef typename base_t::difference_type difference_type;
             typedef typename base_t::reference reference;
+            typedef std::random_access_iterator_tag iterator_category;
 
             integer_iterator_with_step(value_type first, difference_type step, value_type step_size)
                 : m_first(first)
@@ -164,7 +170,7 @@ namespace boost
 
             friend class ::boost::iterator_core_access;
             value_type m_first;
-            value_type m_step;
+            difference_type m_step;
             difference_type m_step_size;
         };
 

include/boost/range/iterator_range_core.hpp

@@ -371,13 +371,13 @@ public:
         template<class IteratorT>
         class iterator_range
             : public iterator_range_detail::iterator_range_base<
-                            IteratorT,
+                    IteratorT,
-                            typename iterator_traversal<IteratorT>::type
+                    BOOST_DEDUCED_TYPENAME iterator_traversal<IteratorT>::type
                 >
         {
             typedef iterator_range_detail::iterator_range_base<
-                        IteratorT,
+                    IteratorT,
-                        typename iterator_traversal<IteratorT>::type
+                    BOOST_DEDUCED_TYPENAME iterator_traversal<IteratorT>::type
             > base_type;
 
         protected:

include/boost/range/size.hpp

@@ -19,24 +19,39 @@
 #include <boost/range/begin.hpp>
 #include <boost/range/end.hpp>
 #include <boost/range/size_type.hpp>
+#include <boost/range/detail/has_member_size.hpp>
 #include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/utility.hpp>
 
 namespace boost
 {
     namespace range_detail
     {
+
         template<class SinglePassRange>
-        inline BOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type
+        inline typename enable_if<
+            has_member_size<SinglePassRange>,
+            typename range_size<const SinglePassRange>::type
+        >::type
         range_calculate_size(const SinglePassRange& rng)
         {
-            BOOST_ASSERT( (boost::end(rng) - boost::begin(rng)) >= 0 &&
+            return rng.size();
-                          "reachability invariant broken!" );
+        }
-            return boost::end(rng) - boost::begin(rng);
+
+        template<class SinglePassRange>
+        inline typename disable_if<
+            has_member_size<SinglePassRange>,
+            typename range_size<const SinglePassRange>::type
+        >::type
+        range_calculate_size(const SinglePassRange& rng)
+        {
+            return std::distance(boost::begin(rng), boost::end(rng));
         }
     }
 
     template<class SinglePassRange>
-    inline BOOST_DEDUCED_TYPENAME range_size<const SinglePassRange>::type
+    inline typename range_size<const SinglePassRange>::type
     size(const SinglePassRange& rng)
     {
 #if !BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) && \

test/Jamfile.v2

@@ -44,6 +44,7 @@ test-suite range :
 	[ range-test adaptor_test/sliced ]
 	[ range-test adaptor_test/strided ]
 	[ range-test adaptor_test/strided2 ]
+	[ range-test adaptor_test/ticket_9519_strided_reversed ]
 	[ range-test adaptor_test/tokenized ]
 	[ range-test adaptor_test/transformed ]
 	[ range-test adaptor_test/type_erased ]

test/adaptor_test/strided.cpp

@@ -137,8 +137,15 @@ namespace boost
             boost::ignore_unused_variable_warning(rng);
             typedef BOOST_DEDUCED_TYPENAME boost::range_iterator<strided_range_t>::type iter_t;
 
-            iter_t first(boost::begin(c), boost::begin(c), boost::end(c), 0);
+            typedef BOOST_DEDUCED_TYPENAME boost::iterator_traversal<
-            iter_t last(boost::begin(c), boost::end(c), boost::end(c), 0);
+                        BOOST_DEDUCED_TYPENAME Container::const_iterator
+            >::type container_traversal_tag;
+
+            iter_t first = boost::range_detail::make_begin_strided_iterator(
+                c, 0, container_traversal_tag());
+
+            iter_t last = boost::range_detail::make_end_strided_iterator(
+                c, 0, container_traversal_tag());
 
             iter_t it = first;
             for (int i = 0; i < 10; ++i, ++it)

test/adaptor_test/ticket_9519_strided_reversed.cpp

@@ -0,0 +1,67 @@
+// Boost.Range library
+//
+//  Copyright Neil Groves 2014. Use, modification and
+//  distribution is subject to the Boost Software License, Version
+//  1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt)
+//
+//
+// For more information, see http://www.boost.org/libs/range/
+//
+// Credit goes to Eric Niebler for providing an example to demonstrate this
+// issue. This has been trivially modified to create this test case.
+//
+#include <boost/range/adaptor/strided.hpp>
+#include <boost/range/adaptor/reversed.hpp>
+#include <boost/range/algorithm_ext/push_back.hpp>
+
+#include <boost/test/test_tools.hpp>
+#include <boost/test/unit_test.hpp>
+
+#include <list>
+#include <vector>
+#include <numeric>
+
+namespace boost
+{
+    namespace
+    {
+
+void ticket_9519_strided_reversed_test()
+{
+    using namespace boost::adaptors;
+
+    std::vector<int> vi;
+    for (int i = 0; i < 50; ++i)
+    {
+        vi.push_back(i);
+    }
+
+    std::vector<int> output;
+    boost::push_back(output, vi | strided(3) | reversed);
+
+    std::list<int> reference;
+    for (int i = 0; i < 50; i += 3)
+    {
+        reference.push_front(i);
+    }
+
+    BOOST_CHECK_EQUAL_COLLECTIONS(output.begin(), output.end(),
+                                  reference.begin(), reference.end());
+}
+
+    } // anonymous namespace
+} // namespace boost
+
+boost::unit_test::test_suite*
+init_unit_test_suite(int argc, char* argv[])
+{
+    boost::unit_test::test_suite* test
+        = BOOST_TEST_SUITE(
+            "RangeTestSuite.adaptor.ticket_9519_strided_reversed");
+
+    test->add(BOOST_TEST_CASE(&boost::ticket_9519_strided_reversed_test));
+
+    return test;
+}
+