SDL3pp_resource.h

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


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

  using RawConstPointer = RAW_CONST_POINTER;

  constexpr ResourceBaseT() = default;

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

  constexpr ResourceBaseT(std::nullptr_t) {}

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

  constexpr auto operator<=>(const ResourceBaseT& 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(ResourceBaseT& lhs, ResourceBaseT& rhs) noexcept
  {
    std::swap(lhs.m_resource, rhs.m_resource);
  }
 
protected:
  constexpr ~ResourceBaseT() = default;

  constexpr ResourceBaseT(const ResourceBaseT&) = default;

  constexpr ResourceBaseT(ResourceBaseT&&) noexcept = default;

  constexpr ResourceBaseT& operator=(const ResourceBaseT&) = default;

  constexpr ResourceBaseT& operator=(ResourceBaseT&&) noexcept = default;
 
private:
  RawPointer m_resource = {}; 
};

template<typename BASE>
struct ResourceRefT : BASE
{
  using BASE::BASE;

  using RawPointer = BASE::RawPointer;

  using RawConstPointer = BASE::RawConstPointer;

  constexpr ResourceRefT(const BASE& resource) noexcept
    : BASE(resource.get())
  {
  }

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

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; 
};

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