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 {
 
template<class F>
struct CallbackWrapper;
 
template<class Result, class... Args>
struct CallbackWrapper<std::function<Result(Args...)>>
{
  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...);
  }
 
  CallbackWrapper() = delete;
 
  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;
  }
};
 
template<class SELF, class R, class... PARAMS>
struct LightweightCallbackT
{
  R (*wrapper)(void*, PARAMS...);
 
  void* data;
 
  template<class F>
  LightweightCallbackT(const F& func)
  {
    static_assert(sizeof(func) <= sizeof(data), "Function must fit size_t");
    union PunAux
    {
      void* ptr;
      F func;
    };
    wrapper = [](void* userdata, PARAMS... params) {
      PunAux aux{.ptr = userdata};
      return SELF::doCall(aux.func, params...);
    };
    PunAux aux{.func = func};
    data = aux.ptr;
  }
};
 
template<class SELF, class R, class... PARAMS>
struct LightweightTrailingCallbackT
{
  R (*wrapper)(PARAMS..., void*);
 
  void* data;
 
  template<class F>
  LightweightTrailingCallbackT(const F& func)
  {
    static_assert(sizeof(func) <= sizeof(data), "Function must fit size_t");
    union PunAux
    {
      void* ptr;
      F func;
    };
    wrapper = [](PARAMS... params, void* userdata) {
      PunAux aux{.ptr = userdata};
      return SELF::doCall(aux.func, params...);
    };
    PunAux aux{.func = func};
    data = aux.ptr;
  }
};
 
template<class F>
struct MakeFrontCallback;
 
template<class R, class... PARAMS>
struct MakeFrontCallback<R(PARAMS...)>
  : LightweightCallbackT<MakeFrontCallback<R(PARAMS...)>, R, PARAMS...>
{
  template<std::invocable<PARAMS...> F>
  MakeFrontCallback(const F& func)
    : LightweightCallbackT<MakeFrontCallback<R(PARAMS...)>, R, PARAMS...>(func)
  {
  }
 
  template<std::invocable<PARAMS...> F>
  static R doCall(F& func, PARAMS... params)
  {
    return func(params...);
  }
};
 
template<class F>
struct MakeBackCallback;
 
template<class R, class... PARAMS>
struct MakeBackCallback<R(PARAMS...)>
  : LightweightTrailingCallbackT<MakeBackCallback<R(PARAMS...)>, R, PARAMS...>
{
  template<std::invocable<PARAMS...> F>
  MakeBackCallback(const F& func)
    : LightweightTrailingCallbackT<MakeBackCallback<R(PARAMS...)>,
                                   R,
                                   PARAMS...>(func)
  {
  }
 
  template<std::invocable<PARAMS...> F>
  static R doCall(const F& func, PARAMS... params)
  {
    return func(params...);
  }
};
 
 
} // namespace SDL
 
#endif /* SDL3PP_CALLBACK_WRAPPER_H_ */