Adapt executor interface to capy continuation API

Capy replaced coroutine_handle<> with continuation& in the executor
post()/dispatch() signatures. continuation wraps a coroutine handle
with an intrusive next pointer so executors can queue work without
per-post heap allocation.

Updated all post/dispatch call sites across every backend (epoll,
kqueue, select, IOCP) and subsystem (timer, signal, resolver,
tcp_server). Each call site stores a continuation with lifetime
that outlives the executor queue residency.

Author: mvandeberg

include/boost/corosio/detail/dispatch_coro.hpp

@@ -12,6 +12,7 @@
 #define BOOST_COROSIO_DETAIL_DISPATCH_CORO_HPP
 
 #include <boost/corosio/io_context.hpp>
+#include <boost/capy/continuation.hpp>
 #include <boost/capy/ex/executor_ref.hpp>
 #include <boost/capy/detail/type_id.hpp>
 #include <coroutine>
@@ -20,25 +21,26 @@ namespace boost::corosio::detail {
 
 /** Returns a handle for symmetric transfer on I/O completion.
 
-    If the executor is io_context::executor_type, returns `h`
+    If the executor is io_context::executor_type, returns `c.h`
     directly (fast path). Otherwise dispatches through the
-    executor, which returns `h` or `noop_coroutine()`.
+    executor, which returns `c.h` or `noop_coroutine()`.
 
     Callers in coroutine machinery should return the result
     for symmetric transfer. Callers at the scheduler pump
     level should call `.resume()` on the result.
 
     @param ex The executor to dispatch through.
-    @param h The coroutine handle to resume.
+    @param c The continuation to dispatch. Must remain at a
+             stable address until dequeued by the executor.
 
     @return A handle for symmetric transfer or `std::noop_coroutine()`.
 */
 inline std::coroutine_handle<>
-dispatch_coro(capy::executor_ref ex, std::coroutine_handle<> h)
+dispatch_coro(capy::executor_ref ex, capy::continuation& c)
 {
     if (ex.target<io_context::executor_type>() != nullptr)
-        return h;
-    return ex.dispatch(h);
+        return c.h;
+    return ex.dispatch(c);
 }
 
 } // namespace boost::corosio::detail

include/boost/corosio/detail/timer_service.hpp

@@ -250,6 +250,7 @@ struct BOOST_COROSIO_SYMBOL_VISIBLE waiter_node
     timer_service::implementation* impl_ = nullptr;
     timer_service* svc_                  = nullptr;
     std::coroutine_handle<> h_;
+    capy::continuation* cont_            = nullptr;
     capy::executor_ref d_;
     std::error_code* ec_out_ = nullptr;
     std::stop_token token_;
@@ -282,7 +283,8 @@ struct timer_service::implementation final : timer::implementation
         std::coroutine_handle<>,
         capy::executor_ref,
         std::stop_token,
-        std::error_code*) override;
+        std::error_code*,
+        capy::continuation*) override;
 };
 
 // Thread-local caches avoid hot-path mutex acquisitions:
@@ -803,14 +805,14 @@ waiter_node::completion_op::operator()()
     if (w->ec_out_)
         *w->ec_out_ = w->ec_value_;
 
-    auto h      = w->h_;
+    auto* cont  = w->cont_;
     auto d      = w->d_;
     auto* svc   = w->svc_;
     auto& sched = svc->get_scheduler();
 
     svc->destroy_waiter(w);
 
-    d.post(h);
+    d.post(*cont);
     sched.work_finished();
 }
 
@@ -852,7 +854,8 @@ timer_service::implementation::wait(
     std::coroutine_handle<> h,
     capy::executor_ref d,
     std::stop_token token,
-    std::error_code* ec)
+    std::error_code* ec,
+    capy::continuation* cont)
 {
     // Already-expired fast path — no waiter_node, no mutex.
     // Post instead of dispatch so the coroutine yields to the
@@ -863,7 +866,7 @@ timer_service::implementation::wait(
         {
             if (ec)
                 *ec = {};
-            d.post(h);
+            d.post(*cont);
             return std::noop_coroutine();
         }
     }
@@ -872,6 +875,7 @@ timer_service::implementation::wait(
     w->impl_   = this;
     w->svc_    = svc_;
     w->h_      = h;
+    w->cont_   = cont;
     w->d_      = d;
     w->token_  = std::move(token);
     w->ec_out_ = ec;

include/boost/corosio/io/io_timer.hpp

@@ -13,6 +13,7 @@
 
 #include <boost/corosio/detail/config.hpp>
 #include <boost/corosio/io/io_object.hpp>
+#include <boost/capy/continuation.hpp>
 #include <boost/capy/io_result.hpp>
 #include <boost/capy/error.hpp>
 #include <boost/capy/ex/executor_ref.hpp>
@@ -46,6 +47,7 @@ class BOOST_COROSIO_DECL io_timer : public io_object
         io_timer& t_;
         std::stop_token token_;
         mutable std::error_code ec_;
+        capy::continuation cont_;
 
         explicit wait_awaitable(io_timer& t) noexcept : t_(t) {}
 
@@ -65,6 +67,7 @@ class BOOST_COROSIO_DECL io_timer : public io_object
             -> std::coroutine_handle<>
         {
             token_     = env->stop_token;
+            cont_.h    = h;
             auto& impl = t_.get();
             // Inline fast path: already expired and not in the heap
             if (impl.heap_index_ == implementation::npos &&
@@ -75,10 +78,10 @@ class BOOST_COROSIO_DECL io_timer : public io_object
                 token_ = {}; // match normal path so await_resume
                              // returns ec_, not a stale stop check
                 auto d = env->executor;
-                d.post(h);
+                d.post(cont_);
                 return std::noop_coroutine();
             }
-            return impl.wait(h, env->executor, std::move(token_), &ec_);
+            return impl.wait(h, env->executor, std::move(token_), &ec_, &cont_);
         }
     };
 
@@ -109,7 +112,8 @@ class BOOST_COROSIO_DECL io_timer : public io_object
             std::coroutine_handle<>,
             capy::executor_ref,
             std::stop_token,
-            std::error_code*) = 0;
+            std::error_code*,
+            capy::continuation*) = 0;
     };
 
     /// The clock type used for time operations.

include/boost/corosio/io_context.hpp

@@ -15,6 +15,7 @@
 #include <boost/corosio/detail/config.hpp>
 #include <boost/corosio/detail/platform.hpp>
 #include <boost/corosio/detail/scheduler.hpp>
+#include <boost/capy/continuation.hpp>
 #include <boost/capy/ex/execution_context.hpp>
 
 #include <chrono>
@@ -375,34 +376,34 @@ class io_context::executor_type
         ctx_->sched_->work_finished();
     }
 
-    /** Dispatch a coroutine handle.
+    /** Dispatch a continuation.
 
         Returns a handle for symmetric transfer. If called from
-        within `run()`, returns `h`. Otherwise posts the coroutine
+        within `run()`, returns `c.h`. Otherwise posts the coroutine
         for later execution and returns `std::noop_coroutine()`.
 
-        @param h The coroutine handle to dispatch.
+        @param c The continuation to dispatch.
 
         @return A handle for symmetric transfer or `std::noop_coroutine()`.
     */
-    std::coroutine_handle<> dispatch(std::coroutine_handle<> h) const
+    std::coroutine_handle<> dispatch(capy::continuation& c) const
     {
         if (running_in_this_thread())
-            return h;
-        ctx_->sched_->post(h);
+            return c.h;
+        ctx_->sched_->post(c.h);
         return std::noop_coroutine();
     }
 
-    /** Post a coroutine for deferred execution.
+    /** Post a continuation for deferred execution.
 
         The coroutine will be resumed during a subsequent call to
         `run()`.
 
-        @param h The coroutine handle to post.
+        @param c The continuation to post.
     */
-    void post(std::coroutine_handle<> h) const
+    void post(capy::continuation& c) const
     {
-        ctx_->sched_->post(h);
+        ctx_->sched_->post(c.h);
     }
 
     /** Compare two executors for equality.

include/boost/corosio/native/detail/epoll/epoll_tcp_acceptor_service.hpp

@@ -177,7 +177,8 @@ epoll_tcp_acceptor::accept(
                 if (impl_out)
                     *impl_out = nullptr;
             }
-            return dispatch_coro(ex, h);
+            op.cont.h = h;
+            return dispatch_coro(ex, op.cont);
         }
 
         op.accepted_fd  = accepted;

include/boost/corosio/native/detail/iocp/win_overlapped_op.hpp

@@ -62,6 +62,7 @@ struct overlapped_op
 
     long ready_ = 0;
     std::coroutine_handle<> h;
+    capy::continuation cont;
     capy::executor_ref ex;
     std::error_code* ec_out = nullptr;
     std::size_t* bytes_out  = nullptr;
@@ -144,7 +145,8 @@ struct overlapped_op
         if (bytes_out)
             *bytes_out = static_cast<std::size_t>(bytes_transferred);
 
-        dispatch_coro(ex, h).resume();
+        cont.h = h;
+        dispatch_coro(ex, cont).resume();
     }
 
     /** Disarm cancellation and abandon the coroutine handle. */

include/boost/corosio/native/detail/iocp/win_resolver_service.hpp

@@ -270,7 +270,8 @@ resolve_op::do_complete(
 
     op->cancel_handle = nullptr;
 
-    dispatch_coro(op->ex, op->h).resume();
+    op->cont.h = op->h;
+    dispatch_coro(op->ex, op->cont).resume();
 }
 
 // reverse_resolve_op
@@ -314,7 +315,8 @@ reverse_resolve_op::do_complete(
             op->ep, std::move(op->stored_host), std::move(op->stored_service));
     }
 
-    dispatch_coro(op->ex, op->h).resume();
+    op->cont.h = op->h;
+    dispatch_coro(op->ex, op->cont).resume();
 }
 
 // win_resolver

include/boost/corosio/native/detail/iocp/win_signal.hpp

@@ -19,6 +19,7 @@
 #include <boost/corosio/signal_set.hpp>
 #include <boost/corosio/detail/intrusive.hpp>
 #include <boost/corosio/detail/scheduler_op.hpp>
+#include <boost/capy/continuation.hpp>
 #include <boost/capy/ex/executor_ref.hpp>
 
 #include <coroutine>
@@ -43,6 +44,7 @@ enum
 struct signal_op : scheduler_op
 {
     std::coroutine_handle<> h;
+    capy::continuation cont;
     capy::executor_ref d;
     std::error_code* ec_out  = nullptr;
     int* signal_out          = nullptr;

include/boost/corosio/native/detail/iocp/win_signals.hpp

@@ -304,7 +304,8 @@ signal_op::do_complete(
     auto* service = op->svc;
     op->svc       = nullptr;
 
-    dispatch_coro(op->d, op->h).resume();
+    op->cont.h = op->h;
+    dispatch_coro(op->d, op->cont).resume();
 
     if (service)
         service->work_finished();
@@ -337,7 +338,8 @@ win_signal::wait(
             *ec = make_error_code(capy::error::canceled);
         if (signal_out)
             *signal_out = 0;
-        dispatch_coro(d, h).resume();
+        pending_op_.cont.h = h;
+        dispatch_coro(d, pending_op_.cont).resume();
         // completion is always posted to scheduler queue, never inline.
         return std::noop_coroutine();
     }
@@ -610,7 +612,8 @@ win_signals::cancel_wait(win_signal& impl)
             *op->ec_out = make_error_code(capy::error::canceled);
         if (op->signal_out)
             *op->signal_out = 0;
-        dispatch_coro(op->d, op->h).resume();
+        op->cont.h = op->h;
+        dispatch_coro(op->d, op->cont).resume();
         sched_.work_finished();
     }
 }

include/boost/corosio/native/detail/iocp/win_tcp_acceptor_service.hpp

@@ -238,11 +238,11 @@ accept_op::do_complete(
             *op->impl_out = nullptr;
     }
 
-    auto saved_h                       = op->h;
+    op->cont.h                         = op->h;
     auto saved_ex                      = op->ex;
     auto prevent_premature_destruction = std::move(op->acceptor_ptr);
 
-    dispatch_coro(saved_ex, saved_h).resume();
+    dispatch_coro(saved_ex, op->cont).resume();
 }
 
 // connect_op completion handler