runners.hpp

#ifndef MRS_LIB_CORO_RUNNERS_HPP_
#define MRS_LIB_CORO_RUNNERS_HPP_
 
#include <concepts>
#include <coroutine>
 
#include <mrs_lib/coro/internal/thread_local_continuation_scheduler.hpp>
#include <mrs_lib/coro/task.hpp>
#include <stop_token>
#include <utility>
 
 
namespace mrs_lib::coro
{
 
  namespace internal
  {
 
    class AsyncRun
    {
    public:
      struct promise_type
      {
        template <typename... Args>
        promise_type(std::stop_token stop_token, Args&&...) : stop_token_(std::move(stop_token))
        {
        }
 
        AsyncRun get_return_object()
        {
          return {};
        }
        MoveToThreadLocalContinuationScheduler initial_suspend()
        {
          return {};
        }
        std::suspend_never final_suspend() noexcept
        {
          return {};
        }
        void return_void()
        {
        }
        void unhandled_exception()
        {
          throw;
        }
 
        std::stop_token stop_token_;
      };
 
    private:
      AsyncRun() = default;
    };
 
    template <>
    struct CancellableContinuationFor<AsyncRun::promise_type>
    {
      static CancellableContinuation release_continuation(std::coroutine_handle<AsyncRun::promise_type>)
      {
        return {};
      };
 
      static std::stop_token get_token(std::coroutine_handle<AsyncRun::promise_type> handle)
      {
        return handle.promise().stop_token_;
      }
    };
 
    template <typename F, typename... Args>
      requires std::invocable<std::decay_t<F>, std::decay_t<Args>...> && std::same_as<Task<void>, std::invoke_result_t<std::decay_t<F>, std::decay_t<Args>...>>
    internal::AsyncRun start_task_impl(std::stop_token, F task, Args... args)
    {
      // The `decay-copy` of the arguments ensures that they are copied into
      // the coroutine frame, preventing dangling references like `std::thread`.
      co_await std::invoke(std::move(task), std::move(args)...);
    }
 
    template <typename F, typename... Args>
      requires std::invocable<std::decay_t<F>, std::decay_t<Args>...> && std::same_as<Task<void>, std::invoke_result_t<std::decay_t<F>, std::decay_t<Args>...>>
    void start_task(F&& task, Args&&... args)
    {
      internal::start_task_impl(std::stop_token(), std::forward<F>(task), std::forward<Args>(args)...);
    }
 
    template <typename F, typename... Args>
      requires std::invocable<std::decay_t<F>, std::decay_t<Args>...> && std::same_as<Task<void>, std::invoke_result_t<std::decay_t<F>, std::decay_t<Args>...>>
    void start_task(std::stop_token token, F&& task, Args&&... args)
    {
      internal::start_task_impl(token, std::forward<F>(task), std::forward<Args>(args)...);
    }
 
  } // namespace internal
 
} // namespace mrs_lib::coro
 
#endif // MRS_LIB_CORO_RUNNERS_HPP_