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 SharedObjectBase;
 
// Forward decl
struct SharedObjectRef;
 
// Forward decl
struct SharedObject;
 
struct SharedObjectBase : Resource<SDL_SharedObject*>
{
  using Resource::Resource;
 
  SharedObjectBase(StringParam sofile)
    : Resource(SDL_LoadObject(sofile))
  {
  }
 
  FunctionPointer LoadFunction(StringParam name)
  {
    return SDL_LoadFunction(get(), name);
  }
};
 
struct SharedObjectRef : SharedObjectBase
{
  using SharedObjectBase::SharedObjectBase;
 
  constexpr SharedObjectRef(const SharedObjectRef& other)
    : SharedObjectBase(other.get())
  {
  }
 
  constexpr SharedObjectRef(SharedObjectRef&& other)
    : SharedObjectBase(other.release())
  {
  }
 
  constexpr ~SharedObjectRef() = default;
 
  SharedObjectRef& operator=(SharedObjectRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_SharedObject* newResource = {})
  {
    SDL_UnloadObject(release(newResource));
  }
 
  void Unload() { reset(); }
};
 
struct SharedObject : SharedObjectRef
{
  using SharedObjectRef::SharedObjectRef;
 
  constexpr explicit SharedObject(SDL_SharedObject* resource = {})
    : SharedObjectRef(resource)
  {
  }
 
  constexpr SharedObject(const SharedObject& other) = delete;
 
  constexpr SharedObject(SharedObject&& other) = default;
 
  ~SharedObject() { reset(); }
 
  SharedObject& operator=(SharedObject other)
  {
    reset(other.release());
    return *this;
  }
};
 
 
} // namespace SDL
 
#endif /* SDL3PP_LOADSO_H_ */