SDL3pp_properties.h

#ifndef SDL3PP_PROPERTIES_H_
#define SDL3PP_PROPERTIES_H_
 
#include <SDL3/SDL_properties.h>
#include "SDL3pp_callbackWrapper.h"
#include "SDL3pp_error.h"
#include "SDL3pp_strings.h"
#include "SDL3pp_version.h"
 
namespace SDL {
 
// Forward decl
struct Properties;
 
using PropertiesID = SDL_PropertiesID;
 
// Forward decl
struct PropertiesRef;
 
struct PropertiesParam
{
  PropertiesID value; 
 
  constexpr PropertiesParam(PropertiesID value)
    : value(value)
  {
  }
 
  constexpr PropertiesParam(std::nullptr_t = nullptr)
    : value(0)
  {
  }
 
  constexpr explicit operator bool() const { return !!value; }
 
  constexpr auto operator<=>(const PropertiesParam& other) const = default;
 
  constexpr operator PropertiesID() const { return value; }
};
 
// Forward decl
struct PropertiesLock;
 
using PropertyType = SDL_PropertyType;
 
constexpr PropertyType PROPERTY_TYPE_INVALID =
  SDL_PROPERTY_TYPE_INVALID; 
 
constexpr PropertyType PROPERTY_TYPE_POINTER =
  SDL_PROPERTY_TYPE_POINTER; 
 
constexpr PropertyType PROPERTY_TYPE_STRING =
  SDL_PROPERTY_TYPE_STRING; 
 
constexpr PropertyType PROPERTY_TYPE_NUMBER =
  SDL_PROPERTY_TYPE_NUMBER; 
 
constexpr PropertyType PROPERTY_TYPE_FLOAT = SDL_PROPERTY_TYPE_FLOAT; 
 
constexpr PropertyType PROPERTY_TYPE_BOOLEAN =
  SDL_PROPERTY_TYPE_BOOLEAN; 
 
using EnumeratePropertiesCallback = void(SDLCALL*)(void* userdata,
                                                   PropertiesID props,
                                                   const char* name);
 
using EnumeratePropertiesCB =
  std::function<void(PropertiesID props, const char* name)>;
 
using CleanupPropertyCallback = void(SDLCALL*)(void* userdata, void* value);
 
using CleanupPropertyCB = std::function<void(void* value)>;
 
class Properties
{
  PropertiesID m_resource = 0;
 
public:
  constexpr Properties(std::nullptr_t = nullptr) noexcept
    : m_resource(0)
  {
  }
 
  constexpr explicit Properties(const PropertiesID resource) noexcept
    : m_resource(resource)
  {
  }
 
protected:
  constexpr Properties(const Properties& other) noexcept = default;
 
public:
  constexpr Properties(Properties&& other) noexcept
    : Properties(other.release())
  {
  }
 
  constexpr Properties(const PropertiesRef& other) = delete;
 
  constexpr Properties(PropertiesRef&& other) = delete;
 
  static Properties Create();
 
  ~Properties() { SDL_DestroyProperties(m_resource); }
 
  constexpr Properties& operator=(Properties&& other) noexcept
  {
    std::swap(m_resource, other.m_resource);
    return *this;
  }
 
protected:
  constexpr Properties& operator=(const Properties& other) noexcept = default;
 
public:
  constexpr PropertiesID get() const noexcept { return m_resource; }
 
  constexpr PropertiesID release() noexcept
  {
    auto r = m_resource;
    m_resource = 0;
    return r;
  }
 
  constexpr auto operator<=>(const Properties& other) const noexcept = default;
 
  constexpr explicit operator bool() const noexcept { return !!m_resource; }
 
  constexpr operator PropertiesParam() const noexcept { return {m_resource}; }
 
  void Destroy();
 
  void Copy(PropertiesParam dst);
 
  PropertiesLock Lock();
 
  void Unlock(PropertiesLock&& lock);
 
  void SetPointerPropertyWithCleanup(StringParam name,
                                     void* value,
                                     CleanupPropertyCallback cleanup,
                                     void* userdata);
 
  void SetPointerPropertyWithCleanup(StringParam name,
                                     void* value,
                                     CleanupPropertyCB cleanup);
 
  void SetPointerProperty(StringParam name, void* value);
 
  void SetStringProperty(StringParam name, StringParam value);
 
  void SetNumberProperty(StringParam name, Sint64 value);
 
  void SetFloatProperty(StringParam name, float value);
 
  void SetBooleanProperty(StringParam name, bool value);
 
  bool HasProperty(StringParam name);
 
  PropertyType GetPropertyType(StringParam name);
 
  void* GetPointerProperty(StringParam name, void* default_value);
 
  const char* GetStringProperty(StringParam name, StringParam default_value);
 
  Sint64 GetNumberProperty(StringParam name, Sint64 default_value);
 
  float GetFloatProperty(StringParam name, float default_value);
 
  bool GetBooleanProperty(StringParam name, bool default_value);
 
  void ClearProperty(StringParam name);
 
  void Enumerate(EnumeratePropertiesCallback callback, void* userdata);
 
  void Enumerate(EnumeratePropertiesCB callback);
 
  Uint64 GetCount();
};
 
struct PropertiesRef : Properties
{
  using Properties::Properties;
 
  PropertiesRef(PropertiesParam resource) noexcept
    : Properties(resource.value)
  {
  }
 
  PropertiesRef(PropertiesID resource) noexcept
    : Properties(resource)
  {
  }
 
  constexpr PropertiesRef(const PropertiesRef& other) noexcept = default;
 
  ~PropertiesRef() { release(); }
};
 
class PropertiesLock
{
  PropertiesRef m_lock;
 
public:
  PropertiesLock(PropertiesRef resource);
 
  PropertiesLock(const PropertiesLock& other) = delete;
 
  constexpr PropertiesLock(PropertiesLock&& other) noexcept
    : m_lock(other.m_lock)
  {
    other.m_lock = {};
  }
 
  ~PropertiesLock() { reset(); }
 
  PropertiesLock& operator=(const PropertiesLock& other) = delete;
 
  PropertiesLock& operator=(PropertiesLock&& other) noexcept
  {
    std::swap(m_lock, other.m_lock);
    return *this;
  }
 
  constexpr operator bool() const { return bool(m_lock); }
 
  void reset();
 
  PropertiesRef get() { return m_lock; }
 
  void release() { m_lock.release(); }
};
 
#if SDL_VERSION_ATLEAST(3, 4, 0)
 
inline auto PROP_NAME_STRING = SDL_PROP_NAME_STRING;
 
#endif // SDL_VERSION_ATLEAST(3, 4, 0)
 
inline PropertiesRef GetGlobalProperties()
{
  return {CheckError(SDL_GetGlobalProperties())};
}
 
inline Properties CreateProperties()
{
  return Properties(CheckError(SDL_CreateProperties()));
}
 
inline Properties Properties::Create() { return SDL::CreateProperties(); }
 
inline void CopyProperties(PropertiesParam src, PropertiesParam dst)
{
  CheckError(SDL_CopyProperties(src, dst));
}
 
inline void Properties::Copy(PropertiesParam dst)
{
  SDL::CopyProperties(m_resource, dst);
}
 
inline void LockProperties(PropertiesParam props)
{
  CheckError(SDL_LockProperties(props));
}
 
inline PropertiesLock Properties::Lock() { return {PropertiesRef(*this)}; }
 
inline PropertiesLock::PropertiesLock(PropertiesRef resource)
  : m_lock(std::move(resource))
{
  LockProperties(m_lock);
}
 
inline void UnlockProperties(PropertiesParam props)
{
  SDL_UnlockProperties(props);
}
 
inline void Properties::Unlock(PropertiesLock&& lock)
{
  SDL_assert_paranoid(lock.get() == *this);
  lock.reset();
}
 
inline void PropertiesLock::reset()
{
  if (!m_lock) return;
  UnlockProperties(m_lock);
  m_lock = {};
}
 
inline void SetPointerPropertyWithCleanup(PropertiesParam props,
                                          StringParam name,
                                          void* value,
                                          CleanupPropertyCallback cleanup,
                                          void* userdata)
{
  CheckError(
    SDL_SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata));
}
 
inline void SetPointerPropertyWithCleanup(PropertiesParam props,
                                          StringParam name,
                                          void* value,
                                          CleanupPropertyCB cleanup)
{
  using Wrapper = CallbackWrapper<CleanupPropertyCB>;
  SDL_SetPointerPropertyWithCleanup(props,
                                    std::move(name),
                                    value,
                                    &Wrapper::CallOnce,
                                    Wrapper::Wrap(std::move(cleanup)));
}
 
inline void Properties::SetPointerPropertyWithCleanup(
  StringParam name,
  void* value,
  CleanupPropertyCallback cleanup,
  void* userdata)
{
  SDL::SetPointerPropertyWithCleanup(
    m_resource, std::move(name), value, cleanup, userdata);
}
 
inline void Properties::SetPointerPropertyWithCleanup(StringParam name,
                                                      void* value,
                                                      CleanupPropertyCB cleanup)
{
  SDL::SetPointerPropertyWithCleanup(
    m_resource, std::move(name), value, cleanup);
}
 
inline void SetPointerProperty(PropertiesParam props,
                               StringParam name,
                               void* value)
{
  CheckError(SDL_SetPointerProperty(props, name, value));
}
 
inline void Properties::SetPointerProperty(StringParam name, void* value)
{
  SDL::SetPointerProperty(m_resource, std::move(name), value);
}
 
inline void SetStringProperty(PropertiesParam props,
                              StringParam name,
                              StringParam value)
{
  CheckError(SDL_SetStringProperty(props, name, value));
}
 
inline void Properties::SetStringProperty(StringParam name, StringParam value)
{
  SDL::SetStringProperty(m_resource, std::move(name), std::move(value));
}
 
inline void SetNumberProperty(PropertiesParam props,
                              StringParam name,
                              Sint64 value)
{
  CheckError(SDL_SetNumberProperty(props, name, value));
}
 
inline void Properties::SetNumberProperty(StringParam name, Sint64 value)
{
  SDL::SetNumberProperty(m_resource, std::move(name), value);
}
 
inline void SetFloatProperty(PropertiesParam props,
                             StringParam name,
                             float value)
{
  CheckError(SDL_SetFloatProperty(props, name, value));
}
 
inline void Properties::SetFloatProperty(StringParam name, float value)
{
  SDL::SetFloatProperty(m_resource, std::move(name), value);
}
 
inline void SetBooleanProperty(PropertiesParam props,
                               StringParam name,
                               bool value)
{
  CheckError(SDL_SetBooleanProperty(props, name, value));
}
 
inline void Properties::SetBooleanProperty(StringParam name, bool value)
{
  SDL::SetBooleanProperty(m_resource, std::move(name), value);
}
 
inline bool HasProperty(PropertiesParam props, StringParam name)
{
  return SDL_HasProperty(props, name);
}
 
inline bool Properties::HasProperty(StringParam name)
{
  return SDL::HasProperty(m_resource, std::move(name));
}
 
inline PropertyType GetPropertyType(PropertiesParam props, StringParam name)
{
  return SDL_GetPropertyType(props, name);
}
 
inline PropertyType Properties::GetPropertyType(StringParam name)
{
  return SDL::GetPropertyType(m_resource, std::move(name));
}
 
inline void* GetPointerProperty(PropertiesParam props,
                                StringParam name,
                                void* default_value)
{
  return SDL_GetPointerProperty(props, name, default_value);
}
 
inline void* Properties::GetPointerProperty(StringParam name,
                                            void* default_value)
{
  return SDL::GetPointerProperty(m_resource, std::move(name), default_value);
}
 
inline const char* GetStringProperty(PropertiesParam props,
                                     StringParam name,
                                     StringParam default_value)
{
  return SDL_GetStringProperty(props, name, default_value);
}
 
inline const char* Properties::GetStringProperty(StringParam name,
                                                 StringParam default_value)
{
  return SDL::GetStringProperty(
    m_resource, std::move(name), std::move(default_value));
}
 
inline Sint64 GetNumberProperty(PropertiesParam props,
                                StringParam name,
                                Sint64 default_value)
{
  return SDL_GetNumberProperty(props, name, default_value);
}
 
inline Sint64 Properties::GetNumberProperty(StringParam name,
                                            Sint64 default_value)
{
  return SDL::GetNumberProperty(m_resource, std::move(name), default_value);
}
 
inline float GetFloatProperty(PropertiesParam props,
                              StringParam name,
                              float default_value)
{
  return SDL_GetFloatProperty(props, name, default_value);
}
 
inline float Properties::GetFloatProperty(StringParam name, float default_value)
{
  return SDL::GetFloatProperty(m_resource, std::move(name), default_value);
}
 
inline bool GetBooleanProperty(PropertiesParam props,
                               StringParam name,
                               bool default_value)
{
  return SDL_GetBooleanProperty(props, name, default_value);
}
 
inline bool Properties::GetBooleanProperty(StringParam name, bool default_value)
{
  return SDL::GetBooleanProperty(m_resource, std::move(name), default_value);
}
 
inline void ClearProperty(PropertiesParam props, StringParam name)
{
  CheckError(SDL_ClearProperty(props, name));
}
 
inline void Properties::ClearProperty(StringParam name)
{
  SDL::ClearProperty(m_resource, std::move(name));
}
 
inline void EnumerateProperties(PropertiesParam props,
                                EnumeratePropertiesCallback callback,
                                void* userdata)
{
  CheckError(SDL_EnumerateProperties(props, callback, userdata));
}
 
inline void EnumerateProperties(PropertiesParam props,
                                EnumeratePropertiesCB callback)
{
  return EnumerateProperties(
    props,
    [](void* userdata, PropertiesID props, const char* name) {
      auto& f = *static_cast<EnumeratePropertiesCB*>(userdata);
      f(props, name);
    },
    &callback);
}
 
inline void Properties::Enumerate(EnumeratePropertiesCallback callback,
                                  void* userdata)
{
  SDL::EnumerateProperties(m_resource, callback, userdata);
}
 
inline void Properties::Enumerate(EnumeratePropertiesCB callback)
{
  SDL::EnumerateProperties(m_resource, callback);
}
 
inline Uint64 CountProperties(PropertiesParam props)
{
  Uint64 count = 0;
  EnumerateProperties(props, [&](auto, const char*) { count++; });
  return count;
}
 
inline Uint64 Properties::GetCount()
{
  return SDL::CountProperties(m_resource);
}
 
inline void DestroyProperties(PropertiesID props)
{
  SDL_DestroyProperties(props);
}
 
inline void Properties::Destroy() { DestroyProperties(release()); }
 
 
} // namespace SDL
 
#endif /* SDL3PP_PROPERTIES_H_ */