From bd3fb642a6c7e1101c5908214a65de9fea977d91 Mon Sep 17 00:00:00 2001
From: AssemblyJohn <ioan.bogdann@gmail.com>
Date: Mon, 21 Oct 2024 12:46:31 +0300
Subject: [PATCH] Updated class for sync mutex usage

Signed-off-by: AssemblyJohn <ioan.bogdann@gmail.com>
---
 include/everest/timer.hpp | 132 +++++++++++++++++++-------------------
 1 file changed, 67 insertions(+), 65 deletions(-)

diff --git a/include/everest/timer.hpp b/include/everest/timer.hpp
index 3affcb8..ce3d48b 100644
--- a/include/everest/timer.hpp
+++ b/include/everest/timer.hpp
@@ -67,7 +67,7 @@ template <typename TimerClock = date::utc_clock, bool ThreadSafe = false> class
         this->callback = callback;
     }
 
-    ~Timer() {
+    ~Timer() {        
         if (this->timer != nullptr) {
             // stop asio timer
             this->timer->cancel();
@@ -85,16 +85,12 @@ template <typename TimerClock = date::utc_clock, bool ThreadSafe = false> class
     /// Executes the given callback at the given timepoint
     template <class Clock, class Duration = typename Clock::duration>
     void at(const std::function<void()>& callback, const std::chrono::time_point<Clock, Duration>& time_point) {
-        if constexpr(ThreadSafe) {
-            OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
-            this->stop();
-            this->callback = callback;
-        } else {
-            this->stop();
-            this->callback = callback;
-        }
+        OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
+
+        this->stop();
+        this->callback = callback;
 
-        this->at(time_point);
+        this->at_internal(time_point);
     }
 
     /// Executes the at the given timepoint
@@ -102,6 +98,65 @@ template <typename TimerClock = date::utc_clock, bool ThreadSafe = false> class
     void at(const std::chrono::time_point<Clock, Duration>& time_point) {
         OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
 
+        at_internal<Clock, Duration>(time_point);
+    }
+
+    /// Execute the given callback peridically from now in the given interval
+    template <class Rep, class Period>
+    void interval(const std::function<void()>& callback, const std::chrono::duration<Rep, Period>& interval) {
+        OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
+
+        this->stop();
+        this->callback = callback;        
+
+        this->interval_internal(interval);
+    }
+
+    /// Execute peridically from now in the given interval
+    template <class Rep, class Period> void interval(const std::chrono::duration<Rep, Period>& interval) {
+        OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
+
+        this->interval_internal(interval);
+    }
+
+    // Execute the given callback once after the given interval
+    template <class Rep, class Period>
+    void timeout(const std::function<void()>& callback, const std::chrono::duration<Rep, Period>& interval) {
+        OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
+        
+        this->stop();
+        this->callback = callback;
+
+        this->timeout_internal(interval);
+    }
+
+    // Execute the given callback once after the given interval
+    template <class Rep, class Period> void timeout(const std::chrono::duration<Rep, Period>& interval) {
+        OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
+
+        this->timeout_internal(interval);
+    }
+
+    /// Stop timer from excuting its callback
+    void stop() {
+        OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
+
+        if (this->timer != nullptr) {
+            // asio based timer
+            this->timer->cancel();
+        }
+
+        running = false;
+    }
+
+    bool is_running() {
+        return running;
+    }
+
+private:
+    /// Executes the at the given timepoint
+    template <class Clock, class Duration = typename Clock::duration>
+    void at_internal(const std::chrono::time_point<Clock, Duration>& time_point) {
         this->stop();
 
         if (this->callback == nullptr) {
@@ -124,27 +179,7 @@ template <typename TimerClock = date::utc_clock, bool ThreadSafe = false> class
         }
     }
 
-    /// Execute the given callback peridically from now in the given interval
-    template <class Rep, class Period>
-    void interval(const std::function<void()>& callback, const std::chrono::duration<Rep, Period>& interval) {
-        if constexpr(ThreadSafe) {
-            OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
-
-            this->stop();
-            this->callback = callback;
-        } else {
-            this->stop();
-            this->callback = callback;
-        }
-        
-
-        this->interval(interval);
-    }
-
-    /// Execute peridically from now in the given interval
-    template <class Rep, class Period> void interval(const std::chrono::duration<Rep, Period>& interval) {
-        OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
-
+    template <class Rep, class Period> void interval_internal(const std::chrono::duration<Rep, Period>& interval) {        
         this->stop();
         this->interval_nanoseconds = interval;
         if (interval_nanoseconds == std::chrono::nanoseconds(0)) {
@@ -176,24 +211,7 @@ template <typename TimerClock = date::utc_clock, bool ThreadSafe = false> class
         }
     }
 
-    // Execute the given callback once after the given interval
-    template <class Rep, class Period>
-    void timeout(const std::function<void()>& callback, const std::chrono::duration<Rep, Period>& interval) {
-        if constexpr (ThreadSafe) {
-            OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
-            this->stop();
-            this->callback = callback;
-        } else {
-            this->stop();
-            this->callback = callback;
-        }
-
-        this->timeout(interval);
-    }
-
-    // Execute the given callback once after the given interval
-    template <class Rep, class Period> void timeout(const std::chrono::duration<Rep, Period>& interval) {
-        OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
+    template <class Rep, class Period> void timeout_internal(const std::chrono::duration<Rep, Period>& interval) {        
         this->stop();
 
         if (this->callback == nullptr) {
@@ -216,22 +234,6 @@ template <typename TimerClock = date::utc_clock, bool ThreadSafe = false> class
             });
         }
     }
-
-    /// Stop timer from excuting its callback
-    void stop() {
-        OptionalGuard<std::unique_lock, std::mutex, ThreadSafe> optional_guard(this->mutex);
-
-        if (this->timer != nullptr) {
-            // asio based timer
-            this->timer->cancel();
-        }
-
-        running = false;
-    }
-
-    bool is_running() {
-        return running;
-    }
 };
 
 using SteadyTimer = Timer<date::utc_clock>;