Coroutine.hpp

#pragma once
 
#include "util/Spawn.hpp"
 
#include <boost/asio/any_io_executor.hpp>
#include <boost/asio/bind_cancellation_slot.hpp>
#include <boost/asio/cancellation_signal.hpp>
#include <boost/asio/cancellation_type.hpp>
#include <boost/asio/error.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/signals2/connection.hpp>
#include <boost/signals2/signal.hpp>
#include <boost/signals2/variadic_signal.hpp>
 
#include <atomic>
#include <concepts>
#include <csignal>
#include <cstddef>
#include <memory>
#include <utility>
 
namespace util {
 
class Coroutine;

template <typename Fn>
concept CoroutineFunction = std::invocable<Fn, Coroutine&> and not std::is_reference_v<Fn>;

class Coroutine {
public:
    using cancellable_yield_context_type = boost::asio::
        cancellation_slot_binder<boost::asio::yield_context, boost::asio::cancellation_slot>;
 
private:
    boost::asio::yield_context yield_;
    boost::system::error_code error_;
    boost::asio::cancellation_signal cancellationSignal_;
    cancellable_yield_context_type cyield_;
    std::atomic_bool isCancelled_{false};
 
    using FamilyCancellationSignal =
        boost::signals2::signal<void(boost::asio::cancellation_type_t)>;
    std::shared_ptr<FamilyCancellationSignal> familySignal_;
    boost::signals2::connection connection_;

    explicit Coroutine(
        boost::asio::yield_context&& yield,
        std::shared_ptr<FamilyCancellationSignal> signal =
            std::make_shared<FamilyCancellationSignal>()
    );
 
public:
    ~Coroutine();
 
    Coroutine(Coroutine const&) = delete;
    Coroutine(Coroutine&&) = delete;
 
    Coroutine&
    operator==(Coroutine&&) = delete;
 
    Coroutine&
    operator==(Coroutine const&) = delete;

    template <typename ExecutionContext, CoroutineFunction Fn>
    static void
    spawnNew(ExecutionContext& ioContext, Fn fn)
    {
        util::spawn(ioContext, [fn = std::move(fn)](boost::asio::yield_context yield) {
            Coroutine thisCoroutine{std::move(yield)};
            fn(thisCoroutine);
        });
    }

    template <CoroutineFunction Fn>
    void
    spawnChild(Fn fn)
    {
        if (isCancelled_)
            return;
 
        util::spawn(
            yield_,
            [signal = familySignal_, fn = std::move(fn)](boost::asio::yield_context yield) mutable {
                Coroutine coroutine(std::move(yield), std::move(signal));
                fn(coroutine);
            }
        );
    }

    [[nodiscard]] boost::system::error_code
    error() const;

    void
    cancelAll(
        boost::asio::cancellation_type_t cancellationType = boost::asio::cancellation_type::terminal
    );

    [[nodiscard]] bool
    isCancelled() const;

    [[nodiscard]] cancellable_yield_context_type
    yieldContext() const;

    [[nodiscard]] boost::asio::any_io_executor
    executor() const;

    void
    yield() const;
};
 
}  // namespace util