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_resource.h"
#include "SDL3pp_strings.h"
#include "SDL3pp_version.h"
 
namespace SDL {

 
// Forward decl
struct PropertiesBase;
 
// Forward decl
struct Properties;

using PropertiesID = SDL_PropertiesID;

using PropertiesRef = ResourceRefT<PropertiesBase>;
 
// 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)>;

struct PropertiesBase : ResourceBaseT<PropertiesID>
{
  using ResourceBaseT::ResourceBaseT;

  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 Properties : PropertiesBase
{
  using PropertiesBase::PropertiesBase;

  constexpr explicit Properties(PropertiesID resource) noexcept
    : PropertiesBase(resource)
  {
  }

  constexpr Properties(Properties&& other) noexcept
    : Properties(other.release())
  {
  }

  Properties();

  ~Properties() { SDL_DestroyProperties(get()); }

  constexpr Properties& operator=(Properties&& other) noexcept
  {
    swap(*this, other);
    return *this;
  }
};

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(); }
 
inline Properties::Properties()
  : Properties(CheckError(SDL_CreateProperties()))
{
}

inline void CopyProperties(PropertiesRef src, PropertiesRef dst)
{
  CheckError(SDL_CopyProperties(src, dst));
}
 
inline void PropertiesBase::Copy(PropertiesRef dst)
{
  SDL::CopyProperties(get(), dst);
}

inline void LockProperties(PropertiesRef props)
{
  CheckError(SDL_LockProperties(props));
}
 
inline PropertiesLock PropertiesBase::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 PropertiesBase::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 PropertiesBase::SetPointerPropertyWithCleanup(
  StringParam name,
  void* value,
  CleanupPropertyCallback cleanup,
  void* userdata)
{
  SDL::SetPointerPropertyWithCleanup(
    get(), std::move(name), value, cleanup, userdata);
}
 
inline void PropertiesBase::SetPointerPropertyWithCleanup(
  StringParam name,
  void* value,
  CleanupPropertyCB cleanup)
{
  SDL::SetPointerPropertyWithCleanup(
    get(), std::move(name), value, std::move(cleanup));
}

inline void SetPointerProperty(PropertiesRef props,
                               StringParam name,
                               void* value)
{
  CheckError(SDL_SetPointerProperty(props, name, value));
}
 
inline void PropertiesBase::SetPointerProperty(StringParam name, void* value)
{
  SDL::SetPointerProperty(get(), std::move(name), value);
}

inline void SetStringProperty(PropertiesRef props,
                              StringParam name,
                              StringParam value)
{
  CheckError(SDL_SetStringProperty(props, name, value));
}
 
inline void PropertiesBase::SetStringProperty(StringParam name,
                                              StringParam value)
{
  SDL::SetStringProperty(get(), std::move(name), std::move(value));
}

inline void SetNumberProperty(PropertiesRef props,
                              StringParam name,
                              Sint64 value)
{
  CheckError(SDL_SetNumberProperty(props, name, value));
}
 
inline void PropertiesBase::SetNumberProperty(StringParam name, Sint64 value)
{
  SDL::SetNumberProperty(get(), std::move(name), value);
}

inline void SetFloatProperty(PropertiesRef props, StringParam name, float value)
{
  CheckError(SDL_SetFloatProperty(props, name, value));
}
 
inline void PropertiesBase::SetFloatProperty(StringParam name, float value)
{
  SDL::SetFloatProperty(get(), std::move(name), value);
}

inline void SetBooleanProperty(PropertiesRef props,
                               StringParam name,
                               bool value)
{
  CheckError(SDL_SetBooleanProperty(props, name, value));
}
 
inline void PropertiesBase::SetBooleanProperty(StringParam name, bool value)
{
  SDL::SetBooleanProperty(get(), std::move(name), value);
}

inline bool HasProperty(PropertiesRef props, StringParam name)
{
  return SDL_HasProperty(props, name);
}
 
inline bool PropertiesBase::HasProperty(StringParam name)
{
  return SDL::HasProperty(get(), std::move(name));
}

inline PropertyType GetPropertyType(PropertiesRef props, StringParam name)
{
  return SDL_GetPropertyType(props, name);
}
 
inline PropertyType PropertiesBase::GetPropertyType(StringParam name)
{
  return SDL::GetPropertyType(get(), std::move(name));
}

inline void* GetPointerProperty(PropertiesRef props,
                                StringParam name,
                                void* default_value)
{
  return SDL_GetPointerProperty(props, name, default_value);
}
 
inline void* PropertiesBase::GetPointerProperty(StringParam name,
                                                void* default_value)
{
  return SDL::GetPointerProperty(get(), 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* PropertiesBase::GetStringProperty(StringParam name,
                                                     StringParam default_value)
{
  return SDL::GetStringProperty(
    get(), 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 PropertiesBase::GetNumberProperty(StringParam name,
                                                Sint64 default_value)
{
  return SDL::GetNumberProperty(get(), std::move(name), default_value);
}

inline float GetFloatProperty(PropertiesRef props,
                              StringParam name,
                              float default_value)
{
  return SDL_GetFloatProperty(props, name, default_value);
}
 
inline float PropertiesBase::GetFloatProperty(StringParam name,
                                              float default_value)
{
  return SDL::GetFloatProperty(get(), std::move(name), default_value);
}

inline bool GetBooleanProperty(PropertiesRef props,
                               StringParam name,
                               bool default_value)
{
  return SDL_GetBooleanProperty(props, name, default_value);
}
 
inline bool PropertiesBase::GetBooleanProperty(StringParam name,
                                               bool default_value)
{
  return SDL::GetBooleanProperty(get(), std::move(name), default_value);
}

inline void ClearProperty(PropertiesRef props, StringParam name)
{
  CheckError(SDL_ClearProperty(props, name));
}
 
inline void PropertiesBase::ClearProperty(StringParam name)
{
  SDL::ClearProperty(get(), 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 PropertiesBase::Enumerate(EnumeratePropertiesCallback callback,
                                      void* userdata)
{
  SDL::EnumerateProperties(get(), callback, userdata);
}
 
inline void PropertiesBase::Enumerate(EnumeratePropertiesCB callback)
{
  SDL::EnumerateProperties(get(), std::move(callback));
}

inline Uint64 CountProperties(PropertiesRef props)
{
  Uint64 count = 0;
  EnumerateProperties(props, [&count](auto, const char*) { count++; });
  return count;
}
 
inline Uint64 PropertiesBase::GetCount() { return SDL::CountProperties(get()); }

inline void DestroyProperties(PropertiesID props)
{
  SDL_DestroyProperties(props);
}
 
inline void PropertiesBase::Destroy() { DestroyProperties(release()); }


 
} // namespace SDL
 
#endif /* SDL3PP_PROPERTIES_H_ */