pfnc_buffer.hpp

#pragma once
 
#include "buffer_base.hpp"
 
#include "pfnc_format.hpp"
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS


  class PFNCBuffer : public BufferBase
  {
  protected:
    struct PrivateTag
    {
    };
 
  public:
    PFNCBuffer(HandleGuard<BufferBase> &&guard, PrivateTag)
        : BufferBase(std::move(guard))
    {
      if (!CVB_CALL_CAPI(CVCIsPfncBuffer(Handle())))
        throw std::runtime_error("handle must be a pfnc buffer");
    }

    /*
     *  \param [in] guard Life time guard for C-API handle.
     */
    static PFNCBufferPtr FromHandle(HandleGuard<BufferBase> &&guard)
    {
      if (!guard.Handle())
        throw std::runtime_error("handle must not be null");
      return std::make_shared<PFNCBuffer>(std::move(guard), PrivateTag{});
    }
    static PFNCBufferPtr FromHandle(HandleGuard<BufferBase> &&guard) {…}
 
    template <class T>
    static PFNCBufferPtr FromHandle(HandleGuard<BufferBase> &&guard)
    {
      static_assert(std::is_base_of<PFNCBuffer, T>::value, "CVB: Type must be derived from PFNCBuffer");
      return FromHandle(std::move(guard));
    }


    int PFNCValue() const noexcept
    {
      CExports::cvbuint32_t pfncFormat = static_cast<CExports::cvbuint32_t>(Cvb::Pfnc::PfncFormat::InvalidPixelFormat);
      CVB_CALL_CAPI(CVCBufferGetPFNCValue(Handle(), pfncFormat));
      return static_cast<int>(pfncFormat);
    }
    int PFNCValue() const noexcept {…}


    int Rank() const noexcept
    {
      CExports::cvbdim_t rank = 0;
      CVB_CALL_CAPI(CVCBufferGetRank(Handle(), rank));
      return static_cast<int>(rank);
    }
    int Rank() const noexcept {…}


    int Length(int dimension) const
    {
      return static_cast<int>(NativeCall<CExports::cvbint64_t>([this, dimension](CExports::cvbint64_t &value) {
        return CVB_CALL_CAPI(CVCBufferGetLength(Handle(), static_cast<CExports::cvbdim_t>(dimension), value));
      }));
    }
    int Length(int dimension) const {…}


    std::intptr_t Increment(int dimension) const
    {
      return NativeCall<std::intptr_t>([this, dimension](std::intptr_t &ptr) {
        return CVB_CALL_CAPI(CVCBufferGetIncrement(Handle(), static_cast<CExports::cvbdim_t>(dimension), ptr));
      });
    }
    std::intptr_t Increment(int dimension) const {…}
 
  protected:
    template <class T, class FN>
    T NativeCall(const FN &fn) const
    {
      T value;
      const auto result = fn(value);
      if (result < 0)
        Utilities::SystemInfo::ThrowLastError(result);
      return value;
    }
  };
  class PFNCBuffer : public BufferBase {…};
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb