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(CVCIsBuffer(Handle())))
        throw std::runtime_error("pfnc buffer handle must be a buffer");
    }
 
    /*
     *  \param [in] guard Life time guard for C-API handle.
     */
    static PFNCBufferPtr FromHandle(HandleGuard<BufferBase>&& guard)
    {
      return std::make_shared<PFNCBuffer>(std::move(guard), PrivateTag{});
    }
 
 
    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 Rank() const noexcept
    {
      CExports::cvbdim_t rank = 0;
      CVB_CALL_CAPI(CVCBufferGetRank(Handle(), rank));
      return static_cast<int>(rank);
    }
 
 
    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));
        }));
    }
 
 
    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));
        });
    }
 
  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;
    }
  };
 
  CVB_END_INLINE_NS
 
}