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;
 
// 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(PropertiesID resource) noexcept
    : m_resource(resource)
  {
  }

  constexpr Properties(const Properties& other) noexcept = delete;

  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;
  }

  Properties& operator=(const Properties& other) = delete;

  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; }

  void Destroy();

  void Copy(PropertiesRef 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;

  constexpr PropertiesRef(PropertiesID resource) noexcept
    : Properties(resource)
  {
  }

  constexpr PropertiesRef(const Properties& resource) noexcept
    : Properties(resource.get())
  {
  }

  constexpr PropertiesRef(Properties&& resource) noexcept
    : Properties(std::move(resource).release())
  {
  }

  constexpr PropertiesRef(const PropertiesRef& other) noexcept
    : Properties(other.get())
  {
  }

  constexpr PropertiesRef(PropertiesRef&& other) noexcept
    : Properties(other.get())
  {
  }

  ~PropertiesRef() { release(); }

  PropertiesRef& operator=(const PropertiesRef& other) noexcept
  {
    release();
    Properties::operator=(Properties(other.get()));
    return *this;
  }

  constexpr operator PropertiesID() const noexcept { return get(); }
};

class PropertiesLock
{
  PropertiesRef m_lock;
 
public:
  PropertiesLock(PropertiesRef resource);

  PropertiesLock(const PropertiesLock& other) = delete;

  PropertiesLock(PropertiesLock&& other) noexcept
    : m_lock(std::move(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 resource() const { return m_lock; }

  void release() { m_lock.release(); }
};
 
#if SDL_VERSION_ATLEAST(3, 4, 0)

constexpr const char* 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(PropertiesRef src, PropertiesRef dst)
{
  CheckError(SDL_CopyProperties(src, dst));
}
 
inline void Properties::Copy(PropertiesRef dst)
{
  SDL::CopyProperties(m_resource, dst);
}

inline void LockProperties(PropertiesRef 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(PropertiesRef props)
{
  SDL_UnlockProperties(props);
}
 
inline void Properties::Unlock(PropertiesLock&& lock)
{
  SDL_assert_paranoid(lock.resource() == *this);
  std::move(lock).reset();
}
 
inline void PropertiesLock::reset()
{
  if (!m_lock) return;
  UnlockProperties(m_lock);
  m_lock = {};
}

inline void SetPointerPropertyWithCleanup(PropertiesRef props,
                                          StringParam name,
                                          void* value,
                                          CleanupPropertyCallback cleanup,
                                          void* userdata)
{
  CheckError(
    SDL_SetPointerPropertyWithCleanup(props, name, value, cleanup, userdata));
}

inline void SetPointerPropertyWithCleanup(PropertiesRef 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, std::move(cleanup));
}

inline void SetPointerProperty(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef 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(PropertiesRef props, StringParam name)
{
  CheckError(SDL_ClearProperty(props, name));
}
 
inline void Properties::ClearProperty(StringParam name)
{
  SDL::ClearProperty(m_resource, std::move(name));
}

inline void EnumerateProperties(PropertiesRef props,
                                EnumeratePropertiesCallback callback,
                                void* userdata)
{
  CheckError(SDL_EnumerateProperties(props, callback, userdata));
}

inline void EnumerateProperties(PropertiesRef props,
                                EnumeratePropertiesCB callback)
{
  return EnumerateProperties(
    props,
    [](void* userdata, PropertiesID props, const char* name) {
      auto& f = *static_cast<const 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, std::move(callback));
}

inline Uint64 CountProperties(PropertiesRef props)
{
  Uint64 count = 0;
  EnumerateProperties(props, [&count](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_ */