function_timer.hpp

// Copyright Take Vos 2022.
// 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 "../utility/utility.hpp"
#include "../time/time.hpp"
#include "../concurrency/concurrency.hpp"
#include "../macros.hpp"
#include <vector>
#include <algorithm>
#include <chrono>
#include <functional>
 
hi_export_module(hikogui.dispatch.function_timer);
 
hi_export namespace hi::inline v1 {
 
class function_timer {
public:
    constexpr function_timer() noexcept = default;
 
    [[nodiscard]] constexpr bool empty() const noexcept
    {
        return _functions.empty();
    }
 
    template<forward_of<void()> Func>
    [[nodiscard]] std::pair<callback<void()>, bool> delay_function(utc_nanoseconds time_point, Func &&func) noexcept
    {
        auto const it = std::lower_bound(_functions.begin(), _functions.end(), time_point, [](auto const& x, auto const& time_point) {
            return x.time_point > time_point;
        });
 
        auto const next_to_call = it == _functions.end();
 
        auto token = callback<void()>{std::forward<Func>(func)};
        _functions.emplace(it, time_point, std::chrono::nanoseconds::max(), token);
        return {std::move(token), next_to_call};
    }
 
    template<forward_of<void()> Func>
    [[nodiscard]] std::pair<callback<void()>, bool> repeat_function(
        std::chrono::nanoseconds period,
        utc_nanoseconds time_point,
        Func &&func) noexcept
    {
        auto it = std::lower_bound(_functions.begin(), _functions.end(), time_point, [](auto const& x, auto const& time_point) {
            return x.time_point > time_point;
        });
 
        auto token = callback<void()>{std::forward<Func>(func)};
        it = _functions.emplace(it, time_point, period, token);
        return {std::move(token), it + 1 == _functions.end()};
    }
 
    template<forward_of<void()> Func>
    [[nodiscard]] std::pair<callback<void()>, bool> repeat_function(std::chrono::nanoseconds period, Func &&func) noexcept
    {
        return repeat_function(period, std::chrono::utc_clock::now(), std::forward<Func>(func));
    }
 
    [[nodiscard]] utc_nanoseconds current_deadline() const noexcept
    {
        if (_functions.empty()) {
            return utc_nanoseconds::max();
        } else {
            return _functions.back().time_point;
        }
    }
 
    void run_all(utc_nanoseconds current_time, auto const&...args) noexcept
    {
        while (current_deadline() <= current_time) {
            run_one(current_time, args...);
        }
    }
 
private:
    struct timer_type {
        utc_nanoseconds time_point;
        std::chrono::nanoseconds period;
        weak_callback<void()> callback;
 
        timer_type() noexcept = default;
        timer_type(timer_type const&) noexcept = default;
        timer_type(timer_type&&) noexcept = default;
        timer_type& operator=(timer_type const&) noexcept = default;
        timer_type& operator=(timer_type&&) noexcept = default;
 
        timer_type(utc_nanoseconds time_point, std::chrono::nanoseconds period, weak_callback<void()> callback) noexcept :
            time_point(time_point), period(period), callback(std::move(callback))
        {
        }
 
        timer_type(utc_nanoseconds time_point, weak_callback<void()> callback) noexcept :
            timer_type(time_point, std::chrono::nanoseconds::max(), std::move(callback))
        {
        }
 
        timer_type(std::chrono::nanoseconds period, weak_callback<void()> callback) noexcept :
            timer_type(std::chrono::utc_clock::now(), period, std::move(callback))
        {
        }
 
        [[nodiscard]] constexpr bool repeats() const noexcept
        {
            return period != std::chrono::nanoseconds::max();
        }
    };
 
    void remove_or_reinsert(utc_nanoseconds current_time) noexcept
    {
        hi_assert(not _functions.empty());
 
        if (_functions.back().repeats() and not _functions.back().callback.expired()) {
            // When the function is repeating, calculate the new.
            auto item = std::move(_functions.back());
            _functions.pop_back();
 
            // Delay the function to be called on the next period.
            // However if the current_time already is passed the deadline, delay it even further.
            item.time_point += item.period;
            if (item.time_point > current_time) {
                item.time_point = current_time + item.period;
            }
 
            // Reinsert the function in the sorted list of functions.
            auto const it = std::lower_bound(_functions.begin(), _functions.end(), item.time_point, [](auto const& x, auto const& time_point) {
                return x.time_point > time_point;
            });
 
            _functions.insert(it, std::move(item));
 
        } else {
            _functions.pop_back();
        }
    }
 
    void run_one(utc_nanoseconds current_time)
    {
        hi_assert(not _functions.empty());
 
        auto &callback = _functions.back().callback;
        if (auto cb = callback.lock()) {
            cb();
        }
        remove_or_reinsert(current_time);
    }
 
    std::vector<timer_type> _functions;
};
 
} // namespace hi::inline v1