stridedPointer.h

Go to the documentation of this file.

#ifndef _DLR_COMMON_STRIDEDPOINTER_H_
#define _DLR_COMMON_STRIDEDPOINTER_H_

#include <iterator>

namespace dlr {

  namespace common {
    
    template <class Type>
    class StridedPointer
      : public std::iterator<std::random_access_iterator_tag, Type, ptrdiff_t>
    {
    public:
      StridedPointer() : m_pointer(0), m_stride(1) {}

      StridedPointer(Type* pointer) : m_pointer(pointer), m_stride(1) {}
    
      StridedPointer(Type* pointer, int stride)
        : m_pointer(pointer), m_stride(stride) {}

      StridedPointer(const StridedPointer<Type>& source)
        : m_pointer(source.m_pointer), m_stride(source.m_stride) {}

      ~StridedPointer() {}

      Type&
      operator*() {return *m_pointer;}

      Type* operator->() {return m_pointer;}

      StridedPointer<Type>& operator++() {m_pointer += m_stride; return *this;}
    
      StridedPointer<Type> operator++(int) {
        StridedPointer<Type> result(*this);
        ++(*this);
        return result;
      }

      StridedPointer<Type>& operator--() {m_pointer -= m_stride; return *this;}

      StridedPointer<Type> operator--(int) {
        StridedPointer<Type> result(*this);
        --(*this);
        return result;
      }

      StridedPointer<Type> operator+(ptrdiff_t offset) {
        StridedPointer<Type> result(*this);
        result += offset;
        return result;
      }

      StridedPointer<Type> operator-(ptrdiff_t offset) {
        StridedPointer<Type> result(*this);
        result -= offset;
        return result;
      }

      ptrdiff_t operator-(const StridedPointer<Type>& other) {
        ptrdiff_t distance = m_pointer - other.m_pointer;
        return distance / m_stride;
      }
    
      StridedPointer<Type>& operator+=(ptrdiff_t offset) {
        m_pointer += offset * m_stride;
        return *this;
      }

      StridedPointer<Type>& operator-=(ptrdiff_t offset) {
        m_pointer -= offset * m_stride;
        return *this;
      }

      bool operator==(const StridedPointer<Type>& other) const {
        return m_pointer == other.m_pointer;
      }

      bool operator!=(const StridedPointer<Type>& other) const {
        return m_pointer != other.m_pointer;
      }

      bool operator<(const StridedPointer<Type>& other) const {
        return m_pointer < other.m_pointer;
      }

      bool operator>(const StridedPointer<Type>& other) const {
        return m_pointer > other.m_pointer;
      }

      bool operator<=(const StridedPointer<Type>& other) const {
        return m_pointer <= other.m_pointer;
      }

      bool operator>=(const StridedPointer<Type>& other) const {
        return m_pointer >= other.m_pointer;
      }

      StridedPointer<Type>& operator=(const StridedPointer<Type>& source) {
        m_pointer = source.m_pointer;
        m_stride = source.m_stride;
        return *this;
      }

    private:
      Type* m_pointer;
      int m_stride;
    };

  } // namespace common
  
} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using common::StridedPointer;
  
} // namespace dlr

#endif // #ifndef _DLR_COMMON_STRIDEDPOINTER_H_