decl_scatter_access.hpp

#pragma once
 
#include <array>
#include <vector>
#include <utility>
 
#include "../exception.hpp"
#include "../shims/stdtype_traits.hpp"
#include "../shims/stdvariant.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  class LinearAccessData;
  class ArrayAccess;
  class Vpat;
 
  namespace Internal
  {
    // The plane access types supported for scattered access.
    using AccessVariant = variant<ArrayAccess, LinearAccessData, Vpat>;
 
    // The row access types supported for scattered access.
    using RowVariant = variant<ArrayAccess::Row, LinearAccessData::Row, Vpat::Row>;
 
    // The column access types supported for scattered access.
    using ColumnVariant = variant<ArrayAccess::Column, LinearAccessData::Column, Vpat::Column>;
 
    /*
     * \brief Gets whether all planes in the range are valid.
     *
     * \param [in] first First element to check.
     * \param [in] last One behind last element to check.
     * \return \b true if all are valid; \b false otherwise.
     */
    template <class FITER>
    bool AllValid(FITER first, FITER last);
  }  // namespace Internal

  static const constexpr int Dynamic = -1;

  template <int K>
  class ScatterAccess
  {
    static_assert(K > 1, "CVB: empty or single plane scatter access not allowed");
 
  public:
    using Variant = Internal::AccessVariant;
 
  private:
    // Storage for the single plane access objects.
    std::array<Variant, K> planeAccesses_;
 
    static Variant MoveTo(const Variant &planeAccess, const Cvb::Rect<int> newAoi)
    {
      return visit([newAoi](auto access) { return Variant{access.NewMoved(newAoi)}; }, planeAccess);
    }
 
    template <size_t... INDICES>
    ScatterAccess<K> NewMoved(const Cvb::Rect<int> newAoi, std::index_sequence<INDICES...>) const noexcept
    {
      return ScatterAccess<K>{MoveTo(planeAccesses_[INDICES], newAoi)...};
    }
 
    static const void *At(const Variant &planeAccess, int x, int y) noexcept
    {
      return visit([x, y](auto access) { return access(x, y); }, planeAccess);
    }
 
    template <size_t... INDICES>
    std::array<const void *, K> At(int x, int y, std::index_sequence<INDICES...>) const noexcept
    {
      return std::array<const void *, K>{{At(planeAccesses_[INDICES], x, y)...}};
    }
 
    static void *At(Variant &planeAccess, int x, int y) noexcept
    {
      return visit([x, y](auto access) { return access(x, y); }, planeAccess);
    }
 
    template <size_t... INDICES>
    std::array<void *, K> At(int x, int y, std::index_sequence<INDICES...>) noexcept
    {
      return std::array<void *, K>{{At(planeAccesses_[INDICES], x, y)...}};
    }
 
    static const void *At(const Variant &planeAccess, int idx) noexcept
    {
      return visit([idx](auto access) { return access[idx]; }, planeAccess);
    }
 
    template <size_t... INDICES>
    std::array<const void *, K> At(int idx, std::index_sequence<INDICES...>) const noexcept
    {
      return std::array<const void *, K>{{At(planeAccesses_[INDICES], idx)...}};
    }
 
    static void *At(Variant &planeAccess, int idx) noexcept
    {
      return visit([idx](auto access) { return access[idx]; }, planeAccess);
    }
 
    template <size_t... INDICES>
    std::array<void *, K> At(int idx, std::index_sequence<INDICES...>) noexcept
    {
      return std::array<void *, K>{{At(planeAccesses_[INDICES], idx)...}};
    }
 
    template <
        class... ACCESSES,
        std::enable_if_t<!conjunction<std::is_same<remove_cvref_t<ACCESSES>, ScatterAccess<K>>...>::value, int> = 0>
    explicit ScatterAccess(ACCESSES &&...planeAccesses)
        : planeAccesses_{{planeAccesses...}}
    {
      static_assert(sizeof...(ACCESSES) == K, "CVB: plane initialization must match plane count K");
    }
 
  public:
    template <class... ACCESSES>
    static ScatterAccess<K> FromAccess(ACCESSES &&...planeAccesses)
    {
      // must be bracket init for unpack to work
      return ScatterAccess<K>{Variant(planeAccesses)...};
    }
    static ScatterAccess<K> FromAccess(ACCESSES &&...planeAccesses) {…}
 
    ScatterAccess(const ScatterAccess &other) noexcept
        : planeAccesses_(other.planeAccesses_)
    {
      // must be explicitly defined, as GCC 7.x is not able to generate it automatically for some reason.
    }
 
    ScatterAccess &operator=(const ScatterAccess &other) noexcept
    {
      // must be explicitly defined, as GCC 7.x is not able to generate it automatically for some reason.
      if (this != &other)
        planeAccesses_ = other.planeAccesses_;
 
      return *this;
    }
 
    ScatterAccess(ScatterAccess &&other) noexcept            = default;
    ScatterAccess &operator=(ScatterAccess &&other) noexcept = default;
    ~ScatterAccess()                                         = default;

    constexpr size_t PlanesCount() const
    {
      return K;
    }
    constexpr size_t PlanesCount() const {…}

    ScatterAccess<K> NewMoved(const Cvb::Rect<int> newAoi) const noexcept
    {
      return NewMoved(newAoi, std::make_index_sequence<K>{});
    }
    ScatterAccess<K> NewMoved(const Cvb::Rect<int> newAoi) const noexcept {…}

    bool Valid() const noexcept
    {
      return Internal::AllValid(planeAccesses_.begin(), planeAccesses_.end());
    }
    bool Valid() const noexcept {…}

    explicit operator bool() const noexcept
    {
      return Valid();
    }
    explicit operator bool() const noexcept {…}

    std::array<const void *, K> operator()(int x, int y) const noexcept
    {
      return At(x, y, std::make_index_sequence<K>{});
    }
    std::array<const void *, K> operator()(int x, int y) const noexcept {…}

    std::array<void *, K> operator()(int x, int y) noexcept
    {
      return At(x, y, std::make_index_sequence<K>{});
    }
    std::array<void *, K> operator()(int x, int y) noexcept {…}

    std::array<const void *, K> operator[](int idx) const noexcept
    {
      return At(idx, std::make_index_sequence<K>{});
    }
    std::array<const void *, K> operator[](int idx) const noexcept {…}

    std::array<void *, K> operator[](int idx) noexcept
    {
      return At(idx, std::make_index_sequence<K>{});
    }
    std::array<void *, K> operator[](int idx) noexcept {…}

    class Row
    {
      friend class ScatterAccess;
 
      std::array<Internal::RowVariant, K> rows_;
 
      static Internal::RowVariant RowAt(const Variant &planeAccess, int y)
      {
        return visit([y](auto access) { return Internal::RowVariant{access.RowAt(y)}; }, planeAccess);
      }
 
      template <size_t... INDICES>
      explicit Row(const ScatterAccess<K> &parent, int y, std::index_sequence<INDICES...>)
          : rows_{{RowAt(parent.planeAccesses_[INDICES], y)...}}
      {
      }
 
      // Creates a row from the scatter access at line \a y.
      explicit Row(const ScatterAccess<K> &parent, int y)
          : Row(parent, y, std::make_index_sequence<K>{})
      {
      }
 
      static const void *ColumnAt(const Internal::RowVariant &row, int x)
      {
        return visit([x](auto rowAccess) { return rowAccess[x]; }, row);
      }
 
      static void *ColumnAt(Internal::RowVariant &row, int x)
      {
        return visit([x](auto rowAccess) { return rowAccess[x]; }, row);
      }
 
      template <size_t... INDICES>
      std::array<const void *, K> ColumnAt(int x, std::index_sequence<INDICES...>) const
      {
        return std::array<const void *, K>{{ColumnAt(rows_[INDICES], x)...}};
      }
 
      template <size_t... INDICES>
      std::array<void *, K> ColumnAt(int x, std::index_sequence<INDICES...>)
      {
        return std::array<void *, K>{{ColumnAt(rows_[INDICES], x)...}};
      }
 
    public:
      Row() noexcept = default;
 
      Row(const Row &other)                = default;
      Row &operator=(const Row &other)     = default;
      Row(Row &&other) noexcept            = default;
      Row &operator=(Row &&other) noexcept = default;
      ~Row()                               = default;

      std::array<void *, K> operator[](int x) noexcept
      {
        return ColumnAt(x, std::make_index_sequence<K>{});
      }
      std::array<void *, K> operator[](int x) noexcept {…}

      std::array<const void *, K> operator[](int x) const noexcept
      {
        return ColumnAt(x, std::make_index_sequence<K>{});
      }
      std::array<const void *, K> operator[](int x) const noexcept {…}
    };
    class Row {…};

    Row RowAt(int y) const
    {
      return Row{*this, y};
    }
    Row RowAt(int y) const {…}

    class Column
    {
      friend class ScatterAccess;
 
      std::array<Internal::ColumnVariant, K> columns_;
 
      static Internal::ColumnVariant ColumnAt(const Variant &planeAccess, int x)
      {
        return visit([x](auto access) { return Internal::ColumnVariant{access.ColumnAt(x)}; }, planeAccess);
      }
 
      template <size_t... INDICES>
      explicit Column(const ScatterAccess<K> &parent, int x, std::index_sequence<INDICES...>)
          : columns_{{ColumnAt(parent.planeAccesses_[INDICES], x)...}}
      {
      }
 
      // Creates a Column from the scatter access at column \a x.
      explicit Column(const ScatterAccess<K> &parent, int x)
          : Column(parent, x, std::make_index_sequence<K>{})
      {
      }
 
      static const void *RowAt(const Internal::ColumnVariant &column, int y)
      {
        return visit([y](auto colAccess) { return colAccess[y]; }, column);
      }
 
      static void *RowAt(Internal::ColumnVariant &column, int y)
      {
        return visit([y](auto colAccess) { return colAccess[y]; }, column);
      }
 
      template <size_t... INDICES>
      std::array<const void *, K> RowAt(int y, std::index_sequence<INDICES...>) const
      {
        return std::array<const void *, K>{{RowAt(columns_[INDICES], y)...}};
      }
 
      template <size_t... INDICES>
      std::array<void *, K> RowAt(int y, std::index_sequence<INDICES...>)
      {
        return std::array<void *, K>{{RowAt(columns_[INDICES], y)...}};
      }
 
    public:
      Column() noexcept = default;
 
      Column(const Column &other)                = default;
      Column &operator=(const Column &other)     = default;
      Column(Column &&other) noexcept            = default;
      Column &operator=(Column &&other) noexcept = default;
      ~Column()                                  = default;

      std::array<void *, K> operator[](int y) noexcept
      {
        return RowAt(y, std::make_index_sequence<K>{});
      }
      std::array<void *, K> operator[](int y) noexcept {…}

      std::array<const void *, K> operator[](int y) const noexcept
      {
        return RowAt(y, std::make_index_sequence<K>{});
      }
      std::array<const void *, K> operator[](int y) const noexcept {…}
    };
    class Column {…};

    Column ColumnAt(int x) const
    {
      return Column{*this, x};
    }
    Column ColumnAt(int x) const {…}
  };
  class ScatterAccess {…};

  template <class... ACCESSES>
  auto MakeStaticScatterAccess(ACCESSES &&...planeAccesses) -> ScatterAccess<sizeof...(ACCESSES)>
  {
    return ScatterAccess<sizeof...(ACCESSES)>::FromAccess(std::forward<ACCESSES>(planeAccesses)...);
  }
  auto MakeStaticScatterAccess(ACCESSES &&...planeAccesses) -> ScatterAccess<sizeof...(ACCESSES)> {…}
 
#ifndef CVB_DOXYGEN
  // Specialization for dynamic number of planes.
  template <>
  class ScatterAccess<Dynamic>
  {
  public:
    using Variant = Internal::AccessVariant;
 
  private:
    // Storage for the single plane access objects.
    std::vector<Variant> planeAccesses_;
 
  public:
    template <class FITER>
    explicit ScatterAccess(FITER first, FITER last)
        : planeAccesses_(first, last)
    {
      if (planeAccesses_.size() <= 1)
        throw std::domain_error{"Empty or single plane scatter buffer not allowed"};
    }

    explicit ScatterAccess(std::vector<Variant> planeAccesses)
        : planeAccesses_(std::move(planeAccesses))
    {
      if (planeAccesses_.size() <= 1)
        throw std::domain_error{"Empty or single plane scatter buffer not allowed"};
    }
 
    template <class... ACCESSES>
    static ScatterAccess<Dynamic> FromAccess(ACCESSES &&...planeAccesses)
    {
      return ScatterAccess<Dynamic>{{Variant(planeAccesses)...}};
    }
 
    ScatterAccess(const ScatterAccess &other)
        : planeAccesses_(other.planeAccesses_)
    {
      // must be explicitly defined, as GCC 7.x is not able to generate it automatically for some reason.
    }
 
    ScatterAccess &operator=(const ScatterAccess &other)
    {
      // must be explicitly defined, as GCC 7.x is not able to generate it automatically for some reason.
      if (this != &other)
        planeAccesses_ = other.planeAccesses_;
 
      return *this;
    }
 
    ScatterAccess(ScatterAccess &&other) noexcept            = default;
    ScatterAccess &operator=(ScatterAccess &&other) noexcept = default;
    ~ScatterAccess()                                         = default;

    size_t PlanesCount() const
    {
      return planeAccesses_.size();
    }

    ScatterAccess<Dynamic> NewMoved(const Cvb::Rect<int> newAoi) const
    {
      std::vector<Variant> newMoved;
      newMoved.reserve(planeAccesses_.size());
      for (const auto &planeAccess : planeAccesses_)
      {
        visit([&newMoved, newAoi](auto access) { newMoved.emplace_back(access.NewMoved(newAoi)); }, planeAccess);
      }
 
      return ScatterAccess<Dynamic>{std::move(newMoved)};
    }

    bool Valid() const noexcept
    {
      return Internal::AllValid(planeAccesses_.begin(), planeAccesses_.end());
    }

    explicit operator bool() const noexcept
    {
      return Valid();
    }

    std::vector<const void *> operator()(int x, int y) const noexcept
    {
      std::vector<const void *> pixAddresses;
      pixAddresses.reserve(planeAccesses_.size());
      for (const auto &planeAccess : planeAccesses_)
      {
        pixAddresses.emplace_back(visit([x, y](auto access) { return access(x, y); }, planeAccess));
      }
 
      return pixAddresses;
    }

    std::vector<void *> operator()(int x, int y) noexcept
    {
      std::vector<void *> pixAddresses;
      pixAddresses.reserve(planeAccesses_.size());
      for (auto &planeAccess : planeAccesses_)
      {
        pixAddresses.emplace_back(visit([x, y](auto access) { return access(x, y); }, planeAccess));
      }
      return pixAddresses;
    }

    std::vector<const void *> operator[](int idx) const noexcept
    {
      std::vector<const void *> pixAddresses;
      pixAddresses.reserve(planeAccesses_.size());
      for (auto &planeAccess : planeAccesses_)
      {
        pixAddresses.emplace_back(visit([idx](auto access) { return access[idx]; }, planeAccess));
      }
 
      return pixAddresses;
    }

    std::vector<void *> operator[](int idx) noexcept
    {
      std::vector<void *> pixAddresses;
      pixAddresses.reserve(planeAccesses_.size());
      for (auto &planeAccess : planeAccesses_)
      {
        pixAddresses.emplace_back(visit([idx](auto access) { return access[idx]; }, planeAccess));
      }
 
      return pixAddresses;
    }

    class Row
    {
      friend class ScatterAccess;
 
      std::vector<Internal::RowVariant> rows_;
 
      explicit Row(const ScatterAccess<Dynamic> &parent, int y)
      {
        rows_.reserve(parent.planeAccesses_.size());
        for (const auto &planeAccess : parent.planeAccesses_)
        {
          visit([this, y](auto access) { rows_.emplace_back(access.RowAt(y)); }, planeAccess);
        }
      }
 
    public:
      Row() noexcept = default;
 
      Row(const Row &other)                = default;  // vector copy may throw
      Row &operator=(const Row &other)     = default;  // vector copy may throw
      Row(Row &&other) noexcept            = default;
      Row &operator=(Row &&other) noexcept = default;
      ~Row()                               = default;

      std::vector<void *> operator[](int x) noexcept
      {
        std::vector<void *> pixel;
        pixel.reserve(rows_.size());
 
        for (auto &row : rows_)
        {
          pixel.emplace_back(visit([x](auto rowAccess) { return rowAccess[x]; }, row));
        }
 
        return pixel;
      }

      std::vector<const void *> operator[](int x) const noexcept
      {
        std::vector<const void *> pixel;
        pixel.reserve(rows_.size());
 
        for (auto &row : rows_)
        {
          pixel.emplace_back(visit([x](auto rowAccess) { return rowAccess[x]; }, row));
        }
 
        return pixel;
      }
    };

    Row RowAt(int y) const
    {
      return Row{*this, y};
    }

    class Column
    {
      friend class ScatterAccess;
 
      std::vector<Internal::ColumnVariant> columns_;
 
      explicit Column(const ScatterAccess<Dynamic> &parent, int x)
      {
        columns_.reserve(parent.planeAccesses_.size());
        for (const auto &planeAccess : parent.planeAccesses_)
        {
          visit([this, x](auto access) { columns_.emplace_back(access.ColumnAt(x)); }, planeAccess);
        }
      }
 
    public:
      Column() noexcept = default;
 
      Column(const Column &other)                = default;  // vector copy may throw
      Column &operator=(const Column &other)     = default;  // vector copy may throw
      Column(Column &&other) noexcept            = default;
      Column &operator=(Column &&other) noexcept = default;
      ~Column()                                  = default;

      std::vector<void *> operator[](int y) noexcept
      {
        std::vector<void *> pixel;
        pixel.reserve(columns_.size());
 
        for (auto &column : columns_)
        {
          pixel.emplace_back(visit([y](auto colAccess) { return colAccess[y]; }, column));
        }
 
        return pixel;
      }

      std::vector<const void *> operator[](int y) const noexcept
      {
        std::vector<const void *> pixel;
        pixel.reserve(columns_.size());
 
        for (auto &column : columns_)
        {
          pixel.emplace_back(visit([y](auto colAccess) { return colAccess[y]; }, column));
        }
 
        return pixel;
      }
    };

    Column ColumnAt(int x) const
    {
      return Column{*this, x};
    }
  };
#endif
  CVB_END_INLINE_NS
 
}  // namespace Cvb