decl_block.hpp

#pragma once
 
#include "../../global.hpp"
 
#include "../../_detail/block/block_helper_linear_value.hpp"
#include "../../_detail/block/block_helper_ref_value.hpp"
 
#include "decl_block_base.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS

  template <class T, class ACCESSTRAIT>
  class Block final : public BlockBase<ACCESSTRAIT>
  {
    template <class Ty, class OTHER_ACCESSTRAIT>
    friend class Block;
 
  public:
    using ComponentType  = ComponentOfT<T>;  // Type of one pixel.
    using AccessTrait    = ACCESSTRAIT;      // Type of the access trait.
    using PixelType      = T;                // Actual type T given as template argument.
    using ConstPixelType = const T;          // Const version of PixelType.

    static constexpr const bool IsPixelTypeMutable = true;
 
  private:
    static constexpr const size_t NumComponents = NumComponentsOfV<T>;
    static_assert(NumComponents > 0, "Cvb: NumComponents must be at least 1");

    template <class OTHER_ACCESSTRAIT>
    explicit Block(const Block<T, OTHER_ACCESSTRAIT> &other, Cvb::Rect<int> aoi)
        : BlockBase<ACCESSTRAIT>(other, aoi)
    {
      if (!IsAligned<PixelType>(other.Access()(0, 0))
          || (aoi.Width() > 1 && !IsAligned<PixelType>(other.Access()(1, 0)))
          || (aoi.Height() > 1 && !IsAligned<PixelType>(other.Access()(0, 1))))
        throw std::runtime_error("Block-type and pointer must have the same alignment.");
    }
 
  public:
    explicit Block(ACCESSTRAIT access, Cvb::Size2D<int> size)
        : BlockBase<ACCESSTRAIT>(std::move(access), size)
    {
      if (!IsAligned<PixelType>(access(0, 0)) || (size.Width() > 1 && !IsAligned<PixelType>(access(1, 0)))
          || (size.Height() > 1 && !IsAligned<PixelType>(access(0, 1))))
        throw std::runtime_error("Block-type and pointer must have the same alignment.");
    }
 
    Block(const Block &other) noexcept            = default;
    Block &operator=(const Block &other) noexcept = default;
    Block(Block &&other) noexcept                 = default;
    Block &operator=(Block &&other) noexcept      = default;
    ~Block()                                      = default;

    auto SubBlock(Cvb::Rect<int> aoi) const -> Block<T, decltype(this->Access().NewMoved(Cvb::Rect<int>{}))>
    {
      return Block<T, decltype(this->Access().NewMoved(Cvb::Rect<int>{}))>{*this, aoi};
    }

    CVB_FORCE_INLINE const PixelType &operator()(int x, int y) const noexcept
    {
      return *reinterpret_cast<const PixelType *>(this->Access()(x, y));
    }

    CVB_FORCE_INLINE PixelType &operator()(int x, int y) noexcept
    {
      static_assert(!std::is_const<typename std::remove_pointer<decltype(this->Access()(x, y))>::type>::value,
                    "The underlying access does not support mutable access. Make the Block const.");
      return *reinterpret_cast<PixelType *>(this->Access()(x, y));
    }
 
  private:
    template <class PTy, size_t... I>
    CVB_FORCE_INLINE static void SetElements(PixelType &pt, const PTy &value, std::index_sequence<I...>) noexcept
    {
      using expander = int[];  // NOLINT(cppcoreguidelines-avoid-c-arrays) fold expression support for pre C++17
                               // standards.. explanation see FillPixelValueElements.
 
      expander{0, (set<I>(pt, get<I>(value)), 0)...};
    }
 
  public:
    template <class FromPixelType>
    CVB_FORCE_INLINE auto Set(int x, int y, const FromPixelType &value) noexcept
        -> std::enable_if_t<!std::is_convertible<remove_cvref_t<FromPixelType>, remove_cvref_t<PixelType>>::value, void>
    {
      static_assert(!std::is_const<typename std::remove_pointer<decltype(this->Access()(x, y))>::type>::value,
                    "The underlying access does not support mutable access.");
      static_assert(NumComponentsOfV<FromPixelType> >= NumComponents || NumComponentsOfV<FromPixelType> == -1,
                    "Incoming value must have at least as many components as current value.");
 
      SetElements(*reinterpret_cast<PixelType *>(this->Access()(x, y)), value,
                  std::make_index_sequence<NumComponents>{});
    }

    CVB_FORCE_INLINE void Set(int x, int y, const PixelType &value) noexcept
    {
      static_assert(!std::is_const<typename std::remove_pointer<decltype(this->Access()(x, y))>::type>::value,
                    "The underlying access does not support mutable access.");
      *reinterpret_cast<PixelType *>(this->Access()(x, y)) = value;
    }

    CVB_FORCE_INLINE const PixelType &operator[](int idx) const noexcept
    {
      return *reinterpret_cast<const PixelType *>(this->Access()[idx]);
    }

    CVB_FORCE_INLINE PixelType &operator[](int idx) noexcept
    {
      static_assert(!std::is_const<typename std::remove_pointer<decltype(this->Access()[idx])>::type>::value,
                    "The underlying access does not support mutable access. Make the Block const.");
      return *reinterpret_cast<PixelType *>(this->Access()[idx]);
    }

    template <class FromPixelType>
    CVB_FORCE_INLINE auto Set(int idx, const FromPixelType &value) noexcept
        -> std::enable_if_t<!std::is_convertible<remove_cvref_t<FromPixelType>, remove_cvref_t<PixelType>>::value, void>
    {
      static_assert(!std::is_const<typename std::remove_pointer<decltype(this->Access()[idx])>::type>::value,
                    "The underlying access does not support mutable access.");
      static_assert(NumComponentsOfV<FromPixelType> >= NumComponents || NumComponentsOfV<FromPixelType> == -1,
                    "Incoming value must have at least as many components as current value.");
 
      SetElements(*reinterpret_cast<PixelType *>(this->Access()[idx]), value,
                  std::make_index_sequence<NumComponents>{});
    }

    CVB_FORCE_INLINE void Set(int idx, const PixelType &value) noexcept
    {
      static_assert(!std::is_const<typename std::remove_pointer<decltype(this->Access()[idx])>::type>::value,
                    "The underlying access does not support mutable access.");
      *reinterpret_cast<PixelType *>(this->Access()[idx]) = value;
    }

    class Row
    {
      friend class Block;
 
      using AccessRow = typename AccessTrait::Row;
 
      AccessRow row_;  

      explicit Row(AccessRow row) noexcept
          : row_(row)
      {
      }
 
    public:
      Row() = default;
 
      Row(const Row &) noexcept            = default;
      Row &operator=(const Row &) noexcept = default;
      Row(Row &&other) noexcept            = default;
      Row &operator=(Row &&other) noexcept = default;
      ~Row()                               = default;

      CVB_FORCE_INLINE PixelType &operator[](int x) noexcept
      {
        static_assert(!std::is_const<typename std::remove_pointer<decltype(row_[x])>::type>::value,
                      "The underlying access does not support mutable access. Make the Row const.");
        return *reinterpret_cast<PixelType *>(row_[x]);
      }

      CVB_FORCE_INLINE const PixelType &operator[](int x) const noexcept
      {
        return *reinterpret_cast<const PixelType *>(row_[x]);
      }

      template <class FromPixelType>
      CVB_FORCE_INLINE auto Set(int x, const FromPixelType &value) noexcept
          -> std::enable_if_t<!std::is_convertible<remove_cvref_t<FromPixelType>, remove_cvref_t<PixelType>>::value,
                              void>
      {
        static_assert(!std::is_const<typename std::remove_pointer<decltype(row_[x])>::type>::value,
                      "The underlying access does not support mutable access.");
        static_assert(NumComponentsOfV<FromPixelType> >= NumComponents || NumComponentsOfV<FromPixelType> == -1,
                      "Incoming value must have at least as many components as current value.");
 
        SetElements(*reinterpret_cast<PixelType *>(row_[x]), value, std::make_index_sequence<NumComponents>{});
      }

      CVB_FORCE_INLINE void Set(int x, const PixelType &value) noexcept
      {
        static_assert(!std::is_const<typename std::remove_pointer<decltype(row_[0])>::type>::value,
                      "The underlying access does not support mutable access.");
        *reinterpret_cast<PixelType *>(row_[x]) = value;
      }
    };

    class Column
    {
      friend class Block;
 
      using AccessColumn = typename AccessTrait::Column;
 
      AccessColumn col_;  

      explicit Column(AccessColumn col) noexcept
          : col_(col)
      {
      }
 
    public:
      Column() = default;
 
      Column(const Column &)                     = default;
      Column &operator=(const Column &)          = default;
      Column(Column &&other) noexcept            = default;
      Column &operator=(Column &&other) noexcept = default;
      ~Column()                                  = default;

      CVB_FORCE_INLINE PixelType &operator[](int y) noexcept
      {
        static_assert(!std::is_const<typename std::remove_pointer<decltype(col_[y])>::type>::value,
                      "The underlying access does not support mutable access. Make the Column const.");
        return *reinterpret_cast<PixelType *>(col_[y]);
      }

      CVB_FORCE_INLINE const PixelType &operator[](int y) const noexcept
      {
        return *reinterpret_cast<const PixelType *>(col_[y]);
      }

      template <class FromPixelType>
      CVB_FORCE_INLINE auto Set(int y, const FromPixelType &value) noexcept
          -> std::enable_if_t<!std::is_convertible<remove_cvref_t<FromPixelType>, remove_cvref_t<PixelType>>::value,
                              void>
      {
        static_assert(!std::is_const<typename std::remove_pointer<decltype(col_[y])>::type>::value,
                      "The underlying access does not support mutable access.");
        static_assert(NumComponentsOfV<FromPixelType> >= NumComponents || NumComponentsOfV<FromPixelType> == -1,
                      "Incoming value must have at least as many components as current value.");
 
        SetElements(*reinterpret_cast<PixelType *>(col_[y]), value, std::make_index_sequence<NumComponents>{});
      }

      CVB_FORCE_INLINE void Set(int y, const PixelType &value) noexcept
      {
        static_assert(!std::is_const<typename std::remove_pointer<decltype(this->col_[0])>::type>::value,
                      "The underlying access does not support mutable access.");
        *reinterpret_cast<PixelType *>(col_[y]) = value;
      }
    };

    Row RowAt(int y) const noexcept
    {
      return Row{this->Access().RowAt(y)};
    }

    Column ColumnAt(int x) const noexcept
    {
      return Column{this->Access().ColumnAt(x)};
    }
  };
 
  // specialization for ScatterAccess
  template <class T, int K>
  class Block<T, ScatterAccess<K>> final : public BlockBase<ScatterAccess<K>>
  {
    template <class Ty, class OTHER_ACCESSTRAIT>
    friend class Block;
 
  public:
    using ComponentType = ComponentOfT<T>;   
    using AccessTrait   = ScatterAccess<K>;  
    using PixelType     = T;                 
    using ConstPixelType =
        typename std::conditional<std::is_same<PixelType, RefValue<ComponentType, K>>::value,
                                  const ConstRefValue<ComponentType, K>,
                                  const PixelType>::type;  
 
    static constexpr const bool IsPixelTypeMutable =
        std::is_same<PixelType, RefValue<ComponentType, K>>::value;  
 
  private:
    explicit Block(const Block &other, Cvb::Rect<int> aoi)
        : BlockBase<ScatterAccess<K>>(other, aoi)
    {
    }
 
  public:
    explicit Block(AccessTrait access, Cvb::Size2D<int> size)
        : BlockBase<AccessTrait>(std::move(access), std::move(size))
    {
    }
 
    Block(const Block &other) noexcept            = default;
    Block &operator=(const Block &other) noexcept = default;
    Block(Block &&other) noexcept                 = default;
    Block &operator=(Block &&other) noexcept      = default;
    ~Block()                                      = default;

    auto SubBlock(Cvb::Rect<int> aoi) const -> Block<T, decltype(this->Access().NewMoved(Cvb::Rect<int>{}))>
    {
      return Block<T, decltype(this->Access().NewMoved(Cvb::Rect<int>{}))>{*this, aoi};
    }
 
  private:
    template <class PTy, class Ty, size_t... I>
    static CVB_FORCE_INLINE PTy FillPixelValueElements(Ty addresses, std::index_sequence<I...>) noexcept
    {
      // JMe: as C++14 does not yet support fold expressions, which would make this a bit more straight forward I had to
      // go with this weird version As `I` is a template parameter pack, it has to be expanded with the ... operator.
      // But this is only possible in contexts, where a list of `xxx, yyy, zzz` is allowed, as the ... operator joins
      // the expression before it with commas. One such context where it is possible to expand the parameter pack, is
      // array initialization as used here. The array is unnamed, to make clear to the compiler, that the array can be
      // optimized away. If `set` returned something it could be as short as: int[]{internal_set<I>(value,
      // reinterpret_cast<const ComponentType*>(addresses[I]))...}; this just calls set<0>, set<1>, set<2>,... with the
      // corresponding address and "stores" the return values in the array (which will be discarded anyway). As `set`
      // returns void, we need to utilize the comma operator, which evaluates the expression left of the operator but
      // discards its value and returns the value on the right of the comma (an int). E.g. after `int i = 200; int x =
      // i++, 0;` i == 201 and x == 0. Therefore the expression down there just calls set<I> for all I in 0 to K - 1
      // with the corresponding address.
 
      using expander =
          int[];  // NOLINT(cppcoreguidelines-avoid-c-arrays) fold expression support for pre C++17 standards..
 
      using CType = typename std::conditional<std::is_const<PTy>::value, const ComponentType, ComponentType>::type;
      typename std::remove_const<PTy>::type value;
      expander{0, ((void)internal_set<I>(value, reinterpret_cast<CType *>(addresses[I])), 0)...};
      return value;
    }

    template <class PTy, class Ty>
    static CVB_FORCE_INLINE PTy FillPixelValue(Ty addresses) noexcept
    {
      return FillPixelValueElements<PTy>(addresses, std::make_index_sequence<K>());
    }

    template <class Ty, class PTy, size_t... I>
    CVB_FORCE_INLINE static void SetElements(Ty addresses, const PTy &value, std::index_sequence<I...>) noexcept
    {
      // fold expression support for pre C++17 standards.. explanation see FillPixelValueElements.
      using expander = int[];  // NOLINT(cppcoreguidelines-avoid-c-arrays)
 
      expander{0, (*reinterpret_cast<ComponentType *>(addresses[I]) = get<I>(value), 0)...};
    }
 
  public:
    CVB_FORCE_INLINE ConstPixelType operator()(int x, int y) const noexcept
    {
      auto addresses = this->Access()(x, y);
      return FillPixelValue<ConstPixelType>(addresses);
    }

    template <bool ENABLE = IsPixelTypeMutable, std::enable_if_t<ENABLE, int> = 0>
    CVB_FORCE_INLINE PixelType operator()(int x, int y) noexcept
    {
      auto addresses = this->Access()(x, y);
      return FillPixelValue<PixelType>(addresses);
    }

    template <class FromPixelType>
    CVB_FORCE_INLINE auto Set(int x, int y, const FromPixelType &value) noexcept
        -> std::enable_if_t<!std::is_convertible<remove_cvref_t<FromPixelType>, remove_cvref_t<PixelType>>::value, void>
    {
      auto addresses = this->Access()(x, y);
      SetElements(addresses, value, std::make_index_sequence<K>());
    }

    CVB_FORCE_INLINE void Set(int x, int y, const PixelType &value) noexcept
    {
      auto addresses = this->Access()(x, y);
      SetElements(addresses, value, std::make_index_sequence<K>());
    }

    CVB_FORCE_INLINE ConstPixelType operator[](int idx) const noexcept
    {
      auto addresses = this->Access()[idx];
      return FillPixelValue<ConstPixelType>(addresses);
    }

    template <bool ENABLE = IsPixelTypeMutable, std::enable_if_t<ENABLE, int> = 0>
    CVB_FORCE_INLINE PixelType operator[](int idx) noexcept
    {
      auto addresses = this->Access()[idx];
      return FillPixelValue<PixelType>(addresses);
    }

    template <class FromPixelType>
    CVB_FORCE_INLINE auto Set(int idx, const FromPixelType &value) noexcept
        -> std::enable_if_t<!std::is_convertible<remove_cvref_t<FromPixelType>, remove_cvref_t<PixelType>>::value, void>
    {
      auto addresses = this->Access()[idx];
      SetElements(addresses, value, std::make_index_sequence<K>());
    }

    CVB_FORCE_INLINE void Set(int idx, const PixelType &value) noexcept
    {
      auto addresses = this->Access()[idx];
      SetElements(addresses, value, std::make_index_sequence<K>());
    }

    class Row
    {
      friend class Block;
 
      using AccessRow = typename AccessTrait::Row;
 
      AccessRow row_;  

      explicit Row(AccessRow row) noexcept
          : row_(row)
      {
      }
 
    public:
      Row() = default;
 
      Row(const Row &other) noexcept            = default;
      Row &operator=(const Row &other) noexcept = default;
      Row(Row &&other) noexcept                 = default;
      Row &operator=(Row &&other) noexcept      = default;
      ~Row()                                    = default;

      template <bool ENABLE = IsPixelTypeMutable, std::enable_if_t<ENABLE, int> = 0>
      CVB_FORCE_INLINE PixelType operator[](int x) noexcept
      {
        auto addresses = row_[x];
        return FillPixelValue<PixelType>(addresses);
      }

      CVB_FORCE_INLINE ConstPixelType operator[](int x) const noexcept
      {
        auto addresses = row_[x];
        return FillPixelValue<ConstPixelType>(addresses);
      }

      template <class FromPixelType>
      CVB_FORCE_INLINE auto Set(int x, const FromPixelType &value) noexcept
          -> std::enable_if_t<!std::is_convertible<remove_cvref_t<FromPixelType>, remove_cvref_t<PixelType>>::value,
                              void>
      {
        auto addresses = row_[x];
        SetElements(addresses, value, std::make_index_sequence<K>());
      }

      CVB_FORCE_INLINE void Set(int x, const PixelType &value) noexcept
      {
        auto addresses = row_[x];
        SetElements(addresses, value, std::make_index_sequence<K>());
      }
    };

    class Column
    {
      friend class Block;
 
      using AccessColumn = typename AccessTrait::Column;
 
      AccessColumn col_;  

      explicit Column(AccessColumn col) noexcept
          : col_(col)
      {
      }
 
    public:
      Column() = default;
 
      Column(const Column &other) noexcept            = default;
      Column &operator=(const Column &other) noexcept = default;
      Column(Column &&other) noexcept                 = default;
      Column &operator=(Column &&other) noexcept      = default;
      ~Column()                                       = default;

      template <bool ENABLE = IsPixelTypeMutable, std::enable_if_t<ENABLE, int> = 0>
      CVB_FORCE_INLINE PixelType operator[](int y) noexcept
      {
        auto addresses = col_[y];
        return FillPixelValue<PixelType>(addresses);
      }

      CVB_FORCE_INLINE ConstPixelType operator[](int y) const noexcept
      {
        auto addresses = col_[y];
        return FillPixelValue<ConstPixelType>(addresses);
      }

      template <class FromPixelType>
      CVB_FORCE_INLINE auto Set(int y, const FromPixelType &value) noexcept
          -> std::enable_if_t<!std::is_convertible<remove_cvref_t<FromPixelType>, remove_cvref_t<PixelType>>::value,
                              void>
      {
        auto addresses = col_[y];
        SetElements(addresses, value, std::make_index_sequence<K>());
      }

      CVB_FORCE_INLINE void Set(int y, const PixelType &value) noexcept
      {
        auto addresses = col_[y];
        SetElements(addresses, value, std::make_index_sequence<K>());
      }
    };

    Row RowAt(int y) const noexcept
    {
      return Row{this->Access().RowAt(y)};
    }

    Column ColumnAt(int x) const noexcept
    {
      return Column{this->Access().ColumnAt(x)};
    }
  };

  template <class T>
  using ArrayPlaneBlock = Block<T, ArrayAccess>;

  template <class T>
  using LinearPlaneBlock = Block<T, LinearAccess>;

  template <class T>
  using VpatPlaneBlock = Block<T, VpatAccess>;

  template <class T, size_t K>
  using ScatterBlock = Block<T, ScatterAccess<K>>;
 
  CVB_END_INLINE_NS
}  // namespace Cvb