added chrono CycleTimer

added scope exit

Author: BestITUserEUW

include/oryx/chrono/cycle_timer.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <chrono>
+#include <optional>
+
+#include <oryx/scope_exit.hpp>
+#include <oryx/chrono/stopwatch.hpp>
+
+namespace oryx::chrono {
+
+template <class Clock = std::chrono::steady_clock>
+    requires std::chrono::is_clock_v<Clock>
+class CycleTimer {
+public:
+    using Duration = std::chrono::milliseconds;
+
+    explicit CycleTimer(Duration target)
+        : target_(target) {}
+
+    auto GetNextSleep() -> std::optional<Duration> {
+        const auto elapsed = sw_.ElapsedMs();
+        if (elapsed >= target_) {
+            return std::nullopt;
+        }
+
+        return Duration(target_ - elapsed);
+    }
+
+    void Reset() { sw_.Reset(); }
+
+    auto target_cycle_time() const -> Duration { return target_; }
+
+    static auto MakeAutoResetGuard(CycleTimer<Clock>& timer) {
+        return ScopeExit{[&timer] { timer.Reset(); }};
+    };
+
+    static auto MakeFrameRateTimer(int target_fps) { return CycleTimer<Clock>{Duration{1000 / target_fps}}; }
+
+private:
+    const Duration target_;
+    details::StopwatchImpl<Clock> sw_{};
+};
+
+}  // namespace oryx::chrono

include/oryx/scope_exit.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <utility>
+
+namespace oryx {
+
+template <class F>
+class ScopeExit {
+public:
+    explicit ScopeExit(F&& fn)
+        : fn_(std::forward<F>(fn)) {}
+
+    ~ScopeExit() {
+        if (is_owner_) {
+            fn_();
+        }
+    }
+
+    void Release() {
+        is_owner_ = false;  // NOTE: Should this return the function object
+    }
+
+    ScopeExit(ScopeExit&& other) = delete;
+    ScopeExit(const ScopeExit&) = delete;
+    auto operator=(const ScopeExit&) -> ScopeExit& = delete;
+
+private:
+    F fn_;
+    bool is_owner_{true};
+};
+
+}  // namespace oryx

tests/chrono_mock_clock.hpp

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <chrono>
+
+namespace oryx {
+
+struct ChronoMockClock {
+    using duration = std::chrono::nanoseconds;
+    using rep = duration::rep;
+    using period = duration::period;
+    using time_point = std::chrono::time_point<std::chrono::steady_clock, duration>;
+
+    static constexpr bool is_steady = true;
+
+    static auto now() noexcept -> time_point { return now_; }
+
+    static time_point now_;
+};
+
+ChronoMockClock::time_point ChronoMockClock::now_ = {};
+
+static_assert(std::chrono::is_clock_v<ChronoMockClock>, "ChronoMockClock does not satisfy chrono clock!");
+
+}  // namespace oryx

tests/cycle_timer.cpp

@@ -1,55 +1,27 @@
 #include "doctest.hpp"
 
 #include <chrono>
-#include <thread>
 
 #include <oryx/chrono/stopwatch.hpp>
 
-using namespace oryx::chrono;
-
-namespace {
-constexpr std::chrono::milliseconds kErrorMargin(100);
-
-struct MockClock {
-    using duration = std::chrono::nanoseconds;
-    using rep = duration::rep;
-    using period = duration::period;
-    using time_point = std::chrono::time_point<std::chrono::steady_clock, duration>;
-
-    static constexpr bool is_steady = true;
-
-    static auto now() noexcept -> time_point { return now_; }
+#include "chrono_mock_clock.hpp"
 
-    static time_point now_;
-};
-
-MockClock::time_point MockClock::now_ = {};
-
-}  // namespace
-
-TEST_CASE("Stopwatch should measure elapsed time") {
-    std::chrono::milliseconds sleep_time(100);
-    Stopwatch sw{};
-    std::this_thread::sleep_for(sleep_time);
-    auto elapsed = sw.ElapsedMs();
-    CHECK_GE(elapsed, sleep_time);
-    CHECK_LT(elapsed, sleep_time + kErrorMargin);
-}
+using namespace oryx::chrono;
 
 TEST_CASE("Reset calls clock now") {
-    details::StopwatchImpl<MockClock> sw{};
-    const auto tp = MockClock::time_point{std::chrono::seconds(5)};
-    MockClock::now_ = tp;
+    details::StopwatchImpl<oryx::ChronoMockClock> sw{};
+    const auto tp = oryx::ChronoMockClock::time_point{std::chrono::seconds(5)};
+    oryx::ChronoMockClock::now_ = tp;
     sw.Reset();
     CHECK_EQ(sw.GetStart(), tp);
 }
 
 TEST_CASE("Elapsed and elapsed ms subtracts now from start") {
-    details::StopwatchImpl<MockClock> sw{MockClock::time_point{std::chrono::seconds(5)}};
-    const auto tp = MockClock::time_point{std::chrono::seconds(10)};
-    MockClock::now_ = tp;
+    details::StopwatchImpl<oryx::ChronoMockClock> sw{oryx::ChronoMockClock::time_point{std::chrono::seconds(5)}};
+    const auto tp = oryx::ChronoMockClock::time_point{std::chrono::seconds(10)};
+    oryx::ChronoMockClock::now_ = tp;
     CHECK_EQ(sw.ElapsedMs(), std::chrono::milliseconds(5000));
 
-    MockClock::now_ = tp;
+    oryx::ChronoMockClock::now_ = tp;
     CHECK_EQ(sw.Elapsed(), std::chrono::nanoseconds(5000000000));
 }