SDL3pp_loadso.h

#ifndef SDL3PP_LOADSO_H_
#define SDL3PP_LOADSO_H_
 
#include <SDL3/SDL_loadso.h>
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
// Forward decl
struct SharedObject;
 
using SharedObjectRaw = SDL_SharedObject*;
 
// Forward decl
struct SharedObjectRef;
 
struct SharedObjectParam
{
  SharedObjectRaw value; 
 
  constexpr SharedObjectParam(SharedObjectRaw value)
    : value(value)
  {
  }
 
  constexpr SharedObjectParam(std::nullptr_t = nullptr)
    : value(nullptr)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const SharedObjectParam& other) const = default;
 
  constexpr operator SharedObjectRaw() const { return value; }
};
 
class SharedObject
{
  SharedObjectRaw m_resource = nullptr;
 
public:
  constexpr SharedObject(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit SharedObject(const SharedObjectRaw resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr SharedObject(const SharedObject& other) noexcept = default;
 
public:
  constexpr SharedObject(SharedObject&& other) noexcept
    : SharedObject(other.release())
  {
  }
 
  constexpr SharedObject(const SharedObjectRef& other) = delete;
 
  constexpr SharedObject(SharedObjectRef&& other) = delete;
 
  SharedObject(StringParam sofile)
    : m_resource(SDL_LoadObject(sofile))
  {
  }
 
  ~SharedObject() { SDL_UnloadObject(m_resource); }
 
  constexpr SharedObject& operator=(SharedObject&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr SharedObject& operator=(const SharedObject& other) noexcept =
    default;
 
public:
  constexpr SharedObjectRaw get() const noexcept { return m_resource; }
 
  constexpr SharedObjectRaw release() noexcept
  {
    auto r = m_resource;
    m_resource = nullptr;
    return r;
  }
 
  constexpr auto operator<=>(const SharedObject& other) const noexcept =
    default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator SharedObjectParam() const noexcept { return {m_resource}; }
 
  void Unload();
 
  FunctionPointer LoadFunction(StringParam name);
};
 
struct SharedObjectRef : SharedObject
{
  using SharedObject::SharedObject;
 
  SharedObjectRef(SharedObjectParam resource) noexcept
    : SharedObject(resource.value)
  {
  }
 
  SharedObjectRef(SharedObjectRaw resource) noexcept
    : SharedObject(resource)
  {
  }
 
  constexpr SharedObjectRef(const SharedObjectRef& other) noexcept = default;
 
  ~SharedObjectRef() { release(); }
};
 
inline SharedObject LoadObject(StringParam sofile)
{
  return SharedObject(std::move(sofile));
}
 
inline FunctionPointer LoadFunction(SharedObjectParam handle, StringParam name)
{
  return SDL_LoadFunction(handle, name);
}
 
inline FunctionPointer SharedObject::LoadFunction(StringParam name)
{
  return SDL::LoadFunction(m_resource, std::move(name));
}
 
inline void UnloadObject(SharedObjectRaw handle) { SDL_UnloadObject(handle); }
 
inline void SharedObject::Unload() { UnloadObject(release()); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_LOADSO_H_ */