SDL3pp_resource.h

#ifndef SDL3PP_RESOURCE_H_
#define SDL3PP_RESOURCE_H_
 
#include <optional>
 
namespace SDL {
 
template<class T>
class Resource
{
  T m_resource;
 
public:
  constexpr Resource(T resource = {})
    : m_resource(std::move(resource))
  {
  }
 
  constexpr Resource(std::nullptr_t)
    : m_resource{0}
  {
  }
 
  constexpr Resource(std::nullopt_t)
    : m_resource{0}
  {
  }
 
  Resource(const Resource& other) = delete;
  Resource(Resource&& other) = delete;
  Resource& operator=(const Resource& other) = delete;
  Resource& operator=(Resource&& other) = delete;
 
  constexpr explicit operator bool() const { return m_resource; }
 
  constexpr bool operator==(const Resource& other) const = default;
 
  constexpr bool operator==(std::nullopt_t) const { return !m_resource; }
 
  constexpr bool operator==(std::nullptr_t) const { return !m_resource; }
 
  constexpr T get() const { return m_resource; }
 
  constexpr T release(T newResource = {})
  {
    T result = std::move(m_resource);
    m_resource = newResource;
    return result;
  }
 
  constexpr const T operator->() const { return get(); }
 
  constexpr T operator->() { return get(); }
};
 
template<class REF, class UNIQUE>
class OptionalResource : public REF
{
  bool m_owning = false;
 
public:
  using REF::REF;
 
  constexpr OptionalResource(const REF& other)
    : REF(other)
  {
  }
 
  constexpr OptionalResource(const UNIQUE& other)
    : REF(other)
  {
  }
 
  constexpr OptionalResource(UNIQUE&& other)
    : REF(other.release())
    , m_owning(true)
  {
  }
 
  OptionalResource(const OptionalResource& other) = delete;
 
  OptionalResource(OptionalResource&& other)
    : REF(other.release())
    , m_owning(other.m_owning)
  {
    other.m_owning = false;
  }
 
  OptionalResource& operator=(const OptionalResource& other) = delete;
 
  OptionalResource& operator=(OptionalResource&& other)
  {
    REF::operator=(REF(other.release()));
    m_owning = other.m_owning;
    other.m_owning = false;
    return *this;
  }
 
  ~OptionalResource()
  {
    if (m_owning) REF::reset();
  }
};
 
template<class REF, class UNIQUE>
struct DetachedResource : REF
{
  using REF::REF;
 
  DetachedResource(const DetachedResource& other) = delete;
 
  constexpr DetachedResource(DetachedResource&& other)
    : REF(other.release())
  {
  }
 
  DetachedResource& operator=(const DetachedResource& other) = delete;
 
  constexpr DetachedResource& operator=(DetachedResource&& other)
  {
    release(other.release());
    return *this;
  }
 
  operator UNIQUE() { return UNIQUE{REF::release()}; }
};
 
} // namespace SDL
 
#endif /* SDL3PP_RESOURCE_H_ */