CORE_StrideIterator.h

#ifndef CORE_StrideIterator_HPP
#define CORE_StrideIterator_HPP
 
#include <iterator>
 
template<class Ptr_Type, tInt Step>
class CORE_StrideIterator {
 
public:
   
 
    typedef typename std::iterator_traits<Ptr_Type>::value_type value_type;
    typedef typename std::iterator_traits<Ptr_Type>::reference reference;
    typedef typename std::iterator_traits<Ptr_Type>::pointer pointer;
 
    typedef typename std::iterator_traits<Ptr_Type>::difference_type difference_type;
    typedef std::random_access_iterator_tag iterator_category;
 
private:
    //This class type
    typedef CORE_StrideIterator self;
 
    Ptr_Type mPointer;
 
public:
 
    //constructors
    //============
    
    CORE_StrideIterator() : mPointer(NULL) {}
    
    explicit CORE_StrideIterator(Ptr_Type x) : mPointer(x) {}
 
    CORE_StrideIterator(const self& x) : mPointer(x.mPointer) {}
    
    //destructor
    //==========
    virtual ~CORE_StrideIterator() {
    }
    
    //accessor operators
    //=====================
    reference operator*() { return *mPointer; }
 
    reference operator[](difference_type n) { return mPointer[n * Step]; }
    
 
    //compount assignement operators
    //===============================
 
    self& operator+=(difference_type x) {
        mPointer += x * Step;
        return *this;
    }
 
 
    //increment & decrement operators
    //================================
 
    self& operator++() {
       
        mPointer += Step;
        return *this;
    }
    self operator++(int s) {
        self tmp = *this; mPointer += Step; return tmp;
    } 
    self& operator--() {
        mPointer -= Step; return *this;
    }
    self operator--(int s) {
        self tmp = *this; mPointer -= Step; return tmp;
    }
 
 
    //arithmetic operators
    //====================
  
    friend self operator+(self x, difference_type y) {
        //x+=y*step -> add step^2 !!
        return (x+=y);
    }
    friend self operator+(difference_type x, self y) {
        return (y+=x);
    }
    friend difference_type operator-(self x, self y) {
        return (x.mPointer - y.mPointer) / Step;
 
    }
 
    //relational & comparison operators
    //=================================
 
    
    friend bool operator==(self x, self y) {
        return x.mPointer == y.mPointer; }
    friend bool operator!=(self x, self y) {
        return x.mPointer != y.mPointer;
    }
    friend bool operator<(self x, self y) { return x.mPointer < y.mPointer; }
    
    //logical operators
    //=================
 
    //bitwise operators
    //=================
    
  
 
 
 
};
 
#endif