The coroutine class provides support for stackless coroutines. Stackless coroutines enable programs to implement asynchronous logic in a synchronous manner, with minimal overhead, as shown in the following example:

struct session : asio::coroutine
{
  boost::shared_ptr<tcp::socket> socket_;
  boost::shared_ptr<std::vector<char> > buffer_;

  session(boost::shared_ptr<tcp::socket> socket)
    : socket_(socket),
      buffer_(new std::vector<char>(1024))
  {
  }

  void operator()(asio::error_code ec = asio::error_code(), std::size_t n = 0)
  {
    if (!ec) reenter (this)
    {
      for (;;)
      {
        yield socket_->async_read_some(asio::buffer(*buffer_), *this);
        yield asio::async_write(*socket_, asio::buffer(*buffer_, n), *this);
      }
    }
  }
};

The coroutine class is used in conjunction with the pseudo-keywords reenter, yield and fork. These are preprocessor macros, and are implemented in terms of a switch statement using a technique similar to Duff's Device. The coroutine class's documentation provides a complete description of these pseudo-keywords.

See Also

coroutine, HTTP Server 4 example, Stackful Coroutines.