SDL3pp_callbackWrapper.h

#ifndef SDL3PP_CALLBACK_WRAPPER_H_
#define SDL3PP_CALLBACK_WRAPPER_H_
 
#include <functional>
#include <map>
#include <memory>
#include <SDL3/SDL_assert.h>
 
namespace SDL {
 
class CallbackHandle
{
  void* id;
 
public:
  constexpr explicit CallbackHandle(void* id = nullptr)
    : id(id)
  {
  }
  constexpr void* get() const { return id; }
 
  constexpr operator bool() const { return id != 0; }
};
 
template<class Result, class... Args>
struct CallbackWrapperBase
{
  using ValueType = std::function<Result(Args...)>;
 
  static const ValueType& Unwrap(void* handle)
  {
    return *static_cast<ValueType*>(handle);
  }
 
  static Result Call(void* handle, Args... args)
  {
    auto& f = Unwrap(handle);
    return f(args...);
  }
 
  static Result CallSuffixed(Args... args, void* handle)
  {
    auto& f = Unwrap(handle);
    return f(args...);
  }
};
 
template<class F>
struct CallbackWrapper;
 
template<class Result, class... Args>
struct CallbackWrapper<std::function<Result(Args...)>>
  : CallbackWrapperBase<Result, Args...>
{
  CallbackWrapper() = delete;
 
  using ValueType = std::function<Result(Args...)>;
 
  static ValueType* Wrap(ValueType&& cb)
  {
    return new ValueType(std::move(cb));
  }
 
  static Result CallOnce(void* handle, Args... args)
  {
    auto f = release(handle);
    return f(args...);
  }
 
  static Result CallOnceSuffixed(Args... args, void* handle)
  {
    auto f = release(handle);
    return f(args...);
  }
 
  static ValueType release(void* handle)
  {
    if (handle == nullptr) return {};
    auto ptr = static_cast<ValueType*>(handle);
    ValueType value{std::move(*ptr)};
    delete ptr;
    return value;
  }
 
  static const ValueType release(CallbackHandle handle)
  {
    return release(handle.get());
  }
};
 
template<class KEY, class VALUE, size_t VARIANT = 0>
struct KeyValueWrapper
{
  static_assert(sizeof(KEY) <= sizeof(void*));
  KeyValueWrapper() = delete;
 
  using KeyType = KEY;
 
  using ValueType = VALUE;
 
  static ValueType* Wrap(KeyType key, ValueType&& value)
  {
    auto lockGuard = lock();
    return &Values().insert_or_assign(key, std::move(value)).first->second;
  }
 
  static bool contains(KeyType handle)
  {
    auto lockGuard = lock();
    return Values().contains(handle);
  }
 
  static const ValueType& at(KeyType handle)
  {
    auto lockGuard = lock();
    return Values().at(handle);
  }
 
  static ValueType release(KeyType key)
  {
    auto lockGuard = lock();
    auto& values = Values();
    auto it = values.find(key);
    if (it == values.end()) return {};
    ValueType value{std::move(it->second)};
    values.erase(it);
    return value;
  }
 
  static bool erase(KeyType key)
  {
    auto lockGuard = lock();
    return Values().erase(key);
  }
 
private:
  static std::map<KeyType, ValueType>& Values()
  {
    static std::map<KeyType, ValueType> values;
    return values;
  }
 
  static std::lock_guard<std::mutex> lock()
  {
    static std::mutex uniqueMutex;
    return std::lock_guard{uniqueMutex};
  }
};
 
template<class KEY, class VALUE, size_t VARIANT = 0>
struct KeyValueCallbackWrapper;
 
template<class KEY, class Result, class... Args, size_t VARIANT>
struct KeyValueCallbackWrapper<KEY, std::function<Result(Args...)>, VARIANT>
  : CallbackWrapperBase<Result, Args...>
  , KeyValueWrapper<KEY, std::function<Result(Args...)>, VARIANT>
{
  KeyValueCallbackWrapper() = delete;
 
  using ValueType = std::function<Result(Args...)>;
};
 
template<class VALUE>
struct UniqueCallbackWrapper;
 
template<class Result, class... Args>
struct UniqueCallbackWrapper<std::function<Result(Args...)>>
  : CallbackWrapperBase<Result, Args...>
{
  UniqueCallbackWrapper() = delete;
 
  using ValueType = std::function<Result(Args...)>;
 
  static ValueType* Wrap(ValueType&& value)
  {
    auto lockGuard = lock();
    auto& v = Value();
    v = std::move(value);
    return &v;
  }
 
  static bool contains(void* handle)
  {
    auto lockGuard = lock();
    auto& v = Value();
    return bool(v) && &v == handle;
  }
 
  static ValueType at(void* handle)
  {
    if (&get() == handle) {
      return CallbackWrapperBase<Result, Args...>::Unwrap(handle);
    }
    return {};
  }
 
  static const ValueType& get()
  {
    auto lockGuard = lock();
    return Value();
  }
 
  static ValueType release()
  {
    auto lockGuard = lock();
    ValueType value{std::move(Value())};
    return value;
  }
 
  static ValueType release(void* handle)
  {
    SDL_assert_paranoid(&get() == handle);
    return release();
  }
 
  static void erase()
  {
    auto lockGuard = lock();
    Value() = {};
  }
 
private:
  static ValueType& Value()
  {
    static ValueType value;
    return value;
  }
 
  static std::lock_guard<std::mutex> lock()
  {
    static std::mutex uniqueMutex;
    return std::lock_guard{uniqueMutex};
  }
};
 
 
} // namespace SDL
 
#endif /* SDL3PP_CALLBACK_WRAPPER_H_ */