loop_intf.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 "function_timer.hpp"
#include "socket_event.hpp"
#include "../container/module.hpp"
#include "../utility/utility.hpp"
#include "../macros.hpp"
#include <functional>
#include <type_traits>
#include <concepts>
#include <vector>
#include <memory>
 
hi_export_module(hikogui.dispatch.loop : intf);
 
namespace hi::inline v1 {
 
class loop {
public:
    using timer_callback_token = function_timer<>::callback_token;
    using render_callback_type = std::function<void(utc_nanoseconds)>;
    using render_callback_token = std::shared_ptr<render_callback_type>;
 
    class impl_type {
    public:
        bool is_main = false;
 
        impl_type() : _thread_id(current_thread_id()) {}
 
        virtual ~impl_type() {}
        impl_type(impl_type const&) = delete;
        impl_type(impl_type&&) = delete;
        impl_type& operator=(impl_type const&) = delete;
        impl_type& operator=(impl_type&&) = delete;
 
        virtual void set_maximum_frame_rate(double frame_rate) noexcept = 0;
        virtual void set_vsync_monitor_id(uintptr_t id) noexcept = 0;
        
        void wfree_post_function(auto&& func) noexcept
        {
            return _function_fifo.add_function(hi_forward(func));
        }
 
        void post_function(auto&& func) noexcept
        {
            _function_fifo.add_function(hi_forward(func));
            notify_has_send();
        }
 
        [[nodiscard]] auto async_function(auto&& func) noexcept
        {
            auto future = _function_fifo.add_async_function(hi_forward(func));
            notify_has_send();
            return future;
        }
 
        timer_callback_token delay_function(utc_nanoseconds time_point, auto&& func) noexcept
        {
            auto [token, first_to_call] = _function_timer.delay_function(time_point, hi_forward(func));
            if (first_to_call) {
                // Notify if the added function is the next function to call.
                notify_has_send();
            }
            return token;
        }
 
        timer_callback_token repeat_function(std::chrono::nanoseconds period, utc_nanoseconds time_point, auto&& func) noexcept
        {
            auto [token, first_to_call] = _function_timer.repeat_function(period, time_point, hi_forward(func));
            if (first_to_call) {
                // Notify if the added function is the next function to call.
                notify_has_send();
            }
            return token;
        }
 
        timer_callback_token repeat_function(std::chrono::nanoseconds period, auto&& func) noexcept
        {
            auto [token, first_to_call] = _function_timer.repeat_function(period, hi_forward(func));
            if (first_to_call) {
                // Notify if the added function is the next function to call.
                notify_has_send();
            }
            return token;
        }
 
        virtual void subscribe_render(std::weak_ptr<render_callback_type> f) noexcept = 0;
        virtual void add_socket(int fd, socket_event event_mask, std::function<void(int, socket_events const&)> f) = 0;
        virtual void remove_socket(int fd) = 0;
        virtual int resume(std::stop_token stop_token) noexcept = 0;
        virtual void resume_once(bool block) noexcept = 0;
 
        [[nodiscard]] bool on_thread() const noexcept
        {
            return current_thread_id() == _thread_id;
        }
 
    protected:
        virtual void notify_has_send() noexcept = 0;
 
        function_fifo<> _function_fifo;
        function_timer<> _function_timer;
 
        std::optional<int> _exit_code = {};
        double _maximum_frame_rate = 30.0;
        std::chrono::nanoseconds _minimum_frame_time = std::chrono::nanoseconds(33'333'333);
        thread_id _thread_id;
        std::vector<std::weak_ptr<render_callback_type>> _render_functions;
    };
 
    loop();
    loop(loop const&) = delete;
    loop(loop&&) noexcept = default;
    loop& operator=(loop const&) = delete;
    loop& operator=(loop&&) noexcept = default;
 
    [[nodiscard]] hi_no_inline static loop& local() noexcept
    {
        if (not _local) {
            _local = std::make_unique<loop>();
        }
        return *_local;
    }
 
    [[nodiscard]] hi_no_inline static loop& main() noexcept
    {
        if (auto ptr = _main.load(std::memory_order::acquire)) {
            return *ptr;
        }
 
        hi_axiom(_timer.load(std::memory_order::relaxed) == nullptr, "loop::main() must be called before loop::timer()");
 
        // This is the first time loop::main() is called so we must be on the main-thread
        // So name the thread "main" so we can find it during debugging.
        set_thread_name("main");
 
        auto ptr = std::addressof(local());
        ptr->_pimpl->is_main = true;
        _main.store(ptr, std::memory_order::release);
        return *ptr;
    }
 
    [[nodiscard]] hi_no_inline static loop& timer() noexcept
    {
        // The first time timer() is called, make sure that the main-loop exists,
        // or even create the main-loop on the current thread.
        [[maybe_unused]] hilet &tmp = loop::main();
 
        return *start_subsystem_or_terminate(_timer, nullptr, timer_init, timer_deinit);
    }
 
    void set_maximum_frame_rate(double frame_rate) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->set_maximum_frame_rate(frame_rate);
    }
 
    void set_vsync_monitor_id(uintptr_t id) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->set_vsync_monitor_id(id);
    }
 
    void wfree_post_function(auto&& func) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->wfree_post_function(hi_forward(func));
    }
 
    void post_function(auto&& func) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->post_function(hi_forward(func));
    }
 
    [[nodiscard]] auto async_function(auto&& func) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->async_function(hi_forward(func));
    }
 
    [[nodiscard]] timer_callback_token delay_function(utc_nanoseconds time_point, auto&& func) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->delay_function(time_point, hi_forward(func));
    }
 
    [[nodiscard]] timer_callback_token
    repeat_function(std::chrono::nanoseconds period, utc_nanoseconds time_point, auto&& func) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->repeat_function(period, time_point, hi_forward(func));
    }
 
    [[nodiscard]] timer_callback_token repeat_function(std::chrono::nanoseconds period, auto&& func) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->repeat_function(period, hi_forward(func));
    }
 
    void subscribe_render(std::weak_ptr<render_callback_type> f) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->subscribe_render(std::move(f));
    }
 
    template<std::invocable<utc_nanoseconds> F>
    render_callback_token subscribe_render(F &&f) noexcept
    {
        hi_assert_not_null(_pimpl);
        auto ptr = std::make_shared<render_callback_type>(std::forward<F>(f));
        _pimpl->subscribe_render(ptr);
        return ptr;
    }
 
    void add_socket(int fd, socket_event event_mask, std::function<void(int, socket_events const&)> f)
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->add_socket(fd, event_mask, std::move(f));
    }
 
    void remove_socket(int fd)
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->remove_socket(fd);
    }
 
    int resume(std::stop_token stop_token = {}) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->resume(stop_token);
    }
 
    void resume_once(bool block = false) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->resume_once(block);
    }
 
    [[nodiscard]] bool on_thread() const noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->on_thread();
    }
 
private:
    static loop *timer_init() noexcept
    {
        hi_assert(not _timer_thread.joinable());
 
        _timer_thread = std::jthread{[](std::stop_token stop_token) {
            _timer.store(std::addressof(loop::local()), std::memory_order::release);
 
            set_thread_name("timer");
            loop::local().resume(stop_token);
        }};
 
        while (true) {
            if (auto ptr = _timer.load(std::memory_order::relaxed)) {
                return ptr;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(20));
        }
    }
 
    static void timer_deinit() noexcept
    {
        if (auto const *const ptr = _timer.exchange(nullptr, std::memory_order::acquire)) {
            hi_assert(_timer_thread.joinable());
            _timer_thread.request_stop();
            _timer_thread.join();
        }
    }
 
    inline static thread_local std::unique_ptr<loop> _local;
 
    inline static std::atomic<loop *> _main;
 
    inline static std::atomic<loop *> _timer;
 
    inline static std::jthread _timer_thread;
 
    std::unique_ptr<impl_type> _pimpl;
};
 
template<typename Result, typename... Args>
template<typename F>
void notifier<Result(Args...)>::loop_local_post_function(F&& f) const noexcept
{
    return loop::local().post_function(std::forward<F>(f));
}
 
template<typename Result, typename... Args>
template<typename F>
void notifier<Result(Args...)>::loop_main_post_function(F&& f) const noexcept
{
    return loop::main().post_function(std::forward<F>(f));
}
 
template<typename Result, typename... Args>
template<typename F>
void notifier<Result(Args...)>::loop_timer_post_function(F&& f) const noexcept
{
    return loop::timer().post_function(std::forward<F>(f));
}
 
} // namespace hi::inline v1