source: trunk/yat/utility/StrideIterator.h @ 1275

#ifndef _theplu_yat_utility_stride_iterator_
#define _theplu_yat_utility_stride_iterator_

// $Id: StrideIterator.h 1275 2008-04-11 06:10:12Z jari $

/*
  Copyright (C) 2007 Jari Häkkinen, Peter Johansson
  Copyright (C) 2008 Peter Johansson

  This file is part of the yat library, http://trac.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "iterator_traits.h"
#include "yat_assert.h"

#include <iterator>

namespace theplu {
namespace yat {
namespace utility {

  // forward declaration
  template<typename Iter>
  class StrideIterator;

  /**
     Specialization for StrideIterator that calls underlying iterator.
   */
  template <typename Iter>
  struct weighted_iterator_traits<StrideIterator<Iter> > {
    /**
       StrideIterator is weighted if underlying iterator is weighted.
    */
    typedef typename weighted_iterator_traits<Iter>::type type;
  };

  /**
     Specialization for StrideIterator using iterator_traits with base()
   */
  template <class Iter>
  struct iterator_traits<StrideIterator<Iter> > {
    /**
       \return data that is *iter
    */
    double data(StrideIterator<Iter> iter) const 
    { return iterator_traits<Iter>().data(iter.base()); }

    /**
       \return 1.0
    */
    double weight(StrideIterator<Iter> iter) const 
    { return iterator_traits<Iter>().weight(iter.base()); }

  };

  /**
     @brief Adaptor using a stride on underlying iterator

     Works as underlying iterator except that all arithmetic uses the
     stride, so e.g., ++StrideIterator returns underlying
     _iterator+stride

  */
  template<typename Iter>
  class StrideIterator 
    : public std::iterator<typename std::iterator_traits<Iter>::iterator_category, 
                           typename std::iterator_traits<Iter>::value_type, 
                           typename std::iterator_traits<Iter>::difference_type, 
                           typename std::iterator_traits<Iter>::pointer, 
                           typename std::iterator_traits<Iter>::reference>
  {
  public:
    /// type of underlying iterator
    typedef Iter iterator_type;
    /// value type
    typedef typename std::iterator_traits<Iter>::value_type value_type;
    /// difference type
    typedef typename std::iterator_traits<Iter>::difference_type difference_type;
    /// reference
    typedef typename std::iterator_traits<Iter>::reference reference;
    /// pointer
    typedef typename std::iterator_traits<Iter>::pointer pointer;
    /// weighted_iterator_tag if iterator is weighted
    typedef typename yat::utility::weighted_iterator_traits<Iter>::type w_type;

    /**
       \brief Constructor
    */
    explicit StrideIterator(Iter p, difference_type stride=1)
      : iterator_(p), stride_(stride) {}

    
    /**
       Conversion from mutable iterator to const iterator. Only works
       if underlying iterator is a pointer.
     */
    // Peter, this is ugly hack to provide iterator to const_iterator
    // for our gsl_iterators - solution? use Boost:iterator_adaptor
    operator StrideIterator<const value_type*>()
    { return StrideIterator<const value_type*>(base(), stride_); }

    /**
       \return underlying iterator
     */
    inline Iter base(void) const { return iterator_; }

    /**
       \return stride
     */
    inline size_t stride(void) const { return stride_; }

    /**
       \return element
     */
    reference operator*(void) const 
    { return *iterator_; }

    /**
       \return pointer
     */
    pointer operator->() const { return &(operator*()); }

    /**
       \return element \a n steps forward
     */
    reference operator[](difference_type n) const 
    { 
      return iterator_[stride_*n];
    }

    /**
       \brief pre-increment

       \return reference to *this
     */
    StrideIterator& operator++(void) { iterator_+=stride_; return *this; }

    /**
       \brief post-increment

       \return copy of iterator prior increment
     */
    StrideIterator operator++(int) 
    { StrideIterator tmp(*this); iterator_+=stride_; return tmp;}

    /**
       \brief iterate \f$ n \f$ steps forward

       \return reference to resulting iterator
     */
    StrideIterator& operator+=(int n) { iterator_+=stride_*n; return *this; }

    /**
       \brief post-decrement

       \return copy of iterator prior decrement
     */
    StrideIterator operator--(int) 
    { StrideIterator tmp(*this); iterator_-=stride_; return tmp;}

    /**
       \brief pre-decrement

       \return reference to resulting iterator
     */
    StrideIterator& operator--(void) { iterator_-=stride_; return *this; }

    /**
       \brief iterate \f$ n \f$ steps backwards

       \return reference to resulting iterator
     */
    StrideIterator& operator-=(int n) { iterator_-=n*stride_; return *this; }

    /**
       \brief addition operator

       \return copy of resulting iterator
     */
    friend StrideIterator operator+(const StrideIterator& lhs,difference_type n) 
    { StrideIterator tmp(lhs); tmp+=n; return tmp; }

    /**
       \brief subtraction operator

       \return copy of resulting iterator
     */
    friend StrideIterator operator-(const StrideIterator& lhs, 
                                    difference_type n) 
    { StrideIterator tmp(lhs); tmp-=n; return tmp; }

    /**
       \brief difference operator

       \return distance between \a lhs and \a rhs
     */
    friend difference_type operator-(const StrideIterator& lhs, 
                                     const StrideIterator& rhs) 
    {
      yat_assert<std::runtime_error>(lhs.stride_==rhs.stride_, 
        "StrideIterator::operator- different stride in lhs and rhs.");
      return static_cast<difference_type>( (lhs.iterator_-rhs.iterator_)/
                                           lhs.stride_);
    }

    
    /**
       \brief Equality operator

       \return True if \a lhs and \a rhs are pointing to same element
     */
    friend bool operator==(const StrideIterator& lhs, const StrideIterator& rhs)
    { return lhs.iterator_==rhs.iterator_; }
    
    /**
       \brief Non-equality operator

       \return False if \a lhs and \a rhs are pointing to same element
     */
    friend bool operator!=(const StrideIterator& lhs, const StrideIterator& rhs)
    { return lhs.iterator_!=rhs.iterator_; }
    
    /**
       \brief Less operator
     */
    friend bool operator<(const StrideIterator& lhs, const StrideIterator& rhs)
    { return lhs.iterator_<rhs.iterator_; }
    
    /**
       \brief Less equal operator
     */
    friend bool operator<=(const StrideIterator& lhs, const StrideIterator& rhs)
    { return lhs.iterator_<=rhs.iterator_; }
    
    /**
       \brief Larger operator
     */
    friend bool operator>(const StrideIterator& lhs, const StrideIterator& rhs)
    { return lhs.iterator_>rhs.iterator_; }
    
    /**
       \brief Larger equal operator
     */
    friend bool operator>=(const StrideIterator& lhs, const StrideIterator& rhs)
    { return lhs.iterator_>=rhs.iterator_; }
    
  private:
    Iter iterator_;
    size_t stride_;

    // Using compiler generated copy
    //StrideIterator(const StrideIterator&);
    //StrideIterator& operator=(const StrideIterator&);
  };





}}} // of namespace utility, yat, and theplu

#endif