diff options
Diffstat (limited to '3rdparty/asio/include/asio/write.hpp')
-rw-r--r-- | 3rdparty/asio/include/asio/write.hpp | 581 |
1 files changed, 500 insertions, 81 deletions
diff --git a/3rdparty/asio/include/asio/write.hpp b/3rdparty/asio/include/asio/write.hpp index 001086202a7..df82e06aec1 100644 --- a/3rdparty/asio/include/asio/write.hpp +++ b/3rdparty/asio/include/asio/write.hpp @@ -2,7 +2,7 @@ // write.hpp // ~~~~~~~~~ // -// Copyright (c) 2003-2016 Christopher M. Kohlhoff (chris at kohlhoff dot com) +// Copyright (c) 2003-2021 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) @@ -32,7 +32,8 @@ namespace asio { /** * @defgroup write asio::write * - * @brief Write a certain amount of data to a stream before returning. + * @brief The @c write function is a composed operation that writes a certain + * amount of data to a stream before returning. */ /*@{*/ @@ -74,9 +75,9 @@ namespace asio { */ template <typename SyncWriteStream, typename ConstBufferSequence> std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, - typename enable_if< + typename constraint< is_const_buffer_sequence<ConstBufferSequence>::value - >::type* = 0); + >::type = 0); /// Write all of the supplied data to a stream before returning. /** @@ -117,9 +118,9 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, template <typename SyncWriteStream, typename ConstBufferSequence> std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, asio::error_code& ec, - typename enable_if< + typename constraint< is_const_buffer_sequence<ConstBufferSequence>::value - >::type* = 0); + >::type = 0); /// Write a certain amount of data to a stream before returning. /** @@ -171,9 +172,9 @@ template <typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, CompletionCondition completion_condition, - typename enable_if< + typename constraint< is_const_buffer_sequence<ConstBufferSequence>::value - >::type* = 0); + >::type = 0); /// Write a certain amount of data to a stream before returning. /** @@ -218,9 +219,11 @@ template <typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, CompletionCondition completion_condition, asio::error_code& ec, - typename enable_if< + typename constraint< is_const_buffer_sequence<ConstBufferSequence>::value - >::type* = 0); + >::type = 0); + +#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1) /// Write all of the supplied data to a stream before returning. /** @@ -249,12 +252,15 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, * s, buffers, * asio::transfer_all()); @endcode */ -template <typename SyncWriteStream, typename DynamicBuffer> +template <typename SyncWriteStream, typename DynamicBuffer_v1> std::size_t write(SyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type* = 0); + ASIO_MOVE_ARG(DynamicBuffer_v1) buffers, + typename constraint< + is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0, + typename constraint< + !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0); /// Write all of the supplied data to a stream before returning. /** @@ -283,13 +289,16 @@ std::size_t write(SyncWriteStream& s, * s, buffers, * asio::transfer_all(), ec); @endcode */ -template <typename SyncWriteStream, typename DynamicBuffer> +template <typename SyncWriteStream, typename DynamicBuffer_v1> std::size_t write(SyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, + ASIO_MOVE_ARG(DynamicBuffer_v1) buffers, asio::error_code& ec, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type* = 0); + typename constraint< + is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0, + typename constraint< + !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0); /// Write a certain amount of data to a stream before returning. /** @@ -327,14 +336,17 @@ std::size_t write(SyncWriteStream& s, * * @throws asio::system_error Thrown on failure. */ -template <typename SyncWriteStream, typename DynamicBuffer, +template <typename SyncWriteStream, typename DynamicBuffer_v1, typename CompletionCondition> std::size_t write(SyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, + ASIO_MOVE_ARG(DynamicBuffer_v1) buffers, CompletionCondition completion_condition, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type* = 0); + typename constraint< + is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0, + typename constraint< + !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0); /// Write a certain amount of data to a stream before returning. /** @@ -373,14 +385,17 @@ std::size_t write(SyncWriteStream& s, * @returns The number of bytes written. If an error occurs, returns the total * number of bytes successfully transferred prior to the error. */ -template <typename SyncWriteStream, typename DynamicBuffer, +template <typename SyncWriteStream, typename DynamicBuffer_v1, typename CompletionCondition> std::size_t write(SyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, + ASIO_MOVE_ARG(DynamicBuffer_v1) buffers, CompletionCondition completion_condition, asio::error_code& ec, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type* = 0); + typename constraint< + is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0, + typename constraint< + !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0); #if !defined(ASIO_NO_EXTENSIONS) #if !defined(ASIO_NO_IOSTREAM) @@ -527,13 +542,170 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b, #endif // !defined(ASIO_NO_IOSTREAM) #endif // !defined(ASIO_NO_EXTENSIONS) +#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1) + +/// Write all of the supplied data to a stream before returning. +/** + * This function is used to write a certain number of bytes of data to a stream. + * The call will block until one of the following conditions is true: + * + * @li All of the data in the supplied dynamic buffer sequence has been written. + * + * @li An error occurred. + * + * This operation is implemented in terms of zero or more calls to the stream's + * write_some function. + * + * @param s The stream to which the data is to be written. The type must support + * the SyncWriteStream concept. + * + * @param buffers The dynamic buffer sequence from which data will be written. + * Successfully written data is automatically consumed from the buffers. + * + * @returns The number of bytes transferred. + * + * @throws asio::system_error Thrown on failure. + * + * @note This overload is equivalent to calling: + * @code asio::write( + * s, buffers, + * asio::transfer_all()); @endcode + */ +template <typename SyncWriteStream, typename DynamicBuffer_v2> +std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers, + typename constraint< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >::type = 0); + +/// Write all of the supplied data to a stream before returning. +/** + * This function is used to write a certain number of bytes of data to a stream. + * The call will block until one of the following conditions is true: + * + * @li All of the data in the supplied dynamic buffer sequence has been written. + * + * @li An error occurred. + * + * This operation is implemented in terms of zero or more calls to the stream's + * write_some function. + * + * @param s The stream to which the data is to be written. The type must support + * the SyncWriteStream concept. + * + * @param buffers The dynamic buffer sequence from which data will be written. + * Successfully written data is automatically consumed from the buffers. + * + * @param ec Set to indicate what error occurred, if any. + * + * @returns The number of bytes transferred. + * + * @note This overload is equivalent to calling: + * @code asio::write( + * s, buffers, + * asio::transfer_all(), ec); @endcode + */ +template <typename SyncWriteStream, typename DynamicBuffer_v2> +std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers, + asio::error_code& ec, + typename constraint< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >::type = 0); + +/// Write a certain amount of data to a stream before returning. +/** + * This function is used to write a certain number of bytes of data to a stream. + * The call will block until one of the following conditions is true: + * + * @li All of the data in the supplied dynamic buffer sequence has been written. + * + * @li The completion_condition function object returns 0. + * + * This operation is implemented in terms of zero or more calls to the stream's + * write_some function. + * + * @param s The stream to which the data is to be written. The type must support + * the SyncWriteStream concept. + * + * @param buffers The dynamic buffer sequence from which data will be written. + * Successfully written data is automatically consumed from the buffers. + * + * @param completion_condition The function object to be called to determine + * whether the write operation is complete. The signature of the function object + * must be: + * @code std::size_t completion_condition( + * // Result of latest write_some operation. + * const asio::error_code& error, + * + * // Number of bytes transferred so far. + * std::size_t bytes_transferred + * ); @endcode + * A return value of 0 indicates that the write operation is complete. A + * non-zero return value indicates the maximum number of bytes to be written on + * the next call to the stream's write_some function. + * + * @returns The number of bytes transferred. + * + * @throws asio::system_error Thrown on failure. + */ +template <typename SyncWriteStream, typename DynamicBuffer_v2, + typename CompletionCondition> +std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers, + CompletionCondition completion_condition, + typename constraint< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >::type = 0); + +/// Write a certain amount of data to a stream before returning. +/** + * This function is used to write a certain number of bytes of data to a stream. + * The call will block until one of the following conditions is true: + * + * @li All of the data in the supplied dynamic buffer sequence has been written. + * + * @li The completion_condition function object returns 0. + * + * This operation is implemented in terms of zero or more calls to the stream's + * write_some function. + * + * @param s The stream to which the data is to be written. The type must support + * the SyncWriteStream concept. + * + * @param buffers The dynamic buffer sequence from which data will be written. + * Successfully written data is automatically consumed from the buffers. + * + * @param completion_condition The function object to be called to determine + * whether the write operation is complete. The signature of the function object + * must be: + * @code std::size_t completion_condition( + * // Result of latest write_some operation. + * const asio::error_code& error, + * + * // Number of bytes transferred so far. + * std::size_t bytes_transferred + * ); @endcode + * A return value of 0 indicates that the write operation is complete. A + * non-zero return value indicates the maximum number of bytes to be written on + * the next call to the stream's write_some function. + * + * @param ec Set to indicate what error occurred, if any. + * + * @returns The number of bytes written. If an error occurs, returns the total + * number of bytes successfully transferred prior to the error. + */ +template <typename SyncWriteStream, typename DynamicBuffer_v2, + typename CompletionCondition> +std::size_t write(SyncWriteStream& s, DynamicBuffer_v2 buffers, + CompletionCondition completion_condition, asio::error_code& ec, + typename constraint< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >::type = 0); /*@}*/ /** * @defgroup async_write asio::async_write * - * @brief Start an asynchronous operation to write a certain amount of data to a - * stream. + * @brief The @c async_write function is a composed asynchronous operation that + * writes a certain amount of data to a stream before completion. */ /*@{*/ @@ -576,9 +748,9 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b, * // of the buffer sizes. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation of - * the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). * * @par Example * To write a single data buffer use the @ref buffer function as follows: @@ -588,16 +760,32 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b, * See the @ref buffer documentation for information on writing multiple * buffers in one go, and how to use it with arrays, boost::array or * std::vector. + * + * @par Per-Operation Cancellation + * This asynchronous operation supports cancellation for the following + * asio::cancellation_type values: + * + * @li @c cancellation_type::terminal + * + * @li @c cancellation_type::partial + * + * if they are also supported by the @c AsyncWriteStream type's + * @c async_write_some operation. */ template <typename AsyncWriteStream, typename ConstBufferSequence, - typename WriteHandler> -ASIO_INITFN_RESULT_TYPE(WriteHandler, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE( + typename AsyncWriteStream::executor_type)> +ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler, void (asio::error_code, std::size_t)) async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, - ASIO_MOVE_ARG(WriteHandler) handler, - typename enable_if< + ASIO_MOVE_ARG(WriteHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN( + typename AsyncWriteStream::executor_type), + typename constraint< is_const_buffer_sequence<ConstBufferSequence>::value - >::type* = 0); + >::type = 0); /// Start an asynchronous operation to write a certain amount of data to a /// stream. @@ -652,9 +840,9 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, * // of the buffer sizes. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation of - * the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). * * @par Example * To write a single data buffer use the @ref buffer function as follows: @@ -665,17 +853,32 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, * See the @ref buffer documentation for information on writing multiple * buffers in one go, and how to use it with arrays, boost::array or * std::vector. + * + * @par Per-Operation Cancellation + * This asynchronous operation supports cancellation for the following + * asio::cancellation_type values: + * + * @li @c cancellation_type::terminal + * + * @li @c cancellation_type::partial + * + * if they are also supported by the @c AsyncWriteStream type's + * @c async_write_some operation. */ -template <typename AsyncWriteStream, typename ConstBufferSequence, - typename CompletionCondition, typename WriteHandler> -ASIO_INITFN_RESULT_TYPE(WriteHandler, +template <typename AsyncWriteStream, + typename ConstBufferSequence, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteHandler> +ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler, void (asio::error_code, std::size_t)) async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, CompletionCondition completion_condition, ASIO_MOVE_ARG(WriteHandler) handler, - typename enable_if< + typename constraint< is_const_buffer_sequence<ConstBufferSequence>::value - >::type* = 0); + >::type = 0); + +#if !defined(ASIO_NO_DYNAMIC_BUFFER_V1) /// Start an asynchronous operation to write all of the supplied data to a /// stream. @@ -716,20 +919,39 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, * // of the buffer sizes. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation of - * the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). + * + * @par Per-Operation Cancellation + * This asynchronous operation supports cancellation for the following + * asio::cancellation_type values: + * + * @li @c cancellation_type::terminal + * + * @li @c cancellation_type::partial + * + * if they are also supported by the @c AsyncWriteStream type's + * @c async_write_some operation. */ -template <typename AsyncWriteStream, - typename DynamicBuffer, typename WriteHandler> -ASIO_INITFN_RESULT_TYPE(WriteHandler, +template <typename AsyncWriteStream, typename DynamicBuffer_v1, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE( + typename AsyncWriteStream::executor_type)> +ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler, void (asio::error_code, std::size_t)) async_write(AsyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, - ASIO_MOVE_ARG(WriteHandler) handler, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type* = 0); + ASIO_MOVE_ARG(DynamicBuffer_v1) buffers, + ASIO_MOVE_ARG(WriteHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN( + typename AsyncWriteStream::executor_type), + typename constraint< + is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0, + typename constraint< + !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0); /// Start an asynchronous operation to write a certain amount of data to a /// stream. @@ -784,21 +1006,37 @@ async_write(AsyncWriteStream& s, * // of the buffer sizes. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation of - * the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). + * + * @par Per-Operation Cancellation + * This asynchronous operation supports cancellation for the following + * asio::cancellation_type values: + * + * @li @c cancellation_type::terminal + * + * @li @c cancellation_type::partial + * + * if they are also supported by the @c AsyncWriteStream type's + * @c async_write_some operation. */ -template <typename AsyncWriteStream, typename DynamicBuffer, - typename CompletionCondition, typename WriteHandler> -ASIO_INITFN_RESULT_TYPE(WriteHandler, +template <typename AsyncWriteStream, + typename DynamicBuffer_v1, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteHandler> +ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler, void (asio::error_code, std::size_t)) async_write(AsyncWriteStream& s, - ASIO_MOVE_ARG(DynamicBuffer) buffers, + ASIO_MOVE_ARG(DynamicBuffer_v1) buffers, CompletionCondition completion_condition, ASIO_MOVE_ARG(WriteHandler) handler, - typename enable_if< - is_dynamic_buffer<DynamicBuffer>::value - >::type* = 0); + typename constraint< + is_dynamic_buffer_v1<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0, + typename constraint< + !is_dynamic_buffer_v2<typename decay<DynamicBuffer_v1>::type>::value + >::type = 0); #if !defined(ASIO_NO_EXTENSIONS) #if !defined(ASIO_NO_IOSTREAM) @@ -840,15 +1078,32 @@ async_write(AsyncWriteStream& s, * // of the buffer sizes. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation of - * the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). + * + * @par Per-Operation Cancellation + * This asynchronous operation supports cancellation for the following + * asio::cancellation_type values: + * + * @li @c cancellation_type::terminal + * + * @li @c cancellation_type::partial + * + * if they are also supported by the @c AsyncWriteStream type's + * @c async_write_some operation. */ -template <typename AsyncWriteStream, typename Allocator, typename WriteHandler> -ASIO_INITFN_RESULT_TYPE(WriteHandler, +template <typename AsyncWriteStream, typename Allocator, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE( + typename AsyncWriteStream::executor_type)> +ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler, void (asio::error_code, std::size_t)) async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b, - ASIO_MOVE_ARG(WriteHandler) handler); + ASIO_MOVE_ARG(WriteHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN( + typename AsyncWriteStream::executor_type)); /// Start an asynchronous operation to write a certain amount of data to a /// stream. @@ -901,13 +1156,26 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b, * // of the buffer sizes. * ); @endcode * Regardless of whether the asynchronous operation completes immediately or - * not, the handler will not be invoked from within this function. Invocation of - * the handler will be performed in a manner equivalent to using - * asio::io_context::post(). + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). + * + * @par Per-Operation Cancellation + * This asynchronous operation supports cancellation for the following + * asio::cancellation_type values: + * + * @li @c cancellation_type::terminal + * + * @li @c cancellation_type::partial + * + * if they are also supported by the @c AsyncWriteStream type's + * @c async_write_some operation. */ -template <typename AsyncWriteStream, typename Allocator, - typename CompletionCondition, typename WriteHandler> -ASIO_INITFN_RESULT_TYPE(WriteHandler, +template <typename AsyncWriteStream, + typename Allocator, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteHandler> +ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler, void (asio::error_code, std::size_t)) async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b, CompletionCondition completion_condition, @@ -915,6 +1183,157 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b, #endif // !defined(ASIO_NO_IOSTREAM) #endif // !defined(ASIO_NO_EXTENSIONS) +#endif // !defined(ASIO_NO_DYNAMIC_BUFFER_V1) + +/// Start an asynchronous operation to write all of the supplied data to a +/// stream. +/** + * This function is used to asynchronously write a certain number of bytes of + * data to a stream. The function call always returns immediately. The + * asynchronous operation will continue until one of the following conditions + * is true: + * + * @li All of the data in the supplied dynamic buffer sequence has been written. + * + * @li An error occurred. + * + * This operation is implemented in terms of zero or more calls to the stream's + * async_write_some function, and is known as a <em>composed operation</em>. The + * program must ensure that the stream performs no other write operations (such + * as async_write, the stream's async_write_some function, or any other composed + * operations that perform writes) until this operation completes. + * + * @param s The stream to which the data is to be written. The type must support + * the AsyncWriteStream concept. + * + * @param buffers The dynamic buffer sequence from which data will be written. + * Although the buffers object may be copied as necessary, ownership of the + * underlying memory blocks is retained by the caller, which must guarantee + * that they remain valid until the handler is called. Successfully written + * data is automatically consumed from the buffers. + * + * @param handler The handler to be called when the write operation completes. + * Copies will be made of the handler as required. The function signature of the + * handler must be: + * @code void handler( + * const asio::error_code& error, // Result of operation. + * + * std::size_t bytes_transferred // Number of bytes written from the + * // buffers. If an error occurred, + * // this will be less than the sum + * // of the buffer sizes. + * ); @endcode + * Regardless of whether the asynchronous operation completes immediately or + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). + * + * @par Per-Operation Cancellation + * This asynchronous operation supports cancellation for the following + * asio::cancellation_type values: + * + * @li @c cancellation_type::terminal + * + * @li @c cancellation_type::partial + * + * if they are also supported by the @c AsyncWriteStream type's + * @c async_write_some operation. + */ +template <typename AsyncWriteStream, typename DynamicBuffer_v2, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteHandler + ASIO_DEFAULT_COMPLETION_TOKEN_TYPE( + typename AsyncWriteStream::executor_type)> +ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler, + void (asio::error_code, std::size_t)) +async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers, + ASIO_MOVE_ARG(WriteHandler) handler + ASIO_DEFAULT_COMPLETION_TOKEN( + typename AsyncWriteStream::executor_type), + typename constraint< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >::type = 0); + +/// Start an asynchronous operation to write a certain amount of data to a +/// stream. +/** + * This function is used to asynchronously write a certain number of bytes of + * data to a stream. The function call always returns immediately. The + * asynchronous operation will continue until one of the following conditions + * is true: + * + * @li All of the data in the supplied dynamic buffer sequence has been written. + * + * @li The completion_condition function object returns 0. + * + * This operation is implemented in terms of zero or more calls to the stream's + * async_write_some function, and is known as a <em>composed operation</em>. The + * program must ensure that the stream performs no other write operations (such + * as async_write, the stream's async_write_some function, or any other composed + * operations that perform writes) until this operation completes. + * + * @param s The stream to which the data is to be written. The type must support + * the AsyncWriteStream concept. + * + * @param buffers The dynamic buffer sequence from which data will be written. + * Although the buffers object may be copied as necessary, ownership of the + * underlying memory blocks is retained by the caller, which must guarantee + * that they remain valid until the handler is called. Successfully written + * data is automatically consumed from the buffers. + * + * @param completion_condition The function object to be called to determine + * whether the write operation is complete. The signature of the function object + * must be: + * @code std::size_t completion_condition( + * // Result of latest async_write_some operation. + * const asio::error_code& error, + * + * // Number of bytes transferred so far. + * std::size_t bytes_transferred + * ); @endcode + * A return value of 0 indicates that the write operation is complete. A + * non-zero return value indicates the maximum number of bytes to be written on + * the next call to the stream's async_write_some function. + * + * @param handler The handler to be called when the write operation completes. + * Copies will be made of the handler as required. The function signature of the + * handler must be: + * @code void handler( + * const asio::error_code& error, // Result of operation. + * + * std::size_t bytes_transferred // Number of bytes written from the + * // buffers. If an error occurred, + * // this will be less than the sum + * // of the buffer sizes. + * ); @endcode + * Regardless of whether the asynchronous operation completes immediately or + * not, the handler will not be invoked from within this function. On + * immediate completion, invocation of the handler will be performed in a + * manner equivalent to using asio::post(). + * + * @par Per-Operation Cancellation + * This asynchronous operation supports cancellation for the following + * asio::cancellation_type values: + * + * @li @c cancellation_type::terminal + * + * @li @c cancellation_type::partial + * + * if they are also supported by the @c AsyncWriteStream type's + * @c async_write_some operation. + */ +template <typename AsyncWriteStream, + typename DynamicBuffer_v2, typename CompletionCondition, + ASIO_COMPLETION_TOKEN_FOR(void (asio::error_code, + std::size_t)) WriteHandler> +ASIO_INITFN_AUTO_RESULT_TYPE(WriteHandler, + void (asio::error_code, std::size_t)) +async_write(AsyncWriteStream& s, DynamicBuffer_v2 buffers, + CompletionCondition completion_condition, + ASIO_MOVE_ARG(WriteHandler) handler, + typename constraint< + is_dynamic_buffer_v2<DynamicBuffer_v2>::value + >::type = 0); /*@}*/ |