convert awaiter to sender

Author: wokron

include/condy/execution.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "condy/concepts.hpp"
 #include "condy/runtime.hpp"
 #include <stdexec/execution.hpp>
 
@@ -40,6 +41,57 @@ class ScheduleSender {
     Runtime &runtime_;
 };
 
+template <AwaiterLike Awaiter> class AwaiterSender {
+public:
+    using sender_concept = stdexec::sender_t;
+
+    using completion_signatures = stdexec::completion_signatures<
+        stdexec::set_value_t(typename Awaiter::HandleType::ReturnType),
+        stdexec::set_error_t(std::exception_ptr)>;
+
+    AwaiterSender(Awaiter awaiter) : awaiter_(std::move(awaiter)) {}
+
+    template <typename Receiver> auto connect(Receiver &&receiver) {
+        return OpState<std::decay_t<Receiver>>(
+            std::move(awaiter_), std::forward<Receiver>(receiver));
+    }
+
+private:
+    template <typename Receiver>
+    class OpState : public InvokerAdapter<OpState<Receiver>> {
+    public:
+        OpState(Awaiter awaiter, Receiver receiver)
+            : awaiter_(std::move(awaiter)), receiver_(std::move(receiver)) {}
+
+        void start() noexcept {
+            awaiter_.init_finish_handle();
+            awaiter_.get_handle()->set_invoker(this);
+            awaiter_.register_operation(0);
+        }
+
+        void invoke() noexcept {
+            try {
+                auto result = awaiter_.await_resume();
+                stdexec::set_value(std::move(receiver_), std::move(result));
+            } catch (...) {
+                stdexec::set_error(std::move(receiver_),
+                                   std::current_exception());
+            }
+        }
+
+    private:
+        Awaiter awaiter_;
+        Receiver receiver_;
+    };
+    ;
+
+    Awaiter awaiter_;
+};
+
+template <AwaiterLike Awaiter> auto convert_to_sender(Awaiter &&awaiter) {
+    return AwaiterSender<std::decay_t<Awaiter>>(std::forward<Awaiter>(awaiter));
+}
+
 } // namespace detail
 
 class RuntimeScheduler {

tests/test_execution.cpp

@@ -1,3 +1,4 @@
+#include "condy/async_operations.hpp"
 #include "condy/execution.hpp"
 #include "condy/runtime.hpp"
 #include <doctest/doctest.h>
@@ -24,6 +25,28 @@ TEST_CASE("test execution - schedule") {
     REQUIRE(thread_id == runtime_thread_id);
     REQUIRE(runtime_thread_id != std::this_thread::get_id());
 
+    runtime.allow_exit();
+    runtime_thread.join();
+}
+
+TEST_CASE("test execution - awaiter") {
+    condy::Runtime runtime;
+    std::thread runtime_thread([&] { runtime.run(); });
+
+    bool executed = false;
+    auto scheduler = condy::RuntimeScheduler(runtime);
+    auto nop_awaiter = condy::async_nop();
+    auto nop_sender = condy::detail::convert_to_sender(nop_awaiter);
+    auto sender = stdexec::schedule(scheduler) |
+                  stdexec::let_value([&]() { return nop_sender; }) |
+                  stdexec::then([&](auto res) {
+                      REQUIRE(res == 0);
+                      executed = true;
+                  });
+
+    stdexec::sync_wait(sender);
+    REQUIRE(executed);
+
     runtime.allow_exit();
     runtime_thread.join();
 }