// // impl/spawn.hpp // ~~~~~~~~~~~~~~ // // Copyright (c) 2003-2021 Christopher M. Kohlhoff (chris at kohlhoff dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // #ifndef BOOST_ASIO_IMPL_SPAWN_HPP #define BOOST_ASIO_IMPL_SPAWN_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include #include #include #include #include #include #include #include #include #include #include #include #include #include namespace boost { namespace asio { namespace detail { template class coro_handler { public: coro_handler(basic_yield_context ctx) : coro_(ctx.coro_.lock()), ca_(ctx.ca_), handler_(ctx.handler_), ready_(0), ec_(ctx.ec_), value_(0) { } void operator()(T value) { *ec_ = boost::system::error_code(); *value_ = BOOST_ASIO_MOVE_CAST(T)(value); if (--*ready_ == 0) (*coro_)(); } void operator()(boost::system::error_code ec, T value) { *ec_ = ec; *value_ = BOOST_ASIO_MOVE_CAST(T)(value); if (--*ready_ == 0) (*coro_)(); } //private: shared_ptr::callee_type> coro_; typename basic_yield_context::caller_type& ca_; Handler handler_; atomic_count* ready_; boost::system::error_code* ec_; T* value_; }; template class coro_handler { public: coro_handler(basic_yield_context ctx) : coro_(ctx.coro_.lock()), ca_(ctx.ca_), handler_(ctx.handler_), ready_(0), ec_(ctx.ec_) { } void operator()() { *ec_ = boost::system::error_code(); if (--*ready_ == 0) (*coro_)(); } void operator()(boost::system::error_code ec) { *ec_ = ec; if (--*ready_ == 0) (*coro_)(); } //private: shared_ptr::callee_type> coro_; typename basic_yield_context::caller_type& ca_; Handler handler_; atomic_count* ready_; boost::system::error_code* ec_; }; template inline asio_handler_allocate_is_deprecated asio_handler_allocate(std::size_t size, coro_handler* this_handler) { #if defined(BOOST_ASIO_NO_DEPRECATED) boost_asio_handler_alloc_helpers::allocate(size, this_handler->handler_); return asio_handler_allocate_is_no_longer_used(); #else // defined(BOOST_ASIO_NO_DEPRECATED) return boost_asio_handler_alloc_helpers::allocate( size, this_handler->handler_); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline asio_handler_deallocate_is_deprecated asio_handler_deallocate(void* pointer, std::size_t size, coro_handler* this_handler) { boost_asio_handler_alloc_helpers::deallocate( pointer, size, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_deallocate_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline bool asio_handler_is_continuation(coro_handler*) { return true; } template inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, coro_handler* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, coro_handler* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template class coro_async_result { public: typedef coro_handler completion_handler_type; typedef T return_type; explicit coro_async_result(completion_handler_type& h) : handler_(h), ca_(h.ca_), ready_(2) { h.ready_ = &ready_; out_ec_ = h.ec_; if (!out_ec_) h.ec_ = &ec_; h.value_ = &value_; } return_type get() { // Must not hold shared_ptr to coro while suspended. handler_.coro_.reset(); if (--ready_ != 0) ca_(); if (!out_ec_ && ec_) throw boost::system::system_error(ec_); return BOOST_ASIO_MOVE_CAST(return_type)(value_); } private: completion_handler_type& handler_; typename basic_yield_context::caller_type& ca_; atomic_count ready_; boost::system::error_code* out_ec_; boost::system::error_code ec_; return_type value_; }; template class coro_async_result { public: typedef coro_handler completion_handler_type; typedef void return_type; explicit coro_async_result(completion_handler_type& h) : handler_(h), ca_(h.ca_), ready_(2) { h.ready_ = &ready_; out_ec_ = h.ec_; if (!out_ec_) h.ec_ = &ec_; } void get() { // Must not hold shared_ptr to coro while suspended. handler_.coro_.reset(); if (--ready_ != 0) ca_(); if (!out_ec_ && ec_) throw boost::system::system_error(ec_); } private: completion_handler_type& handler_; typename basic_yield_context::caller_type& ca_; atomic_count ready_; boost::system::error_code* out_ec_; boost::system::error_code ec_; }; } // namespace detail #if !defined(GENERATING_DOCUMENTATION) template class async_result, ReturnType()> : public detail::coro_async_result { public: explicit async_result( typename detail::coro_async_result::completion_handler_type& h) : detail::coro_async_result(h) { } }; template class async_result, ReturnType(Arg1)> : public detail::coro_async_result::type> { public: explicit async_result( typename detail::coro_async_result::type>::completion_handler_type& h) : detail::coro_async_result::type>(h) { } }; template class async_result, ReturnType(boost::system::error_code)> : public detail::coro_async_result { public: explicit async_result( typename detail::coro_async_result::completion_handler_type& h) : detail::coro_async_result(h) { } }; template class async_result, ReturnType(boost::system::error_code, Arg2)> : public detail::coro_async_result::type> { public: explicit async_result( typename detail::coro_async_result::type>::completion_handler_type& h) : detail::coro_async_result::type>(h) { } }; template struct associated_allocator, Allocator> { typedef typename associated_allocator::type type; static type get(const detail::coro_handler& h, const Allocator& a = Allocator()) BOOST_ASIO_NOEXCEPT { return associated_allocator::get(h.handler_, a); } }; template struct associated_executor, Executor> : detail::associated_executor_forwarding_base { typedef typename associated_executor::type type; static type get(const detail::coro_handler& h, const Executor& ex = Executor()) BOOST_ASIO_NOEXCEPT { return associated_executor::get(h.handler_, ex); } }; namespace detail { template struct spawn_data : private noncopyable { template spawn_data(BOOST_ASIO_MOVE_ARG(Hand) handler, bool call_handler, BOOST_ASIO_MOVE_ARG(Func) function) : handler_(BOOST_ASIO_MOVE_CAST(Hand)(handler)), call_handler_(call_handler), function_(BOOST_ASIO_MOVE_CAST(Func)(function)) { } weak_ptr::callee_type> coro_; Handler handler_; bool call_handler_; Function function_; }; template struct coro_entry_point { void operator()(typename basic_yield_context::caller_type& ca) { shared_ptr > data(data_); #if !defined(BOOST_COROUTINES_UNIDIRECT) && !defined(BOOST_COROUTINES_V2) ca(); // Yield until coroutine pointer has been initialised. #endif // !defined(BOOST_COROUTINES_UNIDIRECT) && !defined(BOOST_COROUTINES_V2) const basic_yield_context yield( data->coro_, ca, data->handler_); (data->function_)(yield); if (data->call_handler_) (data->handler_)(); } shared_ptr > data_; }; template struct spawn_helper { typedef typename associated_allocator::type allocator_type; allocator_type get_allocator() const BOOST_ASIO_NOEXCEPT { return (get_associated_allocator)(data_->handler_); } typedef typename associated_executor::type executor_type; executor_type get_executor() const BOOST_ASIO_NOEXCEPT { return (get_associated_executor)(data_->handler_); } void operator()() { typedef typename basic_yield_context::callee_type callee_type; coro_entry_point entry_point = { data_ }; shared_ptr coro(new callee_type(entry_point, attributes_)); data_->coro_ = coro; (*coro)(); } shared_ptr > data_; boost::coroutines::attributes attributes_; }; template inline asio_handler_invoke_is_deprecated asio_handler_invoke(Function& function, spawn_helper* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->data_->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } template inline asio_handler_invoke_is_deprecated asio_handler_invoke(const Function& function, spawn_helper* this_handler) { boost_asio_handler_invoke_helpers::invoke( function, this_handler->data_->handler_); #if defined(BOOST_ASIO_NO_DEPRECATED) return asio_handler_invoke_is_no_longer_used(); #endif // defined(BOOST_ASIO_NO_DEPRECATED) } inline void default_spawn_handler() {} } // namespace detail template inline void spawn(BOOST_ASIO_MOVE_ARG(Function) function, const boost::coroutines::attributes& attributes) { typedef typename decay::type function_type; typename associated_executor::type ex( (get_associated_executor)(function)); boost::asio::spawn(ex, BOOST_ASIO_MOVE_CAST(Function)(function), attributes); } template void spawn(BOOST_ASIO_MOVE_ARG(Handler) handler, BOOST_ASIO_MOVE_ARG(Function) function, const boost::coroutines::attributes& attributes, typename constraint< !is_executor::type>::value && !execution::is_executor::type>::value && !is_convertible::value>::type) { typedef typename decay::type handler_type; typedef typename decay::type function_type; detail::spawn_helper helper; helper.data_.reset( new detail::spawn_data( BOOST_ASIO_MOVE_CAST(Handler)(handler), true, BOOST_ASIO_MOVE_CAST(Function)(function))); helper.attributes_ = attributes; boost::asio::dispatch(helper); } template void spawn(basic_yield_context ctx, BOOST_ASIO_MOVE_ARG(Function) function, const boost::coroutines::attributes& attributes) { typedef typename decay::type function_type; Handler handler(ctx.handler_); // Explicit copy that might be moved from. detail::spawn_helper helper; helper.data_.reset( new detail::spawn_data( BOOST_ASIO_MOVE_CAST(Handler)(handler), false, BOOST_ASIO_MOVE_CAST(Function)(function))); helper.attributes_ = attributes; boost::asio::dispatch(helper); } template inline void spawn(const Executor& ex, BOOST_ASIO_MOVE_ARG(Function) function, const boost::coroutines::attributes& attributes, typename constraint< is_executor::value || execution::is_executor::value >::type) { boost::asio::spawn(boost::asio::strand(ex), BOOST_ASIO_MOVE_CAST(Function)(function), attributes); } template inline void spawn(const strand& ex, BOOST_ASIO_MOVE_ARG(Function) function, const boost::coroutines::attributes& attributes) { boost::asio::spawn(boost::asio::bind_executor( ex, &detail::default_spawn_handler), BOOST_ASIO_MOVE_CAST(Function)(function), attributes); } #if !defined(BOOST_ASIO_NO_TS_EXECUTORS) template inline void spawn(const boost::asio::io_context::strand& s, BOOST_ASIO_MOVE_ARG(Function) function, const boost::coroutines::attributes& attributes) { boost::asio::spawn(boost::asio::bind_executor( s, &detail::default_spawn_handler), BOOST_ASIO_MOVE_CAST(Function)(function), attributes); } #endif // !defined(BOOST_ASIO_NO_TS_EXECUTORS) template inline void spawn(ExecutionContext& ctx, BOOST_ASIO_MOVE_ARG(Function) function, const boost::coroutines::attributes& attributes, typename constraint::value>::type) { boost::asio::spawn(ctx.get_executor(), BOOST_ASIO_MOVE_CAST(Function)(function), attributes); } #endif // !defined(GENERATING_DOCUMENTATION) } // namespace asio } // namespace boost #include #endif // BOOST_ASIO_IMPL_SPAWN_HPP