watchdog.hpp

/*
    SPDX-License-Identifier: MIT
    Copyright © 2023-2024 Amebis
*/
 
#pragma once
 
#include "compat.hpp"
#include <chrono>
#include <condition_variable>
#include <functional>
#include <mutex>
#include <thread>
 
namespace stdex
{
    template <class _Clock, class _Duration = typename _Clock::duration>
    class watchdog
    {
    public:
        watchdog(_In_ _Duration timeout, _In_ std::function<void()> callback) :
            m_phase(0),
            m_quit(false),
            m_timeout(timeout),
            m_callback(callback),
            m_thread([](_Inout_ watchdog& wd) { wd.run(); }, std::ref(*this))
        {}
 
        ~watchdog()
        {
            {
                const std::lock_guard<std::mutex> lk(m_mutex);
                m_quit = true;
            }
            m_cv.notify_one();
            if (m_thread.joinable())
                m_thread.join();
        }
 
        void reset()
        {
            {
                const std::lock_guard<std::mutex> lk(m_mutex);
                m_phase++;
            }
            m_cv.notify_one();
        }
 
    protected:
        void run()
        {
            size_t phase;
            for (;;) {
                {
                    std::unique_lock<std::mutex> lk(m_mutex);
                    phase = m_phase;
                    if (m_cv.wait_for(lk, m_timeout, [&] {return m_quit || phase != m_phase; })) {
                        if (m_quit)
                            break;
                        // reset() called in time.
                        continue;
                    }
                }
                // Timeout
                m_callback();
                {
                    // Sleep until next reset().
                    std::unique_lock<std::mutex> lk(m_mutex);
                    m_cv.wait(lk, [&] {return m_quit || phase != m_phase; });
                    if (m_quit)
                        break;
                }
            }
        }
 
    protected:
        size_t m_phase;                    
        bool m_quit;                       
        _Duration m_timeout;               
        std::function<void()> m_callback;  
        std::mutex m_mutex;
        std::condition_variable m_cv;
        std::thread m_thread;
    };
}