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 "unfair_mutex.hpp"
#include "subsystem.hpp"
#include "chrono.hpp"
#include <mutex>
#include <vector>
#include <functional>
#include <tuple>
#include <thread>
 
namespace tt {
 
class timer {
public:
    using callback_type = std::function<void(utc_nanoseconds,bool)>;
    using callback_ptr_type = std::shared_ptr<callback_type>;
 
    timer(std::string name) noexcept;
    ~timer();
 
    void start() noexcept;
 
    void stop() noexcept;
 
    template<typename Callback> requires(std::is_invocable_v<Callback>)
    [[nodiscard]] std::shared_ptr<callback_type> add_callback(std::chrono::nanoseconds interval, Callback callback, bool immediate=false) noexcept
    {
        ttlet current_time = utc_nanoseconds(std::chrono::utc_clock::now());
        auto callback_ptr = std::make_shared<callback_type>(std::forward<Callback>(callback));
 
        {
            ttlet lock = std::scoped_lock(mutex);
 
            callback_list.emplace_back(
                interval,
                calculate_next_wakeup(current_time, interval),
                callback_ptr
            );
 
            if (std::ssize(callback_list) == 1) {
                start_with_lock_held();
            }
        }
 
        if (immediate) {
            (*callback_ptr)(current_time, false);
        }
        return callback_ptr;
    }
 
    void remove_callback(callback_ptr_type const &callback_ptr) noexcept;
 
    static timer &global() noexcept
    {
        return *start_subsystem_or_terminate(_global, nullptr, subsystem_init, subsystem_deinit);
    }
 
private:
    struct callback_entry {
        std::chrono::nanoseconds interval;
        utc_nanoseconds next_wakeup;
        std::weak_ptr<callback_type> callback_ptr;
 
        callback_entry(
            std::chrono::nanoseconds interval,
            utc_nanoseconds next_wakeup,
            std::shared_ptr<callback_type> const &callback_ptr) noexcept :
            interval(interval), next_wakeup(next_wakeup), callback_ptr(callback_ptr)
        {
        }
    };
 
    static inline std::atomic<timer *> _global;
 
    std::string name;
 
    mutable unfair_mutex mutex;
    std::jthread thread;
    std::vector<callback_entry> callback_list;
    size_t callback_count = 0;
 
    [[nodiscard]] std::pair<std::vector<callback_ptr_type>, utc_nanoseconds>
    find_triggered_callbacks(utc_nanoseconds current_time) noexcept;
 
    void loop(std::stop_token stop_token) noexcept;
 
    void start_with_lock_held() noexcept;
 
    void stop_with_lock_held() noexcept;
 
    [[nodiscard]] static utc_nanoseconds calculate_next_wakeup(utc_nanoseconds current_time, std::chrono::nanoseconds interval) noexcept;
 
    [[nodiscard]] static timer *subsystem_init() noexcept;
    static void subsystem_deinit() noexcept;
};
 
 
}