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();
    }
    void *Handle() const noexcept {…}


    std::uint8_t *BasePtr() const noexcept
    {
      void *pBase = nullptr;
      CVB_CALL_CAPI(CVCBufferGetBasePtr(Handle(), pBase));
      return reinterpret_cast<std::uint8_t *>(pBase);
    }
    std::uint8_t *BasePtr() const noexcept {…}


    size_t Size() const noexcept
    {
      size_t size = 0;
      CVB_CALL_CAPI(CVCBufferGetSize(Handle(), size));
      return size;
    }
    size_t Size() const noexcept {…}


    size_t Capacity() const noexcept
    {
      size_t capacity = 0;
      CVB_CALL_CAPI(CVCBufferGetCapacity(Handle(), capacity));
      return capacity;
    }
    size_t Capacity() const noexcept {…}
 
  private:
    HandleGuard<BufferBase> handle_;
  };
  class BufferBase {…};
 
  using Cvb::BufferBase;
 
  CVB_END_INLINE_NS
 
}  // namespace Cvb