| // Boost.Range library |
| // |
| // Copyright Neil Groves 2007. Use, modification and |
| // distribution is subject to the Boost Software License, Version |
| // 1.0. (See accompanying file LICENSE_1_0.txt or copy at |
| // http://www.boost.org/LICENSE_1_0.txt) |
| // |
| // |
| // For more information, see http://www.boost.org/libs/range/ |
| // |
| #ifndef BOOST_RANGE_ADAPTOR_STRIDED_HPP_INCLUDED |
| #define BOOST_RANGE_ADAPTOR_STRIDED_HPP_INCLUDED |
| |
| #include <boost/range/adaptor/argument_fwd.hpp> |
| #include <boost/range/iterator_range.hpp> |
| #include <boost/iterator/iterator_adaptor.hpp> |
| #include <iterator> |
| |
| namespace boost |
| { |
| namespace range_detail |
| { |
| |
| template<typename BaseIterator> |
| class strided_iterator |
| : public iterator_adaptor< |
| strided_iterator<BaseIterator>, |
| BaseIterator> |
| { |
| friend class iterator_core_access; |
| |
| typedef iterator_adaptor<strided_iterator<BaseIterator>, BaseIterator> super_t; |
| |
| public: |
| typedef BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type difference_type; |
| |
| strided_iterator() : m_stride() { } |
| |
| strided_iterator(const strided_iterator& other) |
| : super_t(other), m_stride(other.m_stride) { } |
| |
| explicit strided_iterator(BaseIterator base_it, difference_type stride) |
| : super_t(base_it), m_stride(stride) { } |
| |
| strided_iterator& |
| operator=(const strided_iterator& other) |
| { |
| super_t::operator=(other); |
| |
| // Is the interoperation of the stride safe? |
| m_stride = other.m_stride; |
| return *this; |
| } |
| |
| void increment() { std::advance(this->base_reference(), m_stride); } |
| |
| void decrement() { std::advance(this->base_reference(), -m_stride); } |
| |
| void advance(difference_type n) { std::advance(this->base_reference(), n * m_stride); } |
| |
| difference_type |
| distance_to(const strided_iterator& other) const |
| { |
| return std::distance(this->base_reference(), other.base_reference()) / m_stride; |
| } |
| |
| // Using the compiler generated copy constructor and |
| // and assignment operator |
| |
| private: |
| difference_type m_stride; |
| }; |
| |
| template<class BaseIterator> inline |
| strided_iterator<BaseIterator> |
| make_strided_iterator( |
| const BaseIterator& first, |
| BOOST_DEDUCED_TYPENAME std::iterator_traits<BaseIterator>::difference_type stride) |
| { |
| return strided_iterator<BaseIterator>(first, stride); |
| } |
| |
| template< class Rng > |
| class strided_range |
| : public iterator_range<range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> > |
| { |
| typedef range_detail::strided_iterator<BOOST_DEDUCED_TYPENAME range_iterator<Rng>::type> iter_type; |
| typedef iterator_range<iter_type> super_t; |
| public: |
| template< typename Difference > |
| strided_range(Difference stride, Rng& rng) |
| : super_t(make_strided_iterator(boost::begin(rng), stride), |
| make_strided_iterator(boost::end(rng), stride)) |
| { |
| } |
| }; |
| |
| template<class Difference> |
| class strided_holder : public holder<Difference> |
| { |
| public: |
| strided_holder(Difference value) : holder<Difference>(value) {} |
| }; |
| |
| template<class Rng, class Difference> |
| inline strided_range<Rng> |
| operator|(Rng& rng, const strided_holder<Difference>& stride) |
| { |
| return strided_range<Rng>(stride.val, rng); |
| } |
| |
| template<class Rng, class Difference> |
| inline strided_range<const Rng> |
| operator|(const Rng& rng, const strided_holder<Difference>& stride) |
| { |
| return strided_range<const Rng>(stride.val, rng); |
| } |
| |
| } // namespace range_detail |
| |
| using range_detail::strided_range; |
| |
| namespace adaptors |
| { |
| |
| namespace |
| { |
| const range_detail::forwarder<range_detail::strided_holder> |
| strided = range_detail::forwarder<range_detail::strided_holder>(); |
| } |
| |
| template<class Range, class Difference> |
| inline strided_range<Range> |
| stride(Range& rng, Difference step) |
| { |
| return strided_range<Range>(step, rng); |
| } |
| |
| template<class Range, class Difference> |
| inline strided_range<const Range> |
| stride(const Range& rng, Difference step) |
| { |
| return strided_range<const Range>(step, rng); |
| } |
| |
| } // namespace 'adaptors' |
| } // namespace 'boost' |
| |
| #endif |