SDL3pp_timer.h

#ifndef SDL3PP_TIMER_H_
#define SDL3PP_TIMER_H_
 
#include <chrono>
#include <functional>
#include <SDL3/SDL_timer.h>
#include "SDL3pp_callbackWrapper.h"
#include "SDL3pp_error.h"
#include "SDL3pp_stdinc.h"
 
namespace SDL {
 
constexpr Time Time::FromPosix(Sint64 time)
{
  return Time::FromNS(SDL_SECONDS_TO_NS(time));
}
 
constexpr Sint64 Time::ToPosix() const
{
  return SDL_NS_TO_SECONDS(m_value.count());
}
 
inline std::chrono::nanoseconds GetTicks()
{
  return std::chrono::nanoseconds{SDL_GetTicksNS()};
}
 
inline Uint64 GetPerformanceCounter() { return SDL_GetPerformanceCounter(); }
 
inline Uint64 GetPerformanceFrequency()
{
  return SDL_GetPerformanceFrequency();
}
 
inline void Delay(std::chrono::nanoseconds duration)
{
  SDL_DelayNS(duration.count());
}
 
inline void DelayPrecise(std::chrono::nanoseconds duration)
{
  SDL_DelayPrecise(duration.count());
}
using TimerID = SDL_TimerID;
 
using TimerCallback = SDL_NSTimerCallback;
 
using TimerCB =
  std::function<std::chrono::nanoseconds(TimerID, std::chrono::nanoseconds)>;
 
inline TimerID AddTimer(std::chrono::nanoseconds interval,
                        TimerCallback callback,
                        void* userdata)
{
  return CheckError(SDL_AddTimerNS(interval.count(), callback, userdata));
}
 
inline TimerID AddTimer(std::chrono::nanoseconds interval, TimerCB callback)
{
  using Wrapper = CallbackWrapper<TimerCB>;
  using Store = KeyValueWrapper<TimerID, TimerCB*>;
 
  auto cb = Wrapper::Wrap(std::move(callback));
 
  if (TimerID id = SDL_AddTimerNS(
        interval.count(),
        [](void* userdata, TimerID timerID, Uint64 interval) -> Uint64 {
          auto& f = *static_cast<TimerCB*>(userdata);
          auto next = f(timerID, std::chrono::nanoseconds(interval)).count();
          // If ask to removal, then remove it
          if (next == 0) delete Store::release(timerID);
          return next;
        },
        cb)) {
    Store::Wrap(id, std::move(cb));
    return id;
  }
  delete cb;
  throw Error{};
}
 
inline void RemoveTimer(TimerID id)
{
  delete KeyValueWrapper<TimerID, TimerCB*>::release(id);
  CheckError(SDL_RemoveTimer(id));
}
 
 
} // namespace SDL
 
#endif /* SDL3PP_TIMER_H_ */