void operator()(CompletionHandler&& completion_handler,
tcp::socket& socket, const char* message) const
{
// The async_write operation has a completion handler signature of:
//
// void(boost::system::error_code error, std::size n)
//
// This differs from our operation's signature in that it is also passed
// the number of bytes transferred as an argument of type std::size_t. We
// will adapt our completion handler to async_write's completion handler
// signature by using std::bind, which drops the additional argument.
//
// However, it is essential to the correctness of our composed operation
// that we preserve the executor of the user-supplied completion handler.
// The std::bind function will not do this for us, so we must do this by
// first obtaining the completion handler's associated executor (defaulting
// to the I/O executor - in this case the executor of the socket - if the
// completion handler does not have its own) ...
auto executor = boost::asio::get_associated_executor(
completion_handler, socket.get_executor());
// ... and then binding this executor to our adapted completion handler
// using the boost::asio::bind_executor function.
boost::asio::async_write(socket,
boost::asio::buffer(message, std::strlen(message)),
boost::asio::bind_executor(executor,
std::bind(std::forward<CompletionHandler>(
completion_handler), std::placeholders::_1)));
}
auto async_write_messages(tcp::socket& socket,
const T& message, std::size_t repeat_count,
CompletionToken&& token)
// The return type of the initiating function is deduced from the combination
// of CompletionToken type and the completion handler's signature. When the
// completion token is a simple callback, the return type is always void.
// In this example, when the completion token is boost::asio::yield_context
// (used for stackful coroutines) the return type would be also be void, as
// there is no non-error argument to the completion handler. When the
// completion token is boost::asio::use_future it would be std::future<void>.
//
// In C++14 we can omit the return type as it is automatically deduced from
// the return type of boost::asio::async_initiate.
{
// Encode the message and copy it into an allocated buffer. The buffer will
// be maintained for the lifetime of the composed asynchronous operation.
std::ostringstream os;
os << message;
std::unique_ptr<std::string> encoded_message(new std::string(os.str()));
// Create a steady_timer to be used for the delay between messages.
std::unique_ptr<boost::asio::steady_timer> delay_timer(
new boost::asio::steady_timer(socket.get_executor()));
// To manage the cycle between the multiple underlying asychronous
// operations, our implementation is a state machine.
enum { starting, waiting, writing };
// The boost::asio::async_compose function takes:
//
// - our asynchronous operation implementation,
// - the completion token,
// - the completion handler signature, and
// - any I/O objects (or executors) used by the operation
//
// It then wraps our implementation, which is implemented here as a state
// machine in a lambda, in an intermediate completion handler that meets the
// requirements of a conforming asynchronous operation. This includes
// tracking outstanding work against the I/O executors associated with the
// operation (in this example, this is the socket's executor).
//
// The first argument to our lambda is a reference to the enclosing
// intermediate completion handler. This intermediate completion handler is
// provided for us by the boost::asio::async_compose function, and takes care
// of all the details required to implement a conforming asynchronous
// operation. When calling an underlying asynchronous operation, we pass it
// this enclosing intermediate completion handler as the completion token.
//
// All arguments to our lambda after the first must be defaulted to allow the
// state machine to be started, as well as to allow the completion handler to
// match the completion signature of both the async_write and
// steady_timer::async_wait operations.
return boost::asio::async_compose<
CompletionToken, void(boost::system::error_code)>(
[
// The implementation holds a reference to the socket as it is used for
// multiple async_write operations.
&socket,
// The allocated buffer for the encoded message. The std::unique_ptr
// smart pointer is move-only, and as a consequence our lambda
// implementation is also move-only.
encoded_message = std::move(encoded_message),
// The repeat count remaining.
repeat_count,
// A steady timer used for introducing a delay.
delay_timer = std::move(delay_timer),
// To manage the cycle between the multiple underlying asychronous
// operations, our implementation is a state machine.
state = starting
]
(
auto& self,
const boost::system::error_code& error = {},
std::size_t = 0
) mutable
{
if (!error)
{
switch (state)
{
case starting:
case writing:
if (repeat_count > 0)
{
--repeat_count;
state = waiting;
delay_timer->expires_after(std::chrono::seconds(1));
delay_timer->async_wait(std::move(self));
return; // Composed operation not yet complete.
}
break; // Composed operation complete, continue below.
case waiting:
state = writing;
boost::asio::async_write(socket,
boost::asio::buffer(*encoded_message), std::move(self));
return; // Composed operation not yet complete.
}
}
// This point is reached only on completion of the entire composed
// operation.
// Deallocate the encoded message and delay timer before calling the
// user-supplied completion handler.
encoded_message.reset();
delay_timer.reset();
// Call the user-supplied handler with the result of the operation.
self.complete(error);
},
token, socket);
}
void operator()(CompletionHandler&& completion_handler, tcp::socket& socket,
std::unique_ptr<std::string> encoded_message, std::size_t repeat_count,
std::unique_ptr<boost::asio::steady_timer> delay_timer) const
{
// In this example, the composed operation's intermediate completion
// handler is implemented as a hand-crafted function object.
struct intermediate_completion_handler
{
// The intermediate completion handler holds a reference to the socket as
// it is used for multiple async_write operations, as well as for
// obtaining the I/O executor (see get_executor below).
tcp::socket& socket_;
// The allocated buffer for the encoded message. The std::unique_ptr
// smart pointer is move-only, and as a consequence our intermediate
// completion handler is also move-only.
std::unique_ptr<std::string> encoded_message_;
// The repeat count remaining.
std::size_t repeat_count_;
// A steady timer used for introducing a delay.
std::unique_ptr<boost::asio::steady_timer> delay_timer_;
// To manage the cycle between the multiple underlying asychronous
// operations, our intermediate completion handler is implemented as a
// state machine.
enum { starting, waiting, writing } state_;
// As our composed operation performs multiple underlying I/O operations,
// we should maintain a work object against the I/O executor. This tells
// the I/O executor that there is still more work to come in the future.
boost::asio::executor_work_guard<tcp::socket::executor_type> io_work_;
// The user-supplied completion handler, called once only on completion
// of the entire composed operation.
typename std::decay<CompletionHandler>::type handler_;
// By having a default value for the second argument, this function call
// operator matches the completion signature of both the async_write and
// steady_timer::async_wait operations.
void operator()(const boost::system::error_code& error, std::size_t = 0)
{
if (!error)
{
switch (state_)
{
case starting:
case writing:
if (repeat_count_ > 0)
{
--repeat_count_;
state_ = waiting;
delay_timer_->expires_after(std::chrono::seconds(1));
delay_timer_->async_wait(std::move(*this));
return; // Composed operation not yet complete.
}
break; // Composed operation complete, continue below.
case waiting:
state_ = writing;
boost::asio::async_write(socket_,
boost::asio::buffer(*encoded_message_), std::move(*this));
return; // Composed operation not yet complete.
}
}
// This point is reached only on completion of the entire composed
// operation.
// We no longer have any future work coming for the I/O executor.
io_work_.reset();
// Deallocate the encoded message before calling the user-supplied
// completion handler.
encoded_message_.reset();
// Call the user-supplied handler with the result of the operation.
handler_(error);
}
// It is essential to the correctness of our composed operation that we
// preserve the executor of the user-supplied completion handler. With a
// hand-crafted function object we can do this by defining a nested type
// executor_type and member function get_executor. These obtain the
// completion handler's associated executor, and default to the I/O
// executor - in this case the executor of the socket - if the completion
// handler does not have its own.
using executor_type = boost::asio::associated_executor_t<
typename std::decay<CompletionHandler>::type,
tcp::socket::executor_type>;
executor_type get_executor() const noexcept
{
return boost::asio::get_associated_executor(
handler_, socket_.get_executor());
}
// Although not necessary for correctness, we may also preserve the
// allocator of the user-supplied completion handler. This is achieved by
// defining a nested type allocator_type and member function
// get_allocator. These obtain the completion handler's associated
// allocator, and default to std::allocator<void> if the completion
// handler does not have its own.
using allocator_type = boost::asio::associated_allocator_t<
typename std::decay<CompletionHandler>::type,
std::allocator<void>>;
allocator_type get_allocator() const noexcept
{
return boost::asio::get_associated_allocator(
handler_, std::allocator<void>{});
}
};
// Initiate the underlying async_write operation using our intermediate
// completion handler.
auto encoded_message_buffer = boost::asio::buffer(*encoded_message);
boost::asio::async_write(socket, encoded_message_buffer,
intermediate_completion_handler{
socket, std::move(encoded_message),
repeat_count, std::move(delay_timer),
intermediate_completion_handler::starting,
boost::asio::make_work_guard(socket.get_executor()),
std::forward<CompletionHandler>(completion_handler)});
}