SDL3pp_properties.h

#ifndef SDL3PP_PROPERTIES_H_
#define SDL3PP_PROPERTIES_H_
 
#include <SDL3/SDL_properties.h>
#include "SDL3pp_error.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
using PropertyType = SDL_PropertyType;
 
using CleanupPropertyCallback = SDL_CleanupPropertyCallback;
 
using CleanupPropertyCB = std::function<void(void*)>;
 
 
using EnumeratePropertiesCallback = SDL_EnumeratePropertiesCallback;
 
// Forward decl
struct PropertiesRef;
 
using EnumeratePropertiesCB =
  std::function<void(PropertiesRef props, const char* name)>;
 
 
// Forward decl
struct PropertiesLock;
 
// Forward decl
struct PropertiesBase;
 
// Forward decl
struct Properties;
 
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; 
 
struct PropertiesBase : Resource<SDL_PropertiesID>
{
  using Resource::Resource;
 
  void CopyPropertiesTo(PropertiesBase& dst) const
  {
    CheckError(SDL_CopyProperties(get(), dst.get()));
  }
 
  PropertiesLock Lock() &;
 
  void SetPointerWithCleanup(StringParam name,
                             void* value,
                             CleanupPropertyCB cleanup)
  {
    using Wrapper = CallbackWrapper<CleanupPropertyCB>;
    SetPointerWithCleanup(std::move(name),
                          value,
                          &Wrapper::CallOnce,
                          Wrapper::Wrap(std::move(cleanup)));
  }
 
  void SetPointerWithCleanup(StringParam name,
                             void* value,
                             CleanupPropertyCallback cleanup,
                             void* userdata)
  {
    CheckError(
      SDL_SetPointerPropertyWithCleanup(get(), name, value, cleanup, userdata));
  }
 
  void SetPointer(StringParam name, void* value)
  {
    CheckError(SDL_SetPointerProperty(get(), name, value));
  }
 
  void SetString(StringParam name, StringParam value)
  {
    CheckError(SDL_SetStringProperty(get(), name, value));
  }
 
  void SetNumber(StringParam name, Sint64 value)
  {
    CheckError(SDL_SetNumberProperty(get(), name, value));
  }
 
  void SetFloat(StringParam name, float value)
  {
    CheckError(SDL_SetFloatProperty(get(), name, value));
  }
 
  void SetBoolean(StringParam name, bool value)
  {
    CheckError(SDL_SetBooleanProperty(get(), name, value));
  }
 
  bool Has(StringParam name) const { return SDL_HasProperty(get(), name); }
 
  PropertyType GetType(StringParam name) const
  {
    return SDL_GetPropertyType(get(), name);
  }
 
  void* GetPointer(StringParam name, void* default_value) const
  {
    return SDL_GetPointerProperty(get(), name, default_value);
  }
 
  const char* GetString(StringParam name, StringParam default_value) const
  {
    return SDL_GetStringProperty(get(), name, default_value);
  }
 
  Sint64 GetNumber(StringParam name, Sint64 default_value) const
  {
    return SDL_GetNumberProperty(get(), name, default_value);
  }
 
  float GetFloat(StringParam name, float default_value) const
  {
    return SDL_GetFloatProperty(get(), name, default_value);
  }
 
  bool GetBoolean(StringParam name, bool default_value) const
  {
    return SDL_GetBooleanProperty(get(), name, default_value);
  }
 
  void Clear(StringParam name) { CheckError(SDL_ClearProperty(get(), name)); }
 
  template<std::output_iterator<const char*> IT>
  void Enumerate(IT outputIter) const
  {
    Enumerate(
      [&outputIter](auto props, const char name) { *outputIter++ = name; });
  }
 
  void Enumerate(EnumeratePropertiesCB callback) const;
 
  void Enumerate(EnumeratePropertiesCallback callback, void* userdata) const
  {
    CheckError(SDL_EnumerateProperties(get(), callback, userdata));
  }
 
  Uint64 GetCount() const;
};
 
struct PropertiesRef : PropertiesBase
{
  using PropertiesBase::PropertiesBase;
 
  constexpr PropertiesRef(const PropertiesRef& other)
    : PropertiesBase(other.get())
  {
  }
 
  constexpr PropertiesRef(PropertiesRef&& other)
    : PropertiesBase(other.release())
  {
  }
 
  constexpr ~PropertiesRef() = default;
 
  PropertiesRef& operator=(PropertiesRef other)
  {
    release(other.release());
    return *this;
  }
 
  void reset(SDL_PropertiesID newResource = {})
  {
    SDL_DestroyProperties(release(newResource));
  }
};
 
struct Properties : PropertiesRef
{
  using PropertiesRef::PropertiesRef;
 
  constexpr explicit Properties(SDL_PropertiesID resource = {})
    : PropertiesRef(resource)
  {
  }
 
  constexpr Properties(const Properties& other) = delete;
 
  constexpr Properties(Properties&& other) = default;
 
  Properties()
    : Properties(CheckError(SDL_CreateProperties()))
  {
  }
 
  ~Properties() { reset(); }
 
  Properties& operator=(Properties other)
  {
    reset(other.release());
    return *this;
  }
};
 
class PropertiesLock
{
  PropertiesRef properties;
 
  explicit PropertiesLock(PropertiesRef properties)
    : properties(properties)
  {
  }
 
public:
  constexpr PropertiesLock() = default;
 
  PropertiesLock(const PropertiesLock& other) = delete;
 
  PropertiesLock(PropertiesLock&& other)
    : properties(std::move(other.properties))
  {
  }
 
  ~PropertiesLock() { Unlock(); }
 
  PropertiesLock& operator=(PropertiesLock other)
  {
    std::swap(properties, other.properties);
    return *this;
  }
 
  constexpr operator bool() const { return bool(properties); }
 
  void Unlock() { SDL_UnlockProperties(properties.release()); }
 
  friend class PropertiesBase;
};
 
inline PropertiesRef GetGlobalProperties()
{
  return CheckError(SDL_GetGlobalProperties());
}
 
inline PropertiesLock PropertiesBase::Lock() &
{
  CheckError(SDL_LockProperties(get()));
  return PropertiesLock{get()};
}
 
inline Properties CreateProperties()
{
  return Properties{SDL_CreateProperties()};
}
 
#pragma region impl
 
inline void PropertiesBase::Enumerate(EnumeratePropertiesCB callback) const
{
  return Enumerate(
    [](void* userdata, SDL_PropertiesID props, const char* name) {
      auto& f = *static_cast<EnumeratePropertiesCB*>(userdata);
      f(props, name);
    },
    &callback);
}
 
inline Uint64 PropertiesBase::GetCount() const
{
  Uint64 count = 0;
  Enumerate([&](auto, const char*) { count++; });
  return count;
}
 
#pragma endregion impl
 
} // namespace SDL
 
#endif /* SDL3PP_PROPERTIES_H_ */