SDL3pp_properties.h

#ifndef SDL3PP_PROPERTIES_H_
#define SDL3PP_PROPERTIES_H_
 
#include <optional>
#include <variant>
#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; 
 
// Forward decl
struct PropertyProxy;
 
// Forward decl
struct PropertyMutableProxy;
 
// Forward decl
struct PropertyIterator;

template<class T>
concept PropertyValue =
  std::convertible_to<T, const PropertyProxy&> ||
  std::convertible_to<T, void*> || std::convertible_to<T, StringParam> ||
  std::convertible_to<T, Sint64> || std::convertible_to<T, float>;

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();

  PropertyProxy operator[](StringParam name) const;

  PropertyIterator begin() const;

  std::nullptr_t end() const;

  PropertyMutableProxy operator[](StringParam name);

  void Copy(PropertiesRef dst);

  PropertiesLock Lock();

  void Unlock(PropertiesLock&& lock);

  template<PropertyValue V>
  void Set(StringParam name, V&& value);

  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) const;

  PropertyType GetPropertyType(StringParam name) const;

  PropertyProxy Get(StringParam name) const;

  void* GetPointerProperty(StringParam name,
                           void* default_value = nullptr) const;

  const char* GetStringProperty(StringParam name,
                                StringParam default_value = "") const;

  Sint64 GetNumberProperty(StringParam name, Sint64 default_value = 0) const;

  float GetFloatProperty(StringParam name, float default_value = 0) const;

  bool GetBooleanProperty(StringParam name, bool default_value = false) const;

  void ClearProperty(StringParam name);

  void Enumerate(EnumeratePropertiesCallback callback, void* userdata) const;

  void Enumerate(EnumeratePropertiesCB callback) const;

  Uint64 GetCount() const;
};

struct Properties : PropertiesBase
{
  using PropertiesBase::PropertiesBase;

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

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

  Properties();

  Properties(
    std::initializer_list<
      std::pair<StringParam,
                std::variant<StringParam, void*, Sint64, float, bool>>> entries)
    : Properties()
  {
    for (auto& [name, value] : entries) {
      std::visit(
        [this, &name](auto& arg) {
          if constexpr (std::is_convertible_v<decltype(arg),
                                              const StringParam&>) {
            Set(name.c_str(), arg.c_str());
          } else {
            Set(name.c_str(), arg);
          }
        },
        value);
    }
  }

  ~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(); }
};

class PropertyProxy
{
public:
  PropertyProxy(PropertiesRef props, StringParam name)
    : m_props(props)
    , m_name(name)
  {
  }

  bool IsValid() const { return m_props.HasProperty(m_name.c_str()); }

  PropertyType GetType() const
  {
    return m_props.GetPropertyType(m_name.c_str());
  }

  const char* GetName() const { return m_name; }

  PropertiesRef GetProperties() const { return m_props; }

  template<PropertyType T>
  auto As() const;

  template<PropertyValue T>
  auto As() const;

  operator void*() const { return m_props.GetPointerProperty(m_name); }

  operator const char*() const { return m_props.GetStringProperty(m_name); }

  template<std::integral T>
  operator T() const
  {
    return T(m_props.GetNumberProperty(m_name));
  }

  template<std::floating_point T>
  operator T() const
  {
    return T(m_props.GetFloatProperty(m_name));
  }

  operator bool() const { return m_props.GetBooleanProperty(m_name); }

  template<class T>
  auto visit(T visitor) const
  {
    switch (GetType()) {
    case SDL_PROPERTY_TYPE_POINTER: return visitor((void*)(*this));
    case SDL_PROPERTY_TYPE_STRING: return visitor((const char*)(*this));
    case SDL_PROPERTY_TYPE_NUMBER: return visitor(Sint64(*this));
    case SDL_PROPERTY_TYPE_FLOAT: return visitor(float(*this));
    case SDL_PROPERTY_TYPE_BOOLEAN: return visitor(bool(*this));
    default: return visitor(std::nullopt);
    }
  }
 
private:
  PropertiesRef m_props;
 
  StringParam m_name;
 
  friend class PropertyIterator;
};

struct PropertyMutableProxy : PropertyProxy
{
  using PropertyProxy::PropertyProxy;

  template<PropertyValue V>
  PropertyMutableProxy& operator=(V&& value)
  {
    GetProperties().Set(GetName(), std::forward<V>(value));
    return *this;
  }
};

class PropertyIterator
{
public:
  constexpr PropertyIterator() = default;

  PropertyIterator(PropertiesRef props, size_t index = 0)
    : m_index(index)
  {
    props.Enumerate(
      [this](auto, const char* key) { m_keys.emplace_back(key); });
    if (m_index < m_keys.size()) m_proxy = {props, m_keys[m_index]};
  }
 
  ~PropertyIterator() = default;

  constexpr bool operator==(std::nullptr_t) const
  {
    return m_index >= m_keys.size();
  }

  constexpr bool operator==(const PropertyIterator& other) const
  {
    return m_index == other.m_index;
  }

  const PropertyProxy& operator*() const { return m_proxy; }

  const PropertyProxy* operator->() const { return &m_proxy; }

  PropertyIterator& operator++()
  {
    ++m_index;
    update();
    return *this;
  }

  PropertyIterator operator++(int)
  {
    auto copy = *this;
    ++(*this);
    return copy;
  }

  PropertyIterator& operator--()
  {
    --m_index;
    update();
    return *this;
  }

  PropertyIterator operator--(int)
  {
    auto copy = *this;
    --(*this);
    return copy;
  }
 
private:
  std::vector<std::string> m_keys;
  PropertyProxy m_proxy{{}, ""};
  size_t m_index = 0;
 
  void update()
  {
    if (m_index < m_keys.size()) m_proxy.m_name = m_keys[m_index];
  }
};
 
#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(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 PropertyProxy PropertiesBase::operator[](StringParam name) const
{
  return {*this, name};
}
 
inline PropertyMutableProxy PropertiesBase::operator[](StringParam name)
{
  return {*this, name};
}
 
inline PropertyIterator PropertiesBase::begin() const { return {*this}; }
 
inline std::nullptr_t PropertiesBase::end() const { return nullptr; }

template<PropertyValue V>
inline void SetProperty(PropertiesRef props, StringParam name, V value)
{
  struct
  {
    PropertiesRef props;
    StringParam name;
 
    void operator()(std::nullopt_t) { props.ClearProperty(name); }
    void operator()(void* v) { props.SetPointerProperty(name, v); }
    void operator()(const char* v) { props.SetStringProperty(name, v); }
    void operator()(Sint64 v) { props.SetNumberProperty(name, v); }
    void operator()(float v) { props.SetFloatProperty(name, v); }
    void operator()(bool v) { props.SetBooleanProperty(name, v); }
    void operator()(const PropertyProxy& prop) { prop.visit(*this); }
 
  } visitor(props, name);
  if constexpr (std::is_same_v<V, bool>) {
    visitor(value);
  } else if constexpr (std::integral<V>) {
    visitor(Sint64(value));
  } else if constexpr (std::floating_point<V>) {
    visitor(float(value));
  } else if constexpr (std::convertible_to<V, StringParam>) {
    visitor(StringParam(value));
  } else {
    visitor(value);
  }
}
 
template<PropertyValue V>
inline void PropertiesBase::Set(StringParam name, V&& value)
{
  SDL::SetProperty(get(), name, std::forward<V>(value));
}

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, name, value, &Wrapper::CallOnce, Wrapper::Wrap(std::move(cleanup)));
}
 
inline void PropertiesBase::SetPointerPropertyWithCleanup(
  StringParam name,
  void* value,
  CleanupPropertyCallback cleanup,
  void* userdata)
{
  SDL::SetPointerPropertyWithCleanup(get(), name, value, cleanup, userdata);
}
 
inline void PropertiesBase::SetPointerPropertyWithCleanup(
  StringParam name,
  void* value,
  CleanupPropertyCB cleanup)
{
  SDL::SetPointerPropertyWithCleanup(get(), 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(), 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(), name, 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(), 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(), 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(), name, value);
}

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

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

inline PropertyProxy GetProperty(PropertiesRef props, StringParam name)
{
  return {props, name};
}
 
inline PropertyProxy PropertiesBase::Get(StringParam name) const
{
  return SDL::GetProperty(get(), name);
}

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

inline Sint64 GetNumberProperty(PropertiesRef props,
                                StringParam name,
                                Sint64 default_value = 0)
{
  return SDL_GetNumberProperty(props, name, default_value);
}
 
inline Sint64 PropertiesBase::GetNumberProperty(StringParam name,
                                                Sint64 default_value) const
{
  return SDL::GetNumberProperty(get(), name, default_value);
}

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

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

template<PropertyType T>
auto prop_cast(PropertiesRef props, StringParam name)
{
  if constexpr (T == PROPERTY_TYPE_POINTER) {
    return GetPointerProperty(props, name);
  } else if constexpr (T == PROPERTY_TYPE_STRING) {
    return GetStringProperty(props, name);
  } else if constexpr (T == PROPERTY_TYPE_NUMBER) {
    return GetNumberProperty(props, name);
  } else if constexpr (T == PROPERTY_TYPE_FLOAT) {
    return GetFloatProperty(props, name);
  } else {
    static_assert(T == PROPERTY_TYPE_BOOLEAN, "Invalid Property type");
    return GetBooleanProperty(props, name);
  }
}

template<PropertyValue T>
auto prop_cast(PropertiesRef props, StringParam name)
{
  if constexpr (std::is_same_v<T, bool>) {
    return GetBooleanProperty(props, name);
  } else if constexpr (std::integral<T>) {
    return static_cast<T>(GetNumberProperty(props, name));
  } else if constexpr (std::floating_point<T>) {
    return static_cast<T>(GetFloatProperty(props, name));
  } else if constexpr (std::is_same_v<T, char*>) {
    return GetStringProperty(props, name);
  } else if constexpr (std::convertible_to<T, StringParam>) {
    return static_cast<T>(GetStringProperty(props, name));
  } else if constexpr (std::convertible_to<T, void*>) {
    return static_cast<T>(GetPointerProperty(props, name));
  } else {
    static_assert(std::convertible_to<PropertyProxy, T>, "invalid type");
    return static_cast<T>(PropertyProxy(props, name));
  }
}

template<PropertyType T>
auto prop_cast(PropertyProxy prop)
{
  return prop_cast<T>(prop.GetProperties(), prop.GetName());
}

template<PropertyValue T>
auto prop_cast(PropertyProxy prop)
{
  return prop_cast<T>(prop.GetProperties(), prop.GetName());
}

template<PropertyType T>
auto PropertyProxy::As() const
{
  return prop_cast<T>(m_props, m_name);
}

template<PropertyValue T>
auto PropertyProxy::As() const
{
  return prop_cast<T>(m_props, m_name);
}

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

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


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