cancel_after is supported.

Author: klemens-morgenstern

include/boost/cobalt/detail/spawn.hpp

@@ -24,8 +24,15 @@ namespace boost::cobalt::detail
 
 struct async_initiate_spawn
 {
+
+  async_initiate_spawn(executor exec) : exec(exec) {}
+
+  using executor_type = executor;
+  const executor_type & get_executor() const {return exec;}
+  executor exec;
+
   template<typename Handler, typename T>
-  void operator()(Handler && h, task<T> a, executor exec)
+  void operator()(Handler && h, task<T> a)
   {
     auto & rec = a.receiver_;
     if (rec.done)
@@ -44,9 +51,9 @@ struct async_initiate_spawn
     auto sl = asio::get_associated_cancellation_slot(h);
     if (sl.is_connected())
       sl.assign(
-          [exec, recs](asio::cancellation_type ct)
+          [ex = exec, recs](asio::cancellation_type ct)
           {
-            asio::dispatch(exec, [recs, ct] {recs->cancel(ct);});
+            asio::dispatch(ex, [recs, ct] {recs->cancel(ct);});
           });
 
     auto p = recs.get();
@@ -88,7 +95,7 @@ struct async_initiate_spawn
   }
 
   template<typename Handler>
-  void operator()(Handler && h, task<void> a, executor exec)
+  void operator()(Handler && h, task<void> a)
   {
     if (a.receiver_.done)
       return asio::dispatch(
@@ -110,9 +117,9 @@ struct async_initiate_spawn
     auto sl = asio::get_associated_cancellation_slot(h);
     if (sl.is_connected())
       sl.assign(
-          [exec, recs](asio::cancellation_type ct)
+          [ex = exec, recs](asio::cancellation_type ct)
           {
-            asio::dispatch(exec, [recs, ct] {recs->cancel(ct);});
+            asio::dispatch(ex, [recs, ct] {recs->cancel(ct);});
           });
 
     auto p = recs.get();

include/boost/cobalt/spawn.hpp

@@ -19,15 +19,15 @@ auto spawn(Context & context,
            CompletionToken&& token)
 {
     return asio::async_initiate<CompletionToken, void(std::exception_ptr, T)>(
-            detail::async_initiate_spawn{}, token, std::move(t), context.get_executor());
+            detail::async_initiate_spawn{context.get_executor()}, token, std::move(t));
 }
 
 template<std::convertible_to<executor> Executor, typename T, typename CompletionToken>
 auto spawn(Executor executor, task<T> && t,
            CompletionToken&& token BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
 {
     return asio::async_initiate<CompletionToken, void(std::exception_ptr, T)>(
-            detail::async_initiate_spawn{}, token, std::move(t), executor);
+            detail::async_initiate_spawn{executor}, token, std::move(t));
 }
 
 template<with_get_executor Context, typename CompletionToken>
@@ -36,15 +36,15 @@ auto spawn(Context & context,
            CompletionToken&& token)
 {
     return asio::async_initiate<CompletionToken, void(std::exception_ptr)>(
-            detail::async_initiate_spawn{}, token, std::move(t), context.get_executor());
+            detail::async_initiate_spawn{context.get_executor()}, token, std::move(t));
 }
 
 template<std::convertible_to<executor> Executor, typename CompletionToken>
 auto spawn(Executor executor, task<void> && t,
            CompletionToken&& token BOOST_ASIO_DEFAULT_COMPLETION_TOKEN(Executor))
 {
     return asio::async_initiate<CompletionToken, void(std::exception_ptr)>(
-            detail::async_initiate_spawn{}, token, std::move(t), executor);
+            detail::async_initiate_spawn{executor}, token, std::move(t));
 
 }
 

test/task.cpp

@@ -13,6 +13,7 @@
 
 #include <boost/test/unit_test.hpp>
 #include "test.hpp"
+#include <boost/asio/cancel_after.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/steady_timer.hpp>
 #include <boost/asio/awaitable.hpp>
@@ -327,5 +328,33 @@ BOOST_AUTO_TEST_CASE(cancel_task_)
 #endif
 
 
+CO_TEST_CASE(cancel_task_after)
+{
+  try
+  {
+    auto exec = co_await cobalt::this_coro::executor;
+    co_await cobalt::spawn(
+        exec,
+        []() -> cobalt::task<void>
+        {
+          asio::steady_timer t{co_await cobalt::this_coro::executor, std::chrono::steady_clock::time_point::max()};
+          co_await t.async_wait();
+        }(),
+        asio::cancel_after(std::chrono::milliseconds(1)));
+
+    BOOST_FAIL("Unreachable");
+  }
+  catch(system::system_error & se)
+  {
+    BOOST_CHECK(se.code() == asio::error::operation_aborted);
+  }
+  catch(...)
+  {
+    BOOST_FAIL("Unreachable");
+  }
+}
+
+
+
 
 BOOST_AUTO_TEST_SUITE_END();