SDL3pp_resource.h

#ifndef SDL3PP_RESOURCE_H_
#define SDL3PP_RESOURCE_H_
 
#include <cstdlib>
 
namespace SDL {


template<typename RAW_POINTER, typename RAW_CONST_POINTER = RAW_POINTER>
class ResourceBase
{
public:
  using RawPointer = RAW_POINTER;

  using RawConstPointer = RAW_CONST_POINTER;

  constexpr ResourceBase(RawPointer resource)
    : m_resource(resource)
  {
  }

  constexpr ResourceBase(std::nullptr_t = nullptr)
    : m_resource{}
  {
  }

  constexpr explicit operator bool() const { return !!m_resource; }

  constexpr auto operator<=>(const ResourceBase& other) const = default;

  constexpr RawConstPointer operator->() const noexcept { return m_resource; }

  constexpr RawPointer operator->() noexcept { return m_resource; }

  constexpr RawPointer get() const noexcept { return m_resource; }

  constexpr RawPointer release() noexcept
  {
    auto r = m_resource;
    m_resource = {};
    return r;
  }
 
  friend constexpr void swap(ResourceBase& lhs, ResourceBase& rhs) noexcept
  {
    std::swap(lhs.m_resource, rhs.m_resource);
  }
 
private:
  RawPointer m_resource; 
};

template<typename RAW_POINTER>
class ResourceLegacyRef
{
public:
  using RawPointer = RAW_POINTER;

  constexpr ResourceLegacyRef(RawPointer resource)
    : m_resource(resource)
  {
  }

  constexpr ResourceLegacyRef(std::nullptr_t = nullptr)
    : m_resource(nullptr)
  {
  }

  constexpr explicit operator bool() const { return !!m_resource; }

  constexpr auto operator<=>(const ResourceLegacyRef& other) const = default;

  constexpr operator RawPointer() const { return m_resource; }

  constexpr auto operator->() const { return m_resource; }
 
private:
  RawPointer m_resource; 
};

template<typename RAW_POINTER, typename RAW_CONST_POINTER>
class ResourceConstRef
{
public:
  using RawPointer = RAW_POINTER;

  using RawConstPointer = RAW_CONST_POINTER;

  constexpr ResourceConstRef(RawConstPointer resource)
    : m_resource(resource)
  {
  }

  constexpr ResourceConstRef(std::nullptr_t = nullptr)
    : m_resource(nullptr)
  {
  }

  constexpr explicit operator bool() const { return !!m_resource; }

  constexpr auto operator<=>(const ResourceConstRef& other) const = default;

  constexpr operator RawConstPointer() const { return m_resource; }

  constexpr operator RawPointer() const
  {
    return const_cast<RawPointer>(m_resource);
  }

  constexpr auto operator->() const { return m_resource; }
 
private:
  RawConstPointer m_resource; 
};

template<typename RESOURCE>
struct ResourceRef : RESOURCE
{
  using RESOURCE::RESOURCE;

  using RawPointer = RESOURCE::RawPointer;

  using RawConstPointer = RESOURCE::RawConstPointer;

  constexpr ResourceRef(RawPointer resource) noexcept
    : RESOURCE(resource)
  {
  }

  constexpr ResourceRef(const RESOURCE& resource) noexcept
    : RESOURCE(resource.get())
  {
  }

  constexpr ResourceRef(RESOURCE&& resource) noexcept
    : RESOURCE(std::move(resource).release())
  {
  }

  constexpr ResourceRef(const ResourceRef& other) noexcept
    : RESOURCE(other.get())
  {
  }

  constexpr ResourceRef(ResourceRef&& other) noexcept
    : RESOURCE(other.get())
  {
  }

  ~ResourceRef() { this->release(); }

  ResourceRef& operator=(const ResourceRef& other) noexcept
  {
    this->release();
    RESOURCE::operator=(RESOURCE(other.get()));
    return *this;
  }

  constexpr operator RawPointer() const noexcept { return this->get(); }
};

 
} // namespace SDL
 
#endif /* SDL3PP_RESOURCE_H_ */