timer.hpp

// Copyright Take Vos 2020.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt)
 
 
#pragma once
 
#include "hires_utc_clock.hpp"
#include <mutex>
#include <vector>
#include <functional>
#include <tuple>
#include <thread>
 
namespace tt {
 
class timer {
public:
    using duration = hires_utc_clock::duration;
    using time_point = hires_utc_clock::time_point;
 
    using callback_type = std::function<void(time_point,bool)>;
    using callback_ptr_type = std::shared_ptr<callback_type>;
 
    inline static std::unique_ptr<timer> global;
 
public:
    timer(std::string name) noexcept;
    ~timer();
 
    void start() noexcept;
 
    void stop() noexcept;
 
    template<typename Callback>
    [[nodiscard]] std::shared_ptr<callback_type> add_callback(duration interval, Callback callback) noexcept
    {
        ttlet lock = std::scoped_lock(mutex);
        ttlet current_time = hires_utc_clock::now();
 
        auto callback_ptr = std::make_shared<callback_type>(std::forward<Callback>(callback));
 
        callback_list.emplace_back(
            interval,
            calculate_next_wakeup(current_time, interval),
            callback_ptr
        );
 
        if (std::ssize(callback_list) == 1) {
            start_with_lock_held();
        }
 
        return callback_ptr;
    }
 
    void remove_callback(callback_ptr_type const &callback_ptr) noexcept;
 
private:
    struct callback_entry {
        duration interval;
        time_point next_wakeup;
        std::weak_ptr<callback_type> callback_ptr;
 
        callback_entry(duration interval, time_point next_wakeup, std::shared_ptr<callback_type> const &callback_ptr) noexcept :
            interval(interval), next_wakeup(next_wakeup), callback_ptr(callback_ptr)
        {
        }
    };
 
    std::string name;
 
    mutable std::mutex mutex;
    std::thread thread;
    std::vector<callback_entry> callback_list;
    size_t callback_count = 0;
 
    bool stop_thread;
 
    [[nodiscard]] std::pair<std::vector<callback_ptr_type>, timer::time_point>
    find_triggered_callbacks(timer::time_point current_time) noexcept;
 
    void loop() noexcept;
 
    void start_with_lock_held() noexcept;
 
    void stop_with_lock_held() noexcept;
 
    [[nodiscard]] static time_point calculate_next_wakeup(time_point current_time, duration interval) noexcept;
};
 
 
}