File indexing completed on 2025-12-16 09:44:25
0001
0002
0003
0004
0005
0006
0007
0008 #ifndef BOOST_COBALT_DETAIL_TASK_HPP
0009 #define BOOST_COBALT_DETAIL_TASK_HPP
0010
0011 #include <boost/cobalt/detail/exception.hpp>
0012 #include <boost/cobalt/detail/forward_cancellation.hpp>
0013 #include <boost/cobalt/detail/wrapper.hpp>
0014 #include <boost/cobalt/detail/this_thread.hpp>
0015 #include <boost/cobalt/noop.hpp>
0016 #include <boost/cobalt/op.hpp>
0017
0018 #include <boost/asio/bind_allocator.hpp>
0019 #include <boost/asio/cancellation_signal.hpp>
0020
0021
0022 #include <coroutine>
0023 #include <optional>
0024 #include <utility>
0025
0026 namespace boost::cobalt
0027 {
0028
0029 struct as_tuple_tag;
0030 struct as_result_tag;
0031
0032 template<typename Return>
0033 struct task;
0034
0035 namespace detail
0036 {
0037
0038 template<typename T>
0039 struct task_receiver;
0040
0041 template<typename T>
0042 struct task_value_holder
0043 {
0044 std::optional<T> result;
0045 bool result_taken = false;
0046
0047 system::result<T, std::exception_ptr> get_result_value()
0048 {
0049 result_taken = true;
0050 BOOST_ASSERT(result);
0051 return {system::in_place_value, std::move(*result)};
0052 }
0053
0054 void return_value(T && ret)
0055 {
0056 result.emplace(std::move(ret));
0057 static_cast<task_receiver<T>*>(this)->set_done();
0058 }
0059 void return_value(const T & ret)
0060 {
0061 result.emplace(ret);
0062 static_cast<task_receiver<T>*>(this)->set_done();
0063 }
0064
0065 constexpr task_value_holder() noexcept = default;
0066 constexpr task_value_holder(noop<T> n) noexcept(std::is_nothrow_move_constructible_v<T>) : result(std::move(n.value)) {}
0067 };
0068
0069 template<>
0070 struct task_value_holder<void>
0071 {
0072 bool result_taken = false;
0073 system::result<void, std::exception_ptr> get_result_value()
0074 {
0075 result_taken = true;
0076 return {system::in_place_value};
0077 }
0078
0079 inline void return_void();
0080
0081 constexpr task_value_holder() noexcept = default;
0082 constexpr task_value_holder(noop<void> n) noexcept {}
0083 };
0084
0085
0086 template<typename T>
0087 struct task_promise;
0088
0089 template<typename T>
0090 struct task_receiver : task_value_holder<T>
0091 {
0092 std::exception_ptr exception;
0093 system::result<T, std::exception_ptr> get_result()
0094 {
0095 if (exception && !done)
0096 return {system::in_place_error, std::exchange(exception, nullptr)};
0097 else if (exception)
0098 {
0099 this->result_taken = true;
0100 return {system::in_place_error, exception};
0101 }
0102 return this->get_result_value();
0103 }
0104
0105 void unhandled_exception()
0106 {
0107 exception = std::current_exception();
0108 set_done();
0109 }
0110
0111 bool done = false;
0112 unique_handle<void> awaited_from{nullptr};
0113
0114 void set_done()
0115 {
0116 done = true;
0117 }
0118
0119 void cancel(asio::cancellation_type ct) const
0120 {
0121 if (!done)
0122 promise->signal.emit(ct);
0123 }
0124
0125 task_receiver(noop<T> n) : task_value_holder<T>(std::move(n)), done(true) {}
0126 task_receiver() = default;
0127 task_receiver(task_receiver && lhs)
0128 : task_value_holder<T>(std::move(lhs)),
0129 exception(std::move(lhs.exception)), done(lhs.done), awaited_from(std::move(lhs.awaited_from)),
0130 promise(lhs.promise)
0131 {
0132 if (!done && !exception)
0133 {
0134 promise->receiver = this;
0135 lhs.exception = moved_from_exception();
0136 }
0137
0138 lhs.done = true;
0139 }
0140
0141 ~task_receiver()
0142 {
0143 if (!done && promise && promise->receiver == this)
0144 {
0145 promise->receiver = nullptr;
0146 if (!promise->started)
0147 std::coroutine_handle<task_promise<T>>::from_promise(*promise).destroy();
0148 }
0149 }
0150
0151 task_receiver(task_promise<T> * promise)
0152 : promise(promise)
0153 {
0154 promise->receiver = this;
0155 }
0156
0157 struct awaitable
0158 {
0159 task_receiver * self;
0160 asio::cancellation_slot cl;
0161 awaitable(task_receiver * self) : self(self)
0162 {
0163 }
0164
0165 awaitable(awaitable && aw) : self(aw.self)
0166 {
0167 }
0168
0169 ~awaitable ()
0170 {
0171 }
0172
0173 bool await_ready() const { return self->done; }
0174
0175 template<typename Promise>
0176 BOOST_NOINLINE std::coroutine_handle<void> await_suspend(std::coroutine_handle<Promise> h)
0177 {
0178 if (self->done)
0179 return std::coroutine_handle<void>::from_address(h.address());
0180
0181 if constexpr (requires (Promise p) {p.get_cancellation_slot();})
0182 if ((cl = h.promise().get_cancellation_slot()).is_connected())
0183 cl.emplace<forward_cancellation>(self->promise->signal);
0184
0185
0186 if constexpr (requires (Promise p) {p.get_executor();})
0187 self->promise->exec.emplace(h.promise().get_executor());
0188 else
0189 self->promise->exec.emplace(this_thread::get_executor());
0190 self->promise->exec_ = self->promise->exec->get_executor();
0191 self->awaited_from.reset(h.address());
0192
0193 return std::coroutine_handle<task_promise<T>>::from_promise(*self->promise);
0194 }
0195
0196 T await_resume(const boost::source_location & loc = BOOST_CURRENT_LOCATION)
0197 {
0198 if (cl.is_connected())
0199 cl.clear();
0200
0201 return self->get_result().value(loc);
0202 }
0203
0204 system::result<T, std::exception_ptr> await_resume(const as_result_tag &)
0205 {
0206 if (cl.is_connected())
0207 cl.clear();
0208 return self->get_result();
0209 }
0210
0211 auto await_resume(const as_tuple_tag &)
0212 {
0213 if (cl.is_connected())
0214 cl.clear();
0215 auto res = self->get_result();
0216 if constexpr (std::is_void_v<T>)
0217 return res.error();
0218 else
0219 {
0220 if (res.has_error())
0221 return std::make_tuple(res.error(), T{});
0222 else
0223 return std::make_tuple(std::exception_ptr(), std::move(*res));
0224 }
0225
0226 }
0227
0228 void interrupt_await() &
0229 {
0230 if (!self)
0231 return ;
0232 self->exception = detached_exception();
0233 if (self->awaited_from)
0234 self->awaited_from.release().resume();
0235 }
0236 };
0237
0238 task_promise<T> * promise;
0239
0240 awaitable get_awaitable() {return awaitable{this};}
0241
0242
0243 void interrupt_await() &
0244 {
0245 exception = detached_exception();
0246 awaited_from.release().resume();
0247 }
0248 };
0249
0250 inline void task_value_holder<void>::return_void()
0251 {
0252 static_cast<task_receiver<void>*>(this)->set_done();
0253 }
0254
0255 template<typename Return>
0256 struct task_promise_result
0257 {
0258 task_receiver<Return>* receiver{nullptr};
0259 void return_value(Return && ret)
0260 {
0261 if(receiver)
0262 receiver->return_value(std::move(ret));
0263 }
0264 void return_value(const Return & ret)
0265 {
0266 if(receiver)
0267 receiver->return_value(ret);
0268 }
0269 };
0270
0271 template<>
0272 struct task_promise_result<void>
0273 {
0274 task_receiver<void>* receiver{nullptr};
0275 void return_void()
0276 {
0277 if(receiver)
0278 receiver->return_void();
0279 }
0280 };
0281
0282 struct async_initiate_spawn;
0283
0284 template<typename Return>
0285 struct task_promise
0286 : promise_memory_resource_base,
0287 promise_cancellation_base<asio::cancellation_slot, asio::enable_total_cancellation>,
0288 promise_throw_if_cancelled_base,
0289 enable_awaitables<task_promise<Return>>,
0290 enable_await_allocator<task_promise<Return>>,
0291 enable_await_executor<task_promise<Return>>,
0292 enable_await_deferred,
0293 task_promise_result<Return>
0294 {
0295 using promise_cancellation_base<asio::cancellation_slot, asio::enable_total_cancellation>::await_transform;
0296 using promise_throw_if_cancelled_base::await_transform;
0297 using enable_awaitables<task_promise<Return>>::await_transform;
0298 using enable_await_allocator<task_promise<Return>>::await_transform;
0299 using enable_await_executor<task_promise<Return>>::await_transform;
0300 using enable_await_deferred::await_transform;
0301
0302 [[nodiscard]] task<Return> get_return_object()
0303 {
0304 return task<Return>{this};
0305 }
0306
0307 mutable asio::cancellation_signal signal;
0308
0309 using executor_type = executor;
0310 std::optional<asio::executor_work_guard<executor_type>> exec;
0311 std::optional<executor_type> exec_;
0312 const executor_type & get_executor() const
0313 {
0314 if (!exec)
0315 detail::throw_bad_executor();
0316 BOOST_ASSERT(exec_);
0317 return *exec_;
0318 }
0319
0320 template<typename ... Args>
0321 task_promise(Args & ...args)
0322 #if !defined(BOOST_COBALT_NO_PMR)
0323 : promise_memory_resource_base(detail::get_memory_resource_from_args_global(args...))
0324 #endif
0325 {
0326 this->reset_cancellation_source(signal.slot());
0327 }
0328
0329 struct initial_awaitable
0330 {
0331 task_promise * promise;
0332
0333 bool await_ready() const noexcept {return false;}
0334 void await_suspend(std::coroutine_handle<>) {}
0335
0336 void await_resume()
0337 {
0338 promise->started = true;
0339 }
0340 };
0341
0342 auto initial_suspend() noexcept
0343 {
0344
0345 return initial_awaitable{this};
0346 }
0347
0348 struct final_awaitable
0349 {
0350 task_promise * promise;
0351 bool await_ready() const noexcept
0352 {
0353 return promise->receiver && promise->receiver->awaited_from.get() == nullptr;
0354 }
0355
0356 BOOST_NOINLINE
0357 auto await_suspend(std::coroutine_handle<task_promise> h) noexcept
0358 {
0359 std::coroutine_handle<void> res = std::noop_coroutine();
0360 if (promise->receiver && promise->receiver->awaited_from.get() != nullptr)
0361 res = promise->receiver->awaited_from.release();
0362
0363
0364 if (auto & rec = h.promise().receiver; rec != nullptr)
0365 {
0366 if (!rec->done && !rec->exception)
0367 rec->exception = completed_unexpected();
0368 rec->set_done();
0369 rec->awaited_from.reset(nullptr);
0370 rec = nullptr;
0371 }
0372 detail::self_destroy(h);
0373 return res;
0374 }
0375
0376 void await_resume() noexcept
0377 {
0378 }
0379 };
0380
0381 auto final_suspend() noexcept
0382 {
0383 return final_awaitable{this};
0384 }
0385
0386 void unhandled_exception()
0387 {
0388 if (this->receiver)
0389 this->receiver->unhandled_exception();
0390 else
0391 throw ;
0392 }
0393
0394 ~task_promise()
0395 {
0396 if (this->receiver)
0397 {
0398 if (!this->receiver->done && !this->receiver->exception)
0399 this->receiver->exception = completed_unexpected();
0400 this->receiver->set_done();
0401 this->receiver->awaited_from.reset(nullptr);
0402 }
0403 }
0404 bool started = false;
0405 friend struct async_initiate;
0406 };
0407
0408 }
0409
0410 }
0411
0412 #endif
