timer.h

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <chrono>
#include <cstdint>
#include <functional>
#include <memory>
#include <utility>
 
#include <rex/assert.h>
#include <rex/chrono.h>
#include <rex/platform.h>
#include <rex/platform/sync.h>
#include <rex/types.h>
 
namespace rex::platform {
 
class TimerQueue;

struct REX_API TimerQueueWaitItem {
  using clock = std::chrono::steady_clock;

  TimerQueueWaitItem(std::function<void(void*)> callback, void* userdata, TimerQueue* parent_queue,
                     clock::time_point due, clock::duration interval)
      : callback_(std::move(callback)),
        userdata_(userdata),
        parent_queue_(parent_queue),
        due_(due),
        interval_(interval),
        state_(State::kIdle) {}

  void Disarm();
 
  friend TimerQueue;
 
 private:
  enum class State : uint_least8_t { kIdle = 0, kInCallback, kInCallbackSelfDisarmed, kDisarmed };
  static_assert(std::atomic<State>::is_always_lock_free);
 
  std::function<void(void*)> callback_;
  void* userdata_;
  TimerQueue* parent_queue_;
  clock::time_point due_;
  clock::duration interval_;
  std::atomic<State> state_;
};

REX_API std::weak_ptr<TimerQueueWaitItem> QueueTimerOnce(std::function<void(void*)> callback,
                                                         void* userdata,
                                                         TimerQueueWaitItem::clock::time_point due);

REX_API std::weak_ptr<TimerQueueWaitItem> QueueTimerRecurring(
    std::function<void(void*)> callback, void* userdata, TimerQueueWaitItem::clock::time_point due,
    TimerQueueWaitItem::clock::duration interval);

class HighResolutionTimer {
  struct Key {};
 
 public:
  HighResolutionTimer(Key, std::chrono::milliseconds interval, std::function<void()> callback) {
    REX_ASSERT(callback != nullptr);
    wait_item_ = QueueTimerRecurring([callback = std::move(callback)](void*) { callback(); },
                                     nullptr, TimerQueueWaitItem::clock::now(), interval);
  }
 
  ~HighResolutionTimer() {
    if (auto wait_item = wait_item_.lock()) {
      wait_item->Disarm();
    }
  }
 
  static std::unique_ptr<HighResolutionTimer> CreateRepeating(std::chrono::milliseconds period,
                                                              std::function<void()> callback) {
    return std::make_unique<HighResolutionTimer>(Key{}, period, std::move(callback));
  }
 
 private:
  std::weak_ptr<TimerQueueWaitItem> wait_item_;
};

class REX_API Timer : public WaitHandle {
 public:
  using WindowsClock = rex::WinSystemClock;
  using SteadyClock = std::chrono::steady_clock;

  static std::unique_ptr<Timer> CreateManualResetTimer();

  static std::unique_ptr<Timer> CreateSynchronizationTimer();

  virtual bool SetOnceAfter(rex::HundredNanoseconds rel_time,
                            std::function<void()> opt_callback = nullptr) = 0;
  virtual bool SetOnceAt(WindowsClock::time_point due_time,
                         std::function<void()> opt_callback = nullptr) = 0;
  virtual bool SetOnceAt(SteadyClock::time_point due_time,
                         std::function<void()> opt_callback = nullptr) = 0;

  virtual bool SetRepeatingAfter(rex::HundredNanoseconds rel_time, std::chrono::milliseconds period,
                                 std::function<void()> opt_callback = nullptr) = 0;
  virtual bool SetRepeatingAt(WindowsClock::time_point due_time, std::chrono::milliseconds period,
                              std::function<void()> opt_callback = nullptr) = 0;
  virtual bool SetRepeatingAt(SteadyClock::time_point due_time, std::chrono::milliseconds period,
                              std::function<void()> opt_callback = nullptr) = 0;

  virtual bool Cancel() = 0;

  virtual bool Reset() = 0;
};
 
namespace detail {

REX_API void ShutdownTimerQueue();
 
}  // namespace detail
 
}  // namespace rex::platform