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 Properties;
 
using PropertiesShared = ResourceShared<Properties>;
 
using PropertiesWeak = ResourceWeak<Properties>;
 
// Forward decl
struct PropertiesLock;
 
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 PropertiesRef : Resource<SDL_PropertiesID>
{
  using Resource::Resource;
 
  void CopyPropertiesTo(PropertiesRef 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;
 
  static void reset(SDL_PropertiesID resource)
  {
    SDL_DestroyProperties(resource);
  }
};
 
struct Properties : ResourceUnique<PropertiesRef>
{
  using ResourceUnique::ResourceUnique;
 
  static Properties Create()
  {
    return Properties(CheckError(SDL_CreateProperties()));
  }
 
  void Destroy() { reset(); }
  PropertiesShared share();
 
};
 
 
inline PropertiesShared Properties::share()
{
  return PropertiesShared(std::move(*this));
}
 
struct PropertiesUnsafe : ResourceUnsafe<PropertiesRef>
{
  using ResourceUnsafe::ResourceUnsafe;
 
  constexpr explicit PropertiesUnsafe(Properties&& other)
    : PropertiesUnsafe(other.release())
  {
  }
};
 
struct PropertiesLock : LockBase<PropertiesRef>
{
  constexpr PropertiesLock() = default;
 
  constexpr PropertiesLock(PropertiesLock&& other)
    : LockBase(other.release())
  {
  }
 
  PropertiesLock(PropertiesRef props)
    : LockBase<PropertiesRef>(std::move(props))
  {
    CheckError(SDL_LockProperties(get()));
  }
 
  ~PropertiesLock() { Unlock(); }
 
  void Unlock() { SDL_UnlockProperties(release()); }
 
  void reset() { Unlock(); }
};
 
inline PropertiesRef GetGlobalProperties()
{
  return CheckError(SDL_GetGlobalProperties());
}
 
inline PropertiesLock PropertiesRef::Lock() &
{
  CheckError(SDL_LockProperties(get()));
  return PropertiesLock{get()};
}
 
#pragma region impl
 
inline void PropertiesRef::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 PropertiesRef::GetCount() const
{
  Uint64 count = 0;
  Enumerate([&](auto, const char*) { count++; });
  return count;
}
 
#pragma endregion impl
 
} // namespace SDL
 
#endif /* SDL3PP_PROPERTIES_H_ */