You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
138 lines
4.5 KiB
138 lines
4.5 KiB
// |
|
// compose.hpp |
|
// ~~~~~~~~~~~ |
|
// |
|
// Copyright (c) 2003-2019 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_COMPOSE_HPP |
|
#define BOOST_ASIO_COMPOSE_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/async_result.hpp> |
|
|
|
#include <boost/asio/detail/push_options.hpp> |
|
|
|
namespace boost { |
|
namespace asio { |
|
|
|
#if defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) \ |
|
|| defined(GENERATING_DOCUMENTATION) |
|
|
|
/// Launch an asynchronous operation with a stateful implementation. |
|
/** |
|
* The async_compose function simplifies the implementation of composed |
|
* asynchronous operations automatically wrapping a stateful function object |
|
* with a conforming intermediate completion handler. |
|
* |
|
* @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 token The completion token. |
|
* |
|
* @param io_objects_or_executors Zero or more I/O objects or I/O executors for |
|
* which outstanding work must be maintained. |
|
* |
|
* @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 = 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) -> |
|
* typename boost::asio::async_result< |
|
* typename std::decay<CompletionToken>::type, |
|
* void(boost::system::error_code, std::size_t)>::return_type |
|
* { |
|
* 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); |
|
* } @endcode |
|
*/ |
|
template <typename CompletionToken, typename Signature, |
|
typename Implementation, typename... IoObjectsOrExecutors> |
|
BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, Signature) |
|
async_compose(BOOST_ASIO_MOVE_ARG(Implementation) implementation, |
|
BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, |
|
BOOST_ASIO_MOVE_ARG(IoObjectsOrExecutors)... io_objects_or_executors); |
|
|
|
#else // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) |
|
// || defined(GENERATING_DOCUMENTATION) |
|
|
|
template <typename CompletionToken, typename Signature, typename Implementation> |
|
BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, Signature) |
|
async_compose(BOOST_ASIO_MOVE_ARG(Implementation) implementation, |
|
BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token); |
|
|
|
#define BOOST_ASIO_PRIVATE_ASYNC_COMPOSE_DEF(n) \ |
|
template <typename CompletionToken, typename Signature, \ |
|
typename Implementation, BOOST_ASIO_VARIADIC_TPARAMS(n)> \ |
|
BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(CompletionToken, Signature) \ |
|
async_compose(BOOST_ASIO_MOVE_ARG(Implementation) implementation, \ |
|
BOOST_ASIO_NONDEDUCED_MOVE_ARG(CompletionToken) token, \ |
|
BOOST_ASIO_VARIADIC_MOVE_PARAMS(n)); |
|
/**/ |
|
BOOST_ASIO_VARIADIC_GENERATE(BOOST_ASIO_PRIVATE_ASYNC_COMPOSE_DEF) |
|
#undef BOOST_ASIO_PRIVATE_ASYNC_COMPOSE_DEF |
|
|
|
#endif // defined(BOOST_ASIO_HAS_VARIADIC_TEMPLATES) |
|
// || defined(GENERATING_DOCUMENTATION) |
|
|
|
} // namespace asio |
|
} // namespace boost |
|
|
|
#include <boost/asio/detail/pop_options.hpp> |
|
|
|
#include <boost/asio/impl/compose.hpp> |
|
|
|
#endif // BOOST_ASIO_COMPOSE_HPP
|
|
|