image_plane_linear_iterator.hpp

#pragma once
 
#include <iterator>
#include <cassert>
 
#include "_decl/decl_linear_access.hpp"
 
#include "size_2d.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <class Type>
  class LinearConstIterator
  {
  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;
 
    LinearConstIterator() = default;
 
    explicit LinearConstIterator(LinearAccessData linearAccessData, Size2D<int> size,
                                 Point2D<int> pos = Point2D<int>()) noexcept
        : linearAccessData_(linearAccessData)
        , size_(size)
        , currentPos_(pos)
    {
      ApplyCurrentPos();
    }
 
    reference operator*() const noexcept
    {
      return *reinterpret_cast<Type *>(currentPixelPtr_);
    }
 
    pointer operator->() const noexcept
    {
      return reinterpret_cast<Type *>(currentPixelPtr_);
    }
 
    LinearConstIterator<Type> &operator++() noexcept
    {
      currentPos_.SetX(currentPos_.X() + 1);
      currentPixelPtr_ += linearAccessData_.XInc();
      if (currentPos_.X() < size_.Width())
        return *this;
      else
      {
        currentPos_.SetX(0);
        currentPos_.SetY(currentPos_.Y() + 1);
        currentLinePtr_ += linearAccessData_.YInc();
        currentPixelPtr_ = currentLinePtr_;
        return *this;
      }
    }
 
    LinearConstIterator<Type> operator++(int) noexcept  // NOLINT(cert-dcl21-cpp)
    {
      auto tmp = *this;
      ++*this;
      return tmp;
    }
 
    LinearConstIterator<Type> &operator--() noexcept
    {
      currentPos_.SetX(currentPos_.X() - 1);
      currentPixelPtr_ -= linearAccessData_.XInc();
      if (currentPos_.X() >= 0)
        return *this;
      else
      {
        currentPos_.SetX(size_.Width() - 1);
        currentPos_.SetY(currentPos_.Y() - 1);
        currentLinePtr_ -= linearAccessData_.YInc();
        currentPixelPtr_ = currentLinePtr_ + currentPos_.X() * linearAccessData_.XInc();
        return *this;
      }
    }
 
    LinearConstIterator<Type> operator--(int) noexcept  // NOLINT(cert-dcl21-cpp)
    {
      auto tmp = *this;
      --*this;
      return tmp;
    }
 
    LinearConstIterator<Type> &operator+=(const difference_type offset) noexcept
    {
      auto linearPos = Point2DToLinear(currentPos_);
      linearPos += offset;
      currentPos_ = LinearToPoint2D(linearPos);
      ApplyCurrentPos();
      return *this;
    }
 
    LinearConstIterator<Type> operator+(const difference_type offset) const noexcept
    {
      auto tmp = *this;
      return tmp += offset;
    }
 
    LinearConstIterator<Type> &operator-=(const difference_type offset) noexcept
    {
      return *this += -offset;
    }
 
    LinearConstIterator<Type> operator-(const difference_type offset) const noexcept
    {
      auto tmp = *this;
      return tmp -= offset;
    }
 
    difference_type operator-(const LinearConstIterator<Type> &rhs) const noexcept
    {
      return Point2DToLinear(currentPos_) - Point2DToLinear(rhs.currentPos_);
    }
 
    reference operator[](const difference_type offset) const noexcept
    {
      return *(*this + offset);
    }
 
    bool operator==(const LinearConstIterator<Type> &rhs) const noexcept
    {
      return currentPos_ == rhs.currentPos_;
    }
 
    bool operator!=(const LinearConstIterator<Type> &rhs) const noexcept
    {
      return !(*this == rhs);
    }
 
    bool operator<(const LinearConstIterator<Type> &rhs) const noexcept
    {
      return Point2DToLinear(currentPos_) < Point2DToLinear(rhs.currentPos_);
    }
 
    bool operator>(const LinearConstIterator<Type> &rhs) const noexcept
    {
      return rhs < *this;
    }
 
    bool operator<=(const LinearConstIterator<Type> &rhs) const noexcept
    {
      return !(rhs < *this);
    }
 
    bool operator>=(const LinearConstIterator<Type> &rhs) const noexcept
    {
      return !(*this < rhs);
    }
 
  private:
    difference_type Point2DToLinear(Point2D<int> pos) const noexcept
    {
      return static_cast<difference_type>(pos.Y()) * static_cast<difference_type>(size_.Width())
             + static_cast<difference_type>(pos.X());
    }
 
    Point2D<int> LinearToPoint2D(difference_type pos) const noexcept
    {
      return Point2D<int>(static_cast<int>(pos % size_.Width()), static_cast<int>(pos / size_.Width()));
    }
 
    void ApplyCurrentPos() noexcept
    {
      currentLinePtr_ =
          reinterpret_cast<std::uint8_t *>(linearAccessData_.BasePtr()) + currentPos_.Y() * linearAccessData_.YInc();
      currentPixelPtr_ = currentLinePtr_ + currentPos_.X() * linearAccessData_.XInc();
    }
 
    LinearAccessData linearAccessData_;
    Size2D<int> size_;
    Point2D<int> currentPos_;
    std::uint8_t *currentLinePtr_  = nullptr;
    std::uint8_t *currentPixelPtr_ = nullptr;
  };
 
  template <class Type>
  inline LinearConstIterator<Type> operator+(typename LinearConstIterator<Type>::difference_type offset,
                                             LinearConstIterator<Type> next) noexcept
  {
    return next += offset;
  }
 
  template <class Type>
  class LinearIterator : public LinearConstIterator<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 = LinearConstIterator<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)
    }
 
    LinearIterator<Type> &operator++() noexcept
    {
      Base::operator++();
      return *this;
    }
 
    LinearIterator<Type> operator++(int) noexcept  // NOLINT(cert-dcl21-cpp)
    {
      auto tmp = *this;
      Base::operator++();
      return tmp;
    }
 
    LinearIterator<Type> &operator--() noexcept
    {
      Base::operator--();
      return *this;
    }
 
    LinearIterator<Type> operator--(int) noexcept  // NOLINT(cert-dcl21-cpp)
    {
      auto tmp = *this;
      Base::operator--();
      return tmp;
    }
 
    LinearIterator<Type> &operator+=(const difference_type offset) noexcept
    {
      Base::operator+=(offset);
      return *this;
    }
 
    LinearIterator<Type> operator+(const difference_type offset) const noexcept
    {
      auto tmp = *this;
      return tmp += offset;
    }
 
    LinearIterator<Type> &operator-=(const difference_type offset) noexcept
    {
      Base::operator-=(offset);
      return *this;
    }
 
    using Base::operator-;
 
    LinearIterator<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 LinearIterator<Type> operator+(typename LinearIterator<Type>::difference_type offset,
                                        LinearIterator<Type> next) noexcept
  {
    return next += offset;
  }
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb