col_view_iterator.hpp

#ifndef SEQUENCE_COL_VIEW_ITERATOR_HPP__
#define SEQUENCE_COL_VIEW_ITERATOR_HPP__

#include <iterator>
#include <stdexcept>

namespace Sequence
{
    template <typename POINTER> struct col_view_iterator
    {
        static_assert(std::is_pointer<POINTER>::value,
                      "iterator must wrap a pointer type");
        using difference_type =
            typename std::iterator_traits<POINTER>::difference_type;
        using value_type = typename std::iterator_traits<POINTER>::value_type;
        using reference = typename std::iterator_traits<POINTER>::reference;
        using pointer = POINTER;
        using iterator_category =
            typename std::iterator_traits<POINTER>::iterator_category;

        mutable POINTER start;
        mutable POINTER data;

        difference_type stride;
        difference_type offset;
        explicit col_view_iterator(POINTER data_, difference_type stride_,
                                   difference_type offset_)
            : start{ data_ }, data{ data_ }, stride{ stride_ }, offset{
                  offset_
              }
        {
        }

        col_view_iterator(const col_view_iterator&) = default;

        reference operator*() { return *(data + offset); }

        const reference operator*() const { return *(data + offset); }

        reference operator[](difference_type n) { return *(*this + n); }
        const reference operator[](difference_type n) const
        {
            return *(*this + n);
        }

        col_view_iterator&
        operator=(const col_view_iterator& rhs)
        {
            this->start = rhs.start;
            this->data = rhs.data;
            this->stride = rhs.stride;
            this->offset = rhs.offset;
            return *this;
        }

        bool
        operator<=(const col_view_iterator rhs) const
        {
            return (this->data + this->offset) <= (rhs.data + rhs.offset);
        }
        bool
        operator<(const col_view_iterator rhs) const
        {
            return (this->data + this->offset) < (rhs.data + rhs.offset);
        }
        bool
        operator>(const col_view_iterator rhs) const
        {
            return !(*this <= rhs);
        }
        bool
        operator>=(const col_view_iterator rhs) const
        {
            return !(*this < rhs);
        }
        bool
        operator==(const col_view_iterator rhs) const
        {
            return !(*this < rhs) && !(*this > rhs);
        }
        bool
        operator!=(const col_view_iterator rhs) const
        {
            return !(*this == rhs);
        }
    };

    template <typename POINTER>
    col_view_iterator<POINTER> inline
    operator+(col_view_iterator<POINTER> i,
              typename col_view_iterator<POINTER>::difference_type d)
    {
        auto rv(i);
        rv.offset += d * rv.stride;
        return rv;
    }

    template <typename POINTER>
    col_view_iterator<POINTER> inline
    operator+(typename col_view_iterator<POINTER>::difference_type d,
              col_view_iterator<POINTER> i)
    {
        return i + d;
    }

    template <typename POINTER>
    inline col_view_iterator<POINTER>&
    operator++(col_view_iterator<POINTER>& i)
    {
        i.offset += i.stride;
        return i;
    }

    template <typename POINTER>
    inline col_view_iterator<POINTER>
    operator-(col_view_iterator<POINTER> i,
              typename col_view_iterator<POINTER>::difference_type d)
    {
        auto rv(i);
        rv.offset -= d * rv.stride;
        return rv;
    }

    template <typename POINTER>
    col_view_iterator<POINTER> inline
    operator-(typename col_view_iterator<POINTER>::difference_type d,
              col_view_iterator<POINTER> i)
    {
        return i - d;
    }

    template <typename POINTER>
    inline col_view_iterator<POINTER>&
    operator--(col_view_iterator<POINTER>& i)
    {
        i.offset -= i.stride;
        return i;
    }

    template <typename POINTER>
    inline col_view_iterator<POINTER>&
    operator+=(col_view_iterator<POINTER>& i,
               typename col_view_iterator<POINTER>::difference_type d)
    {
        i.offset += d * i.stride;
        return i;
    }

    template <typename POINTER>
    inline col_view_iterator<POINTER>&
    operator-=(col_view_iterator<POINTER>& i,
               typename col_view_iterator<POINTER>::difference_type d)
    {
        i.offset -= d * i.stride;
        return i;
    }

    template <typename POINTER>
    inline typename col_view_iterator<POINTER>::difference_type
    operator-(col_view_iterator<POINTER> i, col_view_iterator<POINTER> j)
    {
        if (i.start != j.start)
            {
                throw std::invalid_argument("attempt to subtract "
                                            "iterators from different "
                                            "columns");
            }
        return (i.offset - j.offset) / i.stride;
    }
}

#endif