CORE_ConstantStrideIterator.h

#ifndef CORE_ConstantStrideIterator_HPP
#define CORE_ConstantStrideIterator_HPP
 
#include <iterator>
 
template<class Ptr_Type, tInt Step>
class CORE_ConstantStrideIterator {
 
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:
    typedef CORE_ConstantStrideIterator self;
 
private:
 
    Ptr_Type mPointer;
 
public:
 
    //constructors
    //============
    
    CORE_ConstantStrideIterator() : mPointer(NULL) {}
    
    explicit CORE_ConstantStrideIterator(Ptr_Type x) : mPointer(x) {}
 
    CORE_ConstantStrideIterator(const self& x) : mPointer(x.mPointer) {}
    
    virtual ~CORE_ConstantStrideIterator() {
    }
    
    //accessor operators
    //=====================
    const  reference operator*() { return *mPointer; }
    
    const 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) {
        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) {
        //std::cout<<"== x:"<<x.mPointer<<" y:"<<y.mPointer<<" y-x:"<<y.mPointer-x.mPointer<<"\n";
        return x.mPointer == y.mPointer;
    }
    friend bool operator!=(self x, self y) {
        //std::cout<<"!= x:"<<x.mPointer<<" y:"<<y.mPointer<<" y-x:"<<y.mPointer-x.mPointer<<"\n";
        return x.mPointer != y.mPointer;
    }
    friend bool operator<(self x, self y) {
        //std::cout<<"< x:"<<x.mPointer<<" y:"<<y.mPointer<<" y-x:"<<y.mPointer-x.mPointer<<"\n";
        return x.mPointer < y.mPointer;
    }
    
    //logical operators
    //=================
 
    //bitwise operators
    //=================
    
  
 
 
 
};
 
#endif