notifier.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 "required.hpp"
#include "generator.hpp"
#include "loop.hpp"
#include <vector>
#include <tuple>
#include <functional>
#include <coroutine>
 
namespace hi::inline v1 {
 
template<typename T = void()>
class notifier {
};
 
// The partial template specialization allows the use of a `std::function`-like template
// argument, that looks like a function prototype.
template<typename Result, typename... Args>
class notifier<Result(Args...)> {
public:
    static_assert(std::is_same_v<Result, void>, "Result of a notifier must be void.");
 
    using result_type = Result;
    using callback_type = std::function<Result(Args const&...)>;
 
    using token_type = std::shared_ptr<callback_type>;
    using weak_token_type = std::weak_ptr<callback_type>;
 
    class awaiter_type {
    public:
        constexpr awaiter_type() noexcept = default;
        constexpr awaiter_type(awaiter_type const&) noexcept = default;
        constexpr awaiter_type(awaiter_type&&) noexcept = default;
        constexpr awaiter_type& operator=(awaiter_type const&) noexcept = default;
        constexpr awaiter_type& operator=(awaiter_type&&) noexcept = default;
 
        constexpr awaiter_type(notifier& notifier) noexcept : _notifier(&notifier) {}
 
        [[nodiscard]] constexpr bool await_ready() noexcept
        {
            return false;
        }
 
        void await_suspend(std::coroutine_handle<> handle) noexcept
        {
            hi_axiom(_notifier != nullptr);
 
            // We can use the this pointer in the callback, as `await_suspend()` is called by
            // the co-routine on the same object as `await_resume()`.
            _cbt = _notifier->subscribe([this, handle](Args const&...args) {
                _args = {args...};
                handle.resume();
            });
        }
 
        constexpr void await_resume() const noexcept requires(sizeof...(Args) == 0) {}
 
        constexpr auto await_resume() const noexcept requires(sizeof...(Args) == 1)
        {
            return std::get<0>(_args);
        }
 
        constexpr auto await_resume() const noexcept requires(sizeof...(Args) > 1)
        {
            return _args;
        }
 
        [[nodiscard]] bool operator==(awaiter_type const& rhs) const noexcept
        {
            return _notifier == rhs._notifier;
        }
 
    private:
        notifier *_notifier = nullptr;
        token_type _cbt;
        std::tuple<Args...> _args;
    };
 
    constexpr notifier() noexcept = default;
    notifier(notifier&&) = delete;
    notifier(notifier const&) = delete;
    notifier& operator=(notifier&&) = delete;
    notifier& operator=(notifier const&) = delete;
 
    awaiter_type operator co_await() const noexcept
    {
        return awaiter_type{const_cast<notifier&>(*this)};
    }
 
    [[nodiscard]] token_type subscribe(std::invocable<Args...> auto&& callback) noexcept
    {
        auto token = std::make_shared<callback_type>(hi_forward(callback));
        _callbacks.emplace_back(token);
        return token;
    }
 
    void post(Args const&...args) const noexcept requires(std::is_same_v<result_type, void>)
    {
        for (auto& weak_callback : _callbacks) {
            loop::local().post_function([=] {
                if (auto callback = weak_callback.lock()) {
                    (*callback)(args...);
                }
            });
        }
        clean_up();
    }
 
    void post_on_main(Args const&...args) const noexcept requires(std::is_same_v<result_type, void>)
    {
        for (auto& weak_callback : _callbacks) {
            loop::main().post_function([=] {
                if (auto callback = weak_callback.lock()) {
                    (*callback)(args...);
                }
            });
        }
        clean_up();
    }
 
    auto operator()(Args const&...args) const noexcept
    {
        return post(args...);
    }
 
private:
    mutable std::vector<weak_token_type> _callbacks;
 
    void clean_up() const noexcept
    {
        std::erase_if(_callbacks, [](hilet& item) {
            return item.expired();
        });
    }
 
#if HI_BUILD_TYPE == HI_BT_DEBUG
    mutable bool _notifying = false;
#endif
};
 
} // namespace hi::inline v1