SDL3pp_resource.h

#ifndef SDL3PP_RESOURCE_H_
#define SDL3PP_RESOURCE_H_
 
#include <memory>
#include <optional>
 
namespace SDL {
 
template<class T, class RESOURCE>
concept ResourceHandle = requires(const T& test) {
  { *test } -> std::convertible_to<RESOURCE>;
};
 
template<class T>
class Resource
{
  T m_resource;
 
public:
  using value_type = T;
 
  constexpr Resource(T resource = {})
    : m_resource(std::move(resource))
  {
  }
 
  constexpr Resource(const ResourceHandle<Resource<T>> auto& resource)
    : Resource(*resource)
  {
  }
 
  constexpr Resource(std::nullptr_t)
    : m_resource{0}
  {
  }
 
  constexpr Resource(std::nullopt_t)
    : m_resource{0}
  {
  }
 
  constexpr explicit operator bool() const { return m_resource; }
 
  constexpr operator value_type() 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 const T operator->() const { return get(); }
 
  constexpr T operator->() { return get(); }
};
 
template<class RESOURCE>
struct DefaultDeleter
{
  void operator()(RESOURCE& ref) const { RESOURCE::reset(ref.get()); }
};
 
template<class RESOURCE>
class ResourcePtrBase
{
public:
  using reference = RESOURCE;
 
  using value_type = typename reference::value_type;
 
private:
  reference m_value;
 
protected:
  constexpr ResourcePtrBase(value_type value = {})
    : m_value(value)
  {
  }
 
  reference& get() { return m_value; }
 
public:
  constexpr operator bool() const { return bool(m_value); }
 
  constexpr bool operator==(const ResourcePtrBase& other) const
  {
    return m_value == other.m_value;
  };
 
  constexpr bool operator==(std::nullptr_t) const { return !*this; }
 
  constexpr bool operator==(std::nullopt_t) const { return !*this; }
 
  constexpr reference operator*() const { return m_value; }
 
  constexpr const reference* operator->() const { return &m_value; }
 
  constexpr reference* operator->() { return &m_value; }
 
  reference get() const { return m_value; }
};
 
template<class RESOURCE, class DELETER>
class ResourceOwnerBase : public ResourcePtrBase<RESOURCE>
{
  using base = ResourcePtrBase<RESOURCE>;
  DELETER m_deleter;
 
protected:
  constexpr ResourceOwnerBase(base::value_type value = {}, DELETER deleter = {})
    : base(value)
    , m_deleter(std::move(deleter))
  {
  }
 
  void free() { m_deleter(base::get()); }
 
public:
  using deleter = DELETER;
 
  RESOURCE release()
  {
    RESOURCE value = base::get();
    base::get() = {};
    return value;
  }
};
 
template<class RESOURCE, class DELETER = DefaultDeleter<RESOURCE>>
class ResourceUnsafe : public ResourceOwnerBase<RESOURCE, DELETER>
{
  using base = ResourceOwnerBase<RESOURCE, DELETER>;
 
public:
  constexpr ResourceUnsafe() = default;
 
  constexpr explicit ResourceUnsafe(RESOURCE other, DELETER deleter = {})
    : base(other, std::move(deleter))
  {
    other = nullptr;
  }
 
  void reset()
  {
    base::free();
    base::release();
  }
};
 
template<class RESOURCE, class DELETER = DefaultDeleter<RESOURCE>>
class ResourceUnique : public ResourceOwnerBase<RESOURCE, DELETER>
{
  using base = ResourceOwnerBase<RESOURCE, DELETER>;
 
public:
  constexpr ResourceUnique(std::nullptr_t = nullptr) {};
 
  constexpr explicit ResourceUnique(base::value_type value,
                                    DELETER deleter = {})
    : base(value, std::move(deleter))
  {
  }
 
  constexpr ResourceUnique(ResourceUnique&& other)
    : base(other)
  {
    other.release();
  }
 
  ResourceUnique(const ResourceUnique& other) = delete;
 
  ~ResourceUnique() { base::free(); }
 
  constexpr ResourceUnique& operator=(ResourceUnique other)
  {
    base::operator=(other);
    other.release();
    return *this;
  }
 
  void reset()
  {
    base::free();
    base::release();
  }
};
 
// Forward decl
template<class UNIQUE>
class ResourceWeak;
 
template<class UNIQUE>
class ResourceShared : public ResourcePtrBase<typename UNIQUE::reference>
{
  using base = ResourcePtrBase<typename UNIQUE::reference>;
  std::shared_ptr<UNIQUE> m_shared;
 
  constexpr explicit ResourceShared(std::shared_ptr<UNIQUE> shared)
    : base(shared ? **shared : nullptr)
    , m_shared(std::move(shared))
  {
  }
 
public:
  constexpr ResourceShared(std::nullptr_t = nullptr) {};
 
  constexpr ResourceShared(UNIQUE&& value)
    : base(*value)
    , m_shared(std::make_shared<UNIQUE>(std::move(value)))
  {
  }
 
  constexpr explicit ResourceShared(base::value_type value,
                                    typename UNIQUE::deleter deleter = {})
    : ResourceShared(UNIQUE(value, std::move(deleter)))
  {
  }
 
  constexpr bool unique() const { return m_shared.unique(); }
 
  void reset() { *this = {}; }
 
  friend class ResourceWeak<UNIQUE>;
};
 
template<class UNIQUE>
class ResourceWeak
{
  std::weak_ptr<UNIQUE> m_shared;
 
public:
  constexpr ResourceWeak() = default;
 
  constexpr ResourceWeak(const ResourceShared<UNIQUE>& shared)
    : m_shared(shared.m_shared)
  {
  }
 
  constexpr bool operator==(const ResourceWeak& other) const = default;
 
  constexpr bool expired() const { return m_shared.expired(); }
 
  constexpr operator bool() const { return !expired(); }
 
  ResourceShared<UNIQUE> lock() const
  {
    return ResourceShared<UNIQUE>(m_shared.lock());
  }
};
 
template<class RESOURCE, class UNIQUE>
class DetachedResource
  : public ResourceOwnerBase<RESOURCE, DefaultDeleter<RESOURCE>>
{
  using base = ResourceOwnerBase<RESOURCE, DefaultDeleter<RESOURCE>>;
 
public:
  constexpr explicit DetachedResource(RESOURCE other)
    : base(other)
  {
    other = nullptr;
  }
 
  DetachedResource(const DetachedResource& other) = delete;
 
  constexpr DetachedResource(DetachedResource&& other) = default;
 
  DetachedResource& operator=(const DetachedResource& other) = delete;
 
  constexpr DetachedResource& operator=(DetachedResource&& other) = default;
 
  operator UNIQUE() && { return UNIQUE{base::release()}; }
};
 
template<class RESOURCE>
class LockBase : public ResourceOwnerBase<RESOURCE, DefaultDeleter<RESOURCE>>
{
  using base = ResourceOwnerBase<RESOURCE, DefaultDeleter<RESOURCE>>;
 
protected:
  constexpr LockBase(RESOURCE&& resource)
    : base(std::move(resource))
  {
  }
 
public:
  constexpr LockBase() = default;
 
  LockBase(const LockBase& other) = delete;
 
  LockBase(LockBase&& other)
    : base(std::move(other))
  {
    other.get() = nullptr;
  }
 
  constexpr ~LockBase() { SDL_assert_paranoid(!*this); }
 
  LockBase& operator=(LockBase other)
  {
    base::operator=(other);
    other.get() = nullptr;
    return *this;
  }
};
 
template<class T>
std::size_t hash(const SDL::Resource<T>& s) noexcept
{
  return std::hash<T>{}(s.get());
}
 
template<class T>
std::size_t hash(const SDL::ResourcePtrBase<T>& s) noexcept
{
  return hash(s.get());
}
 
struct Hash
{
  template<class T>
  std::size_t operator()(const T& s) const noexcept
  {
    return hash(s);
  }
};
 
} // namespace SDL
 
#endif /* SDL3PP_RESOURCE_H_ */