buffer_base.hpp

#pragma once
 
#include <cassert>
 
#include "global.hpp"
 
 
namespace Cvb
{
 
  CVB_BEGIN_INLINE_NS
 
  template <>
  inline HandleGuard<BufferBase>::HandleGuard(void* handle) noexcept
    : HandleGuard<BufferBase>(handle, [](void* handle) { CVB_CALL_CAPI(ReleaseObject(handle)); })
  {
  }
 
 
  class BufferBase
  {
  public:
 
     using GuardType = HandleGuard<BufferBase>;
 
  protected:
    explicit BufferBase(HandleGuard<BufferBase>&& guard)
      : handle_(std::move(guard))
    {
      if (!CVB_CALL_CAPI(CVCIsBuffer(Handle())))
        throw std::runtime_error("handle must be a buffer");
    }
 
  public:
    BufferBase(const BufferBase& other) = delete;
    BufferBase& operator=(const BufferBase& other) = delete;
    BufferBase(BufferBase&& other) = delete;
    BufferBase& operator=(BufferBase&& other) = delete;
    virtual ~BufferBase() = default;
 
 
    void* Handle() const noexcept
    {
      return handle_.Handle();
    }
 
 
    std::uint8_t* BasePtr() const noexcept
    {
      void* pBase = nullptr;
      CVB_CALL_CAPI(CVCBufferGetBasePtr(Handle(), pBase));
      return reinterpret_cast<std::uint8_t*>(pBase);
    }
 
 
    size_t Size() const noexcept
    {
      size_t size = 0;
      CVB_CALL_CAPI(CVCBufferGetSize(Handle(), size));
      return size;
    }
 
 
    size_t Capacity() const noexcept
    {
      size_t capacity = 0;
      CVB_CALL_CAPI(CVCBufferGetCapacity(Handle(), capacity));
      return capacity;
    }
 
  private:
    HandleGuard<BufferBase> handle_;
  };
 
  using Cvb::BufferBase;
 
  CVB_END_INLINE_NS
 
}