image_plane_contiguous_iterator.hpp

#pragma once
 
#include <iterator>
#include <cassert>
 
#include "size_2d.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <class Type>
  class ContiguousConstIterator
  {
  private:
    using Allocator   = std::allocator<Type>;
    using AllocType   = typename std::allocator_traits<Allocator>::template rebind_alloc<Type>;
    using AllocTraits = std::allocator_traits<AllocType>;
 
  public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type        = Type;
    using pointer           = typename AllocTraits::pointer;
    using reference         = const value_type &;
    using difference_type   = typename AllocTraits::difference_type;
 
    ContiguousConstIterator() = default;
 
    explicit ContiguousConstIterator(pointer ptr, intptr_t index) noexcept
        : ptr_(ptr)
        , index_(index)
    {
      assert(("index must not be negative", index >= 0));  // NOLINT
    }
 
    reference operator*() const noexcept
    {
      return ptr_[index_];
    }
 
    pointer operator->() const noexcept
    {
      return ptr_ + index_;
    }
 
    ContiguousConstIterator<Type> &operator++() noexcept
    {
      ++index_;
      return *this;
    }
 
    ContiguousConstIterator<Type> operator++(int) noexcept  // NOLINT(cert-dcl21-cpp)
    {
      auto tmp = *this;
      ++*this;
      return tmp;
    }
 
    ContiguousConstIterator<Type> &operator--() noexcept
    {
      --index_;
      assert(("operator-- results in negative index", index_ >= 0));
      return *this;
    }
 
    ContiguousConstIterator<Type> operator--(int) noexcept  // NOLINT(cert-dcl21-cpp)
    {
      auto tmp = *this;
      --*this;
      return tmp;
    }
 
    ContiguousConstIterator<Type> &operator+=(const difference_type offset) noexcept
    {
      index_ += offset;
      assert(("operator+= results in negative index", index_ >= 0));
      return *this;
    }
 
    ContiguousConstIterator<Type> operator+(const difference_type offset) const noexcept
    {
      auto tmp = *this;
      return tmp += offset;
    }
 
    ContiguousConstIterator<Type> &operator-=(const difference_type offset) noexcept
    {
      return *this += -offset;
    }
 
    ContiguousConstIterator<Type> operator-(const difference_type offset) const noexcept
    {
      auto tmp = *this;
      return tmp -= offset;
    }
 
    difference_type operator-(const ContiguousConstIterator<Type> &rhs) const noexcept
    {
      assert(("operator- results in negative index", index_ - rhs.index_ >= 0));
      return index_ - rhs.index_;
    }
 
    reference operator[](const difference_type offset) const noexcept
    {
      return *(*this + offset);
    }
 
    bool operator==(const ContiguousConstIterator<Type> &rhs) const noexcept
    {
      assert(("iter to different buffer", ptr_ == rhs.ptr_));
      return index_ == rhs.index_;
    }
 
    bool operator!=(const ContiguousConstIterator<Type> &rhs) const noexcept
    {
      return !(*this == rhs);
    }
 
    bool operator<(const ContiguousConstIterator<Type> &rhs) const noexcept
    {
      return index_ < rhs.index_;
    }
 
    bool operator>(const ContiguousConstIterator<Type> &rhs) const noexcept
    {
      return rhs < *this;
    }
 
    bool operator<=(const ContiguousConstIterator<Type> &rhs) const noexcept
    {
      return !(rhs < *this);
    }
 
    bool operator>=(const ContiguousConstIterator<Type> &rhs) const noexcept
    {
      return !(*this < rhs);
    }
 
  private:
    pointer ptr_    = nullptr;
    intptr_t index_ = 0;
  };
 
  template <class Type>
  inline ContiguousConstIterator<Type> operator+(typename ContiguousConstIterator<Type>::difference_type offset,
                                                 ContiguousConstIterator<Type> next) noexcept
  {
    return next += offset;
  }
 
  template <class Type>
  class ContiguousIterator : public ContiguousConstIterator<Type>
  {
  private:
    using Allocator   = std::allocator<Type>;
    using AllocType   = typename std::allocator_traits<Allocator>::template rebind_alloc<Type>;
    using AllocTraits = std::allocator_traits<AllocType>;
 
    using Base = ContiguousConstIterator<Type>;
 
  public:
    using iterator_category = std::random_access_iterator_tag;
    using value_type        = Type;
    using pointer           = typename AllocTraits::pointer;
    using reference         = value_type &;
    using difference_type   = typename AllocTraits::difference_type;
 
    using Base::Base;
 
    reference operator*() const noexcept
    {
      return const_cast<reference>(Base::operator*());  // NOLINT(cppcoreguidelines-pro-type-const-cast)
    }
 
    pointer operator->() const noexcept
    {
      return const_cast<pointer>(Base::operator->());  // NOLINT(cppcoreguidelines-pro-type-const-cast)
    }
 
    ContiguousIterator<Type> &operator++() noexcept
    {
      Base::operator++();
      return *this;
    }
 
    ContiguousIterator<Type> operator++(int) noexcept  // NOLINT(cert-dcl21-cpp)
    {
      auto tmp = *this;
      Base::operator++();
      return tmp;
    }
 
    ContiguousIterator<Type> &operator--() noexcept
    {
      Base::operator--();
      return *this;
    }
 
    ContiguousIterator<Type> operator--(int) noexcept  // NOLINT(cert-dcl21-cpp)
    {
      auto tmp = *this;
      Base::operator--();
      return tmp;
    }
 
    ContiguousIterator<Type> &operator+=(const difference_type offset) noexcept
    {
      Base::operator+=(offset);
      return *this;
    }
 
    ContiguousIterator<Type> operator+(const difference_type offset) const noexcept
    {
      auto tmp = *this;
      return tmp += offset;
    }
 
    ContiguousIterator<Type> &operator-=(const difference_type offset) noexcept
    {
      Base::operator-=(offset);
      return *this;
    }
 
    using Base::operator-;
 
    ContiguousIterator<Type> operator-(const difference_type offset) const noexcept
    {
      auto tmp = *this;
      return tmp -= offset;
    }
 
    reference operator[](const difference_type offset) const noexcept
    {
      return const_cast<reference>(Base::operator[](offset));  // NOLINT(cppcoreguidelines-pro-type-const-cast)
    }
  };
 
  template <class Type>
  inline ContiguousIterator<Type> operator+(typename ContiguousIterator<Type>::difference_type offset,
                                            ContiguousIterator<Type> next) noexcept
  {
    return next += offset;
  }
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb