// // composed.hpp // ~~~~~~~~~~~~ // // Copyright (c) 2003-2024 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_COMPOSED_HPP #define BOOST_ASIO_COMPOSED_HPP #if defined(_MSC_VER) && (_MSC_VER >= 1200) # pragma once #endif // defined(_MSC_VER) && (_MSC_VER >= 1200) #include <boost/asio/detail/config.hpp> #include <boost/asio/associated_executor.hpp> #include <boost/asio/async_result.hpp> #include <boost/asio/detail/base_from_cancellation_state.hpp> #include <boost/asio/detail/composed_work.hpp> #include <boost/asio/detail/handler_cont_helpers.hpp> #include <boost/asio/detail/type_traits.hpp> #include <boost/asio/detail/push_options.hpp> namespace boost { namespace asio { namespace detail { template <typename Impl, typename Work, typename Handler, typename... Signatures> class composed_op; template <typename Impl, typename Work, typename Handler> class composed_op<Impl, Work, Handler> : public base_from_cancellation_state<Handler> { public: template <typename I, typename W, typename H> composed_op(I&& impl, W&& work, H&& handler) : base_from_cancellation_state<Handler>( handler, enable_terminal_cancellation()), impl_(static_cast<I&&>(impl)), work_(static_cast<W&&>(work)), handler_(static_cast<H&&>(handler)), invocations_(0) { } composed_op(composed_op&& other) : base_from_cancellation_state<Handler>( static_cast<base_from_cancellation_state<Handler>&&>(other)), impl_(static_cast<Impl&&>(other.impl_)), work_(static_cast<Work&&>(other.work_)), handler_(static_cast<Handler&&>(other.handler_)), invocations_(other.invocations_) { } typedef typename composed_work_guard< typename Work::head_type>::executor_type io_executor_type; io_executor_type get_io_executor() const noexcept { return work_.head_.get_executor(); } typedef associated_executor_t<Handler, io_executor_type> executor_type; executor_type get_executor() const noexcept { return (get_associated_executor)(handler_, work_.head_.get_executor()); } typedef associated_allocator_t<Handler, std::allocator<void>> allocator_type; allocator_type get_allocator() const noexcept { return (get_associated_allocator)(handler_, std::allocator<void>()); } template <typename... T> void operator()(T&&... t) { if (invocations_ < ~0u) ++invocations_; this->get_cancellation_state().slot().clear(); impl_(*this, static_cast<T&&>(t)...); } template <typename... Args> auto complete(Args&&... args) -> decltype(declval<Handler>()(static_cast<Args&&>(args)...)) { return static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...); } void reset_cancellation_state() { base_from_cancellation_state<Handler>::reset_cancellation_state(handler_); } template <typename Filter> void reset_cancellation_state(Filter&& filter) { base_from_cancellation_state<Handler>::reset_cancellation_state(handler_, static_cast<Filter&&>(filter)); } template <typename InFilter, typename OutFilter> void reset_cancellation_state(InFilter&& in_filter, OutFilter&& out_filter) { base_from_cancellation_state<Handler>::reset_cancellation_state(handler_, static_cast<InFilter&&>(in_filter), static_cast<OutFilter&&>(out_filter)); } cancellation_type_t cancelled() const noexcept { return base_from_cancellation_state<Handler>::cancelled(); } //private: Impl impl_; Work work_; Handler handler_; unsigned invocations_; }; template <typename Impl, typename Work, typename Handler, typename R, typename... Args> class composed_op<Impl, Work, Handler, R(Args...)> : public composed_op<Impl, Work, Handler> { public: using composed_op<Impl, Work, Handler>::composed_op; template <typename... T> void operator()(T&&... t) { if (this->invocations_ < ~0u) ++this->invocations_; this->get_cancellation_state().slot().clear(); this->impl_(*this, static_cast<T&&>(t)...); } void complete(Args... args) { this->work_.reset(); static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...); } }; template <typename Impl, typename Work, typename Handler, typename R, typename... Args, typename... Signatures> class composed_op<Impl, Work, Handler, R(Args...), Signatures...> : public composed_op<Impl, Work, Handler, Signatures...> { public: using composed_op<Impl, Work, Handler, Signatures...>::composed_op; template <typename... T> void operator()(T&&... t) { if (this->invocations_ < ~0u) ++this->invocations_; this->get_cancellation_state().slot().clear(); this->impl_(*this, static_cast<T&&>(t)...); } using composed_op<Impl, Work, Handler, Signatures...>::complete; void complete(Args... args) { this->work_.reset(); static_cast<Handler&&>(this->handler_)(static_cast<Args&&>(args)...); } }; template <typename Impl, typename Work, typename Handler, typename Signature> inline bool asio_handler_is_continuation( composed_op<Impl, Work, Handler, Signature>* this_handler) { return this_handler->invocations_ > 1 ? true : boost_asio_handler_cont_helpers::is_continuation( this_handler->handler_); } template <typename Implementation, typename Executors, typename... Signatures> class initiate_composed { public: typedef typename composed_io_executors<Executors>::head_type executor_type; template <typename I> initiate_composed(I&& impl, composed_io_executors<Executors>&& executors) : implementation_(std::forward<I>(impl)), executors_(std::move(executors)) { } executor_type get_executor() const noexcept { return executors_.head_; } template <typename Handler, typename... Args> void operator()(Handler&& handler, Args&&... args) const & { composed_op<decay_t<Implementation>, composed_work<Executors>, decay_t<Handler>, Signatures...>(implementation_, composed_work<Executors>(executors_), static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...); } template <typename Handler, typename... Args> void operator()(Handler&& handler, Args&&... args) && { composed_op<decay_t<Implementation>, composed_work<Executors>, decay_t<Handler>, Signatures...>( static_cast<Implementation&&>(implementation_), composed_work<Executors>(executors_), static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...); } private: Implementation implementation_; composed_io_executors<Executors> executors_; }; template <typename Implementation, typename... Signatures> class initiate_composed<Implementation, void(), Signatures...> { public: template <typename I> initiate_composed(I&& impl, composed_io_executors<void()>&&) : implementation_(std::forward<I>(impl)) { } template <typename Handler, typename... Args> void operator()(Handler&& handler, Args&&... args) const & { composed_op<decay_t<Implementation>, composed_work<void()>, decay_t<Handler>, Signatures...>(implementation_, composed_work<void()>(composed_io_executors<void()>()), static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...); } template <typename Handler, typename... Args> void operator()(Handler&& handler, Args&&... args) && { composed_op<decay_t<Implementation>, composed_work<void()>, decay_t<Handler>, Signatures...>( static_cast<Implementation&&>(implementation_), composed_work<void()>(composed_io_executors<void()>()), static_cast<Handler&&>(handler))(static_cast<Args&&>(args)...); } private: Implementation implementation_; }; template <typename... Signatures, typename Implementation, typename Executors> inline initiate_composed<Implementation, Executors, Signatures...> make_initiate_composed(Implementation&& implementation, composed_io_executors<Executors>&& executors) { return initiate_composed<decay_t<Implementation>, Executors, Signatures...>( static_cast<Implementation&&>(implementation), static_cast<composed_io_executors<Executors>&&>(executors)); } } // namespace detail #if !defined(GENERATING_DOCUMENTATION) template <template <typename, typename> class Associator, typename Impl, typename Work, typename Handler, typename Signature, typename DefaultCandidate> struct associator<Associator, detail::composed_op<Impl, Work, Handler, Signature>, DefaultCandidate> : Associator<Handler, DefaultCandidate> { static typename Associator<Handler, DefaultCandidate>::type get( const detail::composed_op<Impl, Work, Handler, Signature>& h) noexcept { return Associator<Handler, DefaultCandidate>::get(h.handler_); } static auto get(const detail::composed_op<Impl, Work, Handler, Signature>& h, const DefaultCandidate& c) noexcept -> decltype(Associator<Handler, DefaultCandidate>::get(h.handler_, c)) { return Associator<Handler, DefaultCandidate>::get(h.handler_, c); } }; #endif // !defined(GENERATING_DOCUMENTATION) /// Creates an initiation function object that may be used to launch an /// asynchronous operation with a stateful implementation. /** * The @c composed function simplifies the implementation of composed * asynchronous operations automatically by wrapping a stateful function object * for use as an initiation function object. * * @param implementation A function object that contains the implementation of * the composed asynchronous operation. The first argument to the function * object is a non-const reference to the enclosing intermediate completion * handler. The remaining arguments are any arguments that originate from the * completion handlers of any asynchronous operations performed by the * implementation. * * @param io_objects_or_executors Zero or more I/O objects or I/O executors for * which outstanding work must be maintained. * * @par Per-Operation Cancellation * By default, terminal per-operation cancellation is enabled for composed * operations that are implemented using @c composed. To disable cancellation * for the composed operation, or to alter its supported cancellation types, * call the @c self object's @c reset_cancellation_state function. * * @par Example: * * @code struct async_echo_implementation * { * tcp::socket& socket_; * boost::asio::mutable_buffer buffer_; * enum { starting, reading, writing } state_; * * template <typename Self> * void operator()(Self& self, * boost::system::error_code error, * std::size_t n) * { * switch (state_) * { * case starting: * state_ = reading; * socket_.async_read_some( * buffer_, std::move(self)); * break; * case reading: * if (error) * { * self.complete(error, 0); * } * else * { * state_ = writing; * boost::asio::async_write(socket_, buffer_, * boost::asio::transfer_exactly(n), * std::move(self)); * } * break; * case writing: * self.complete(error, n); * break; * } * } * }; * * template <typename CompletionToken> * auto async_echo(tcp::socket& socket, * boost::asio::mutable_buffer buffer, * CompletionToken&& token) * -> decltype( * boost::asio::async_initiate<CompletionToken, * void(boost::system::error_code, std::size_t)>( * boost::asio::composed( * async_echo_implementation{socket, buffer, * async_echo_implementation::starting}, socket), * token)) * { * return boost::asio::async_initiate<CompletionToken, * void(boost::system::error_code, std::size_t)>( * boost::asio::composed( * async_echo_implementation{socket, buffer, * async_echo_implementation::starting}, socket), * token, boost::system::error_code{}, 0); * } @endcode */ template <BOOST_ASIO_COMPLETION_SIGNATURE... Signatures, typename Implementation, typename... IoObjectsOrExecutors> inline auto composed(Implementation&& implementation, IoObjectsOrExecutors&&... io_objects_or_executors) -> decltype( detail::make_initiate_composed<Signatures...>( static_cast<Implementation&&>(implementation), detail::make_composed_io_executors( detail::get_composed_io_executor( static_cast<IoObjectsOrExecutors&&>( io_objects_or_executors))...))) { return detail::make_initiate_composed<Signatures...>( static_cast<Implementation&&>(implementation), detail::make_composed_io_executors( detail::get_composed_io_executor( static_cast<IoObjectsOrExecutors&&>( io_objects_or_executors))...)); } } // namespace asio } // namespace boost #include <boost/asio/detail/pop_options.hpp> #endif // BOOST_ASIO_COMPOSE_HPP