pfnc_buffer.hpp

#pragma once

#include "buffer_base.hpp"

#include "gevserver/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

}