block_helper_ref_value.hpp

#pragma once
 
#include "../../shims/stdtype_traits.hpp"
 
#include "detail_block.hpp"
 
namespace Cvb
{
  CVB_BEGIN_INLINE_NS
 
  namespace  // NOLINT(cert-dcl59-cpp)
  {
    template <template <class, size_t> class CRefValue>
    struct ConstRefValueSetter
    {
      template <size_t I, class Ty, size_t K, std::enable_if_t<less<I, K>::value, int> = 0>
      static CVB_FORCE_INLINE void set(CRefValue<Ty, K> &refVal, const Ty *val) noexcept
      {
        refVal.pointers_[I] = const_cast<Ty *>(val);  // NOLINT(cppcoreguidelines-pro-type-const-cast)
                                                      // we have to const_cast here, as the stored pointers must be
                                                      // mutable as we set them here and for RefValue.
      }
      static CVB_FORCE_INLINE void set(CRefValue<Ty, K> &refVal, const Ty *val) noexcept {…}
    };
    struct ConstRefValueSetter {…};

    template <template <class, size_t> class RValue>
    struct RefValueSetter
    {
      template <size_t I, class Ty, size_t K, std::enable_if_t<less<I, K>::value, int> = 0>
      static CVB_FORCE_INLINE void set(RValue<Ty, K> &refVal, Ty *val) noexcept
      {
        refVal.pointers_[I] = val;
      }
      static CVB_FORCE_INLINE void set(RValue<Ty, K> &refVal, Ty *val) noexcept {…}
    };
    struct RefValueSetter {…};
  }  // namespace

  template <class T, size_t K>
  class ConstRefValue final
  {
    static_assert(K > 0, "Cvb: ConstRefValue must hold at least one element.");
 
    template <class Ty, class ACCESSTRAIT>
    friend class Block;
    template <template <class, size_t> class CRefValue>
    friend struct ConstRefValueSetter;
 
    std::array<T *, K> pointers_;
 
    /*
     * \brief Default Ctor creating invalid object.
     */
    ConstRefValue()
    {
      for (auto &ptr : pointers_)
      {
        ptr = nullptr;
      }
    }
 
  public:
    using ComponentType = T;

    template <class... TT>
    explicit ConstRefValue(const TT &...refs)
        : pointers_({const_cast<T *>(&refs)...})  // NOLINT(cppcoreguidelines-pro-type-const-cast)
                                                  // we have to const_cast here, as the stored pointers must be mutable
                                                  // through the setters and for RefValue.
    {
      static_assert(sizeof...(TT) == K, "Cvb: Number of parameters must equal the number of elements.");
    }
    explicit ConstRefValue(const TT &...refs) {…}
 
    ConstRefValue(const ConstRefValue &other) noexcept            = default;
    ConstRefValue &operator=(const ConstRefValue &other) noexcept = default;
    ConstRefValue(ConstRefValue &&other) noexcept                 = default;
    ConstRefValue &operator=(ConstRefValue &&other) noexcept      = default;
    ~ConstRefValue()                                              = default;
 
  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, *pointers_[I]), 0)...};
      return value;
    }
 
  public:
    template <class Ty>
    Ty Cast() const noexcept
    {
      return Cast<Ty>(std::make_index_sequence<K>());
    }
    Ty Cast() const noexcept {…}

    T X() const noexcept
    {
      return *pointers_[0];
    }
    T X() const noexcept {…}

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

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

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

    T operator[](size_t i) const noexcept
    {
      assert(i < K);
 
      return *pointers_[i];
    }
    T operator[](size_t i) const noexcept {…}

    static constexpr size_t NumValues() noexcept
    {
      return K;
    }
    static constexpr size_t NumValues() noexcept {…}
  };
  class ConstRefValue final {…};

  template <class T, size_t K>
  class RefValue final
  {
    /*
     * This class could theoretically inherit from ConstRefValue,
     * but as that would require adding a virtual destructor to ConstRefValue
     * to ensure correct handling of deletion of pointers to these classes,
     * both classes are implemented as concrete classes.
     *
     * The caveat of adding a virtual destructor is, that it requires constructing
     * a vtable which seems to disable inlining and therefore hurts the performance.
     */
 
    static_assert(K > 0, "Cvb: RefValue must hold at least one element.");
 
    template <class Ty, class ACCESSTRAIT>
    friend class Block;
    template <template <class, size_t> class RValue>
    friend struct RefValueSetter;
 
    std::array<T *, K> pointers_;
 
    /*
     * \brief Default Ctor creating invalid object.
     */
    RefValue()
    {
      for (auto &ptr : pointers_)
      {
        ptr = nullptr;
      }
    }
 
  public:
    using ComponentType = T;

    template <class... TT>
    explicit RefValue(TT &...refs)
        : pointers_({const_cast<T *>(&refs)...})  // NOLINT(cppcoreguidelines-pro-type-const-cast)
                                                  // we have to const_cast here, as the stored pointers must be
                                                  // mutable through the setters and for RefValue.
    {
    }
    explicit RefValue(TT &...refs) {…}
 
    RefValue(const RefValue &other) noexcept            = default;
    RefValue &operator=(const RefValue &other) noexcept = default;
    RefValue(RefValue &&other) noexcept                 = default;
    RefValue &operator=(RefValue &&other) noexcept      = default;
    ~RefValue()                                         = default;
 
  private:
    template <class Ty, size_t... I>
    RefValue<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)(*pointers_[I] = get<I>(other)), 0)...};
      return *this;
    }
 
  public:
    template <class Ty>
    RefValue<T, K> &operator=(const Ty &other) noexcept
    {
      return Assign(other, std::make_index_sequence<K>());  // NOLINT(cppcoreguidelines-c-copy-assignment-signature)
    }
    RefValue<T, K> &operator=(const Ty &other) noexcept {…}

    template <size_t N>
    RefValue<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)
      {
        *pointers_[i] = list[i];
      }
      return *this;
    }
    RefValue<T, K> &operator=(const T (&list)[N]) noexcept  // NOLINT(cppcoreguidelines-avoid-c-arrays) {…}
 
  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, *pointers_[I]), 0)...};
      return value;
    }
 
  public:
    template <class Ty>
    Ty Cast() const noexcept
    {
      return Cast<Ty>(std::make_index_sequence<K>());
    }
    Ty Cast() const noexcept {…}

    T X() const noexcept
    {
      return *pointers_[0];
    }
    T X() const noexcept {…}

    T &X() noexcept
    {
      return *pointers_[0];
    }
    T &X() noexcept {…}

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

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

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

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

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

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

    T operator[](size_t i) const noexcept
    {
      assert(i < K);
 
      return *pointers_[i];
    }
    T operator[](size_t i) const noexcept {…}

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

    static constexpr const size_t NumValues() noexcept
    {
      return K;
    }
    static constexpr const size_t NumValues() noexcept {…}
  };
  class RefValue final {…};

  template <size_t I, class T, size_t K, std::enable_if_t<less<I, K>::value, int> = 0>
  auto get(const RefValue<T, K> &refVal) noexcept -> decltype(refVal[I])
  {
    return refVal[I];
  }
  auto get(const RefValue<T, K> &refVal) noexcept -> decltype(refVal[I]) {…}

  template <size_t I, class T, size_t K, std::enable_if_t<less<I, K>::value, int> = 0>
  auto get(const ConstRefValue<T, K> &refVal) noexcept -> decltype(refVal[I])
  {
    return refVal[I];
  }
  auto get(const ConstRefValue<T, K> &refVal) noexcept -> decltype(refVal[I]) {…}

  template <size_t I, class T, size_t K, std::enable_if_t<less<I, K>::value, int> = 0>
  void set(RefValue<T, K> &refVal, const T &val) noexcept
  {
    refVal[I] = val;
  }
  void set(RefValue<T, K> &refVal, const T &val) noexcept {…}


  template <size_t I, class Ty, size_t K>
  CVB_FORCE_INLINE void internal_set(RefValue<Ty, K> &refVal, Ty *val) noexcept
  {
    assert(val != nullptr);
 
    RefValueSetter<RefValue>::template set<I>(refVal, val);
  }
  CVB_FORCE_INLINE void internal_set(RefValue<Ty, K> &refVal, Ty *val) noexcept {…}


  template <size_t I, class Ty, size_t K>
  CVB_FORCE_INLINE void internal_set(ConstRefValue<Ty, K> &refVal, const Ty *val) noexcept
  {
    assert(val != nullptr);
 
    ConstRefValueSetter<ConstRefValue>::template set<I>(refVal, val);
  }
  CVB_FORCE_INLINE void internal_set(ConstRefValue<Ty, K> &refVal, const Ty *val) noexcept {…}
 
  CVB_END_INLINE_NS
}  // namespace Cvb