loop.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_fifo.hpp"
#include "function_timer.hpp"
#include "utility/module.hpp"
#include "net/network_event.hpp"
#include <functional>
#include <type_traits>
#include <concepts>
#include <vector>
#include <memory>
 
namespace hi::inline v1 {
class gui_window;
 
class loop {
public:
    using timer_callback_token = function_timer<>::callback_token;
 
    class impl_type {
    public:
        bool is_main = false;
 
        impl_type() = default;
        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;
 
        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 add_window(std::weak_ptr<gui_window> window) noexcept = 0;
        virtual void add_socket(int fd, network_event event_mask, std::function<void(int, network_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
        {
            // Some functions check on_thread() while resume() has not been called yet.
            // calling functions outside of the loop's thread if the loop is not being resumed is valid.
            return _thread_id == 0 or 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 = 0;
        std::vector<std::weak_ptr<gui_window>> _windows;
    };
 
    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;
        }
 
        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
    {
        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 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 add_window(std::weak_ptr<gui_window> window) noexcept
    {
        hi_assert_not_null(_pimpl);
        return _pimpl->add_window(std::move(window));
    }
 
    void add_socket(int fd, network_event event_mask, std::function<void(int, network_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;
};
 
} // namespace hi::inline v1