block_helper_linear_value.hpp

#pragma once
 
#include "detail_block.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  template <typename T, size_t K>
  class LinearValue;

  template <size_t I, class T, size_t K, std::enable_if_t<less<I, K>::value, int> = 0>
  T get(const LinearValue<T, K> &linVal) noexcept;

  template <size_t I, class T, size_t K, std::enable_if_t<less<I, K>::value, int> = 0>
  void set(LinearValue<T, K> &linVal, const T &val) noexcept;

#pragma pack(push, 1)
  template <typename T, size_t K>
  class LinearValue final
  {
    template <class TTY, class ACCESSTRAITT>
    friend class Block;
 
    std::array<T, K> values_;
 
  public:
    using ComponentType = T;
 
    /*
     * \brief Ctor.
     *        This shouldn't be public as it destroys the whole point of the LinearValue. Todo: revisit.
     *        could in theory be private with friending block (see RefValue), but GCC 7.3 (at least) doesn't like it.
     */
    LinearValue() = default;
 
    LinearValue(const LinearValue &other) noexcept            = default;
    LinearValue &operator=(const LinearValue &other) noexcept = default;
    LinearValue(LinearValue &&other) noexcept                 = default;
    LinearValue &operator=(LinearValue &&other) noexcept      = default;
    ~LinearValue()                                            = default;
 
  private:
    template <class Ty, size_t... I>
    LinearValue<T, K> &Assign(const Ty &other, std::index_sequence<I...>) noexcept
    {
      using expander = int[];  // NOLINT(cppcoreguidelines-avoid-c-arrays) fold expression support for pre C++17
                               // standards.. for explanation see Block::FillPixelValueElements
 
      expander{0, ((void)(values_[I] = get<I>(other)), 0)...};
      return *this;
    }
 
  public:
    template <class Ty>
    LinearValue<T, K> &operator=(const Ty &other) noexcept
    {
      return Assign(other, std::make_index_sequence<K>());  // NOLINT(cppcoreguidelines-c-copy-assignment-signature)
    }

    template <std::size_t N>
    LinearValue<T, K> &operator=(const T (&list)[N]) noexcept  // NOLINT(cppcoreguidelines-avoid-c-arrays)
    {
      static_assert(N == K, "Cvb: The initializer list must contain K elements.");
 
      for (int i = 0; i < N; ++i)
      {
        values_[i] = list[i];
      }
      return *this;
    }
 
  private:
    template <class Ty, size_t... I>
    Ty Cast(std::index_sequence<I...>) const noexcept
    {
      using expander = int[];  // NOLINT(cppcoreguidelines-avoid-c-arrays) fold expression support for pre C++17
                               // standards.. for explanation see Block::FillPixelValueElements
 
      Ty value{};
      expander{0, ((void)set<I>(value, values_[I]), 0)...};
      return value;
    }
 
  public:
    template <class Ty>
    Ty Cast() const noexcept
    {
      return Cast<Ty>(std::make_index_sequence<K>());
    }

    T &X() noexcept
    {
      return values_[0];
    }

    const T &X() const noexcept
    {
      return values_[0];
    }

    template <size_t N = K, std::enable_if_t<less<1, N>::value, int> = 0>
    T &Y() noexcept
    {
      return values_[1];
    }

    template <size_t N = K, std::enable_if_t<less<1, N>::value, int> = 0>
    const T &Y() const noexcept
    {
      return values_[1];
    }

    template <size_t N = K, std::enable_if_t<less<2, N>::value, int> = 0>
    T &Z() noexcept
    {
      return values_[2];
    }

    template <size_t N = K, std::enable_if_t<less<2, N>::value, int> = 0>
    const T &Z() const noexcept
    {
      return values_[2];
    }

    template <size_t N = K, std::enable_if_t<less<3, N>::value, int> = 0>
    T &W() noexcept
    {
      return values_[3];
    }

    template <size_t N = K, std::enable_if_t<less<3, N>::value, int> = 0>
    const T &W() const noexcept
    {
      return values_[3];
    }

    const T &operator[](size_t i) const noexcept
    {
      assert(i < K);
 
      return values_[i];
    }

    T &operator[](size_t i) noexcept
    {
      assert(i < K);
 
      return values_[i];
    }

    static constexpr const size_t NumValues() noexcept
    {
      return K;
    }
  };
#pragma pack(pop)
 
  static_assert(sizeof(LinearValue<float, 1>) == 1 * sizeof(float), "LinearValue is not packed");
  static_assert(sizeof(LinearValue<float, 2>) == 2 * sizeof(float), "LinearValue is not packed");
  static_assert(sizeof(LinearValue<float, 3>) == 3 * sizeof(float), "LinearValue is not packed");
  static_assert(sizeof(LinearValue<float, 4>) == 4 * sizeof(float), "LinearValue is not packed");
  static_assert(sizeof(LinearValue<double, 5>) == 5 * sizeof(double), "LinearValue is not packed");
 
  template <size_t I, class T, size_t K, std::enable_if_t<less<I, K>::value, int>>
  T get(const LinearValue<T, K> &linVal) noexcept
  {
    return linVal[I];
  }
 
  template <size_t I, class T, size_t K, std::enable_if_t<less<I, K>::value, int>>
  void set(LinearValue<T, K> &linVal, const T &val) noexcept
  {
    linVal[I] = val;
  }
 
  /*
   * \relates LinearValue
   * \sa Block, Visit
   *
   * \brief Set's the value of the \a I-th element in the \em LinearValue<T,K> \a linVal to the value pointed to by \a
   * val.
   *
   * \pre I < K
   *
   * \tparam I The index of the element.
   * \param linVal The \em LinearValue<T,K> to retrieve the \a I-th element from.
   * \param val The pointer to the value to be written to the \a I-th element of \a linVal.
   */
  template <size_t I, class T, size_t K, std::enable_if_t<less<I, K>::value, int> = 0>
  void internal_set(LinearValue<T, K> &linVal, const T *val) noexcept
  {
    assert(val != nullptr);
    linVal[I] = *val;
  }
  CVB_END_INLINE_NS
}  // namespace Cvb