async_compose

Launch an asynchronous operation with a stateful implementation.

template<
    typename CompletionToken,
    typename Signature,
    typename Implementation,
    typename... IoObjectsOrExecutors>
auto async_compose(
    Implementation && implementation,
    type_identity_t< CompletionToken > & token,
    IoObjectsOrExecutors &&... io_objects_or_executors);

The async_compose function simplifies the implementation of composed asynchronous operations automatically wrapping a stateful function object with a conforming intermediate completion handler.

Parameters

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.
token: The completion token.
io_objects_or_executors: Zero or more I/O objects or I/O executors for which outstanding work must be maintained.

By default, terminal per-operation cancellation is enabled for composed operations that are implemented using async_compose. To disable cancellation for the composed operation, or to alter its supported cancellation types, call the self object's reset_cancellation_state function.

Example:

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 = 0)
  {
    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_compose<CompletionToken,
      void(boost::system::error_code, std::size_t)>(
        std::declval<async_echo_implementation>(),
        token, socket))
{
  return boost::asio::async_compose<CompletionToken,
    void(boost::system::error_code, std::size_t)>(
      async_echo_implementation{socket, buffer,
        async_echo_implementation::starting},
      token, socket);
}

Requirements

Header: boost/asio/compose.hpp

Convenience header: boost/asio.hpp

async_compose

Parameters

Per-Operation Cancellation

Example:

Requirements