Timer.h

#pragma once
 
// Standard.
#include <future>
#include <optional>
#include <chrono>
#include <vector>
 
namespace ne {
    class Node;
 
    class Timer {
        // Only node and game instance can create timers because they have some additional protection
        // code to avoid shooting yourself in the foot (like if you forget to stop the timer).
        // Although only nodes and game instances can create timers this does not mean that the timer
        // depends on their functionality - no, the timer is modular and you can use it outside of these
        // classes if you remove `friend class` and move functions from the `protected` section of
        // the timer to the `public` section.
        friend class Node;
        friend class GameInstance;
 
    public:
        Timer() = delete;
 
        ~Timer();
 
        Timer(const Timer&) = delete;
        Timer& operator=(const Timer&) = delete;
 
        void setCallbackForTimeout(
            long long iTimeToWaitInMs, const std::function<void()>& callback, bool bIsLooping = false);
 
        void start();
 
        void stop(bool bDisableTimer = false);
 
        std::optional<long long> getElapsedTimeInMs();
 
        std::string getName() const;
 
        size_t getStartCount();
 
        bool isRunning();
 
        bool isStopped();
 
        bool isEnabled();
 
    protected:
        Timer(const std::string& sTimerName);
 
        void setCallbackValidator(const std::function<bool(size_t)>& validator);
 
        void setEnable(bool bEnable);
 
    private:
        void timerThread(std::chrono::milliseconds timeToWaitInMs);
 
        std::optional<std::future<void>> timerThreadFuture;
 
        std::optional<std::function<void()>> callbackForTimeout;
 
        std::optional<std::function<bool(size_t)>> callbackValidator;
 
        std::string sTimerName;
 
        std::pair<std::mutex, std::optional<std::chrono::steady_clock::time_point>> mtxTimeWhenStarted;
 
        size_t iStartCount = 0;
 
        std::mutex mtxTerminateTimerThread;
 
        std::condition_variable cvTerminateTimerThread;
 
        std::atomic_flag bIsShuttingDown{};
 
        std::atomic_flag bIsStopRequested{};
 
        std::optional<long long> elapsedTimeWhenStopped;
 
        long long iTimeToWaitInMs = 0;
 
        bool bIsRunning = false;
 
        bool bIsEnabled = true;
 
        bool bIsLooping = false;
    };
} // namespace ne