diff options
Diffstat (limited to 'boost/asio/write.hpp')
| -rw-r--r-- | boost/asio/write.hpp | 331 |
1 files changed, 320 insertions, 11 deletions
diff --git a/boost/asio/write.hpp b/boost/asio/write.hpp index b70e6f5bf5..87187c3d06 100644 --- a/boost/asio/write.hpp +++ b/boost/asio/write.hpp @@ -18,9 +18,13 @@ #include <boost/asio/detail/config.hpp> #include <cstddef> #include <boost/asio/async_result.hpp> -#include <boost/asio/basic_streambuf_fwd.hpp> +#include <boost/asio/buffer.hpp> #include <boost/asio/error.hpp> +#if !defined(BOOST_ASIO_NO_EXTENSIONS) +# include <boost/asio/basic_streambuf_fwd.hpp> +#endif // !defined(BOOST_ASIO_NO_EXTENSIONS) + #include <boost/asio/detail/push_options.hpp> namespace boost { @@ -70,7 +74,10 @@ namespace asio { * boost::asio::transfer_all()); @endcode */ template <typename SyncWriteStream, typename ConstBufferSequence> -std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers); +std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, + typename enable_if< + is_const_buffer_sequence<ConstBufferSequence>::value + >::type* = 0); /// Write all of the supplied data to a stream before returning. /** @@ -110,7 +117,10 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers); */ template <typename SyncWriteStream, typename ConstBufferSequence> std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, - boost::system::error_code& ec); + boost::system::error_code& ec, + typename enable_if< + is_const_buffer_sequence<ConstBufferSequence>::value + >::type* = 0); /// Write a certain amount of data to a stream before returning. /** @@ -161,7 +171,10 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, template <typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, - CompletionCondition completion_condition); + CompletionCondition completion_condition, + typename enable_if< + is_const_buffer_sequence<ConstBufferSequence>::value + >::type* = 0); /// Write a certain amount of data to a stream before returning. /** @@ -205,8 +218,172 @@ std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, template <typename SyncWriteStream, typename ConstBufferSequence, typename CompletionCondition> std::size_t write(SyncWriteStream& s, const ConstBufferSequence& buffers, - CompletionCondition completion_condition, boost::system::error_code& ec); + CompletionCondition completion_condition, boost::system::error_code& ec, + typename enable_if< + is_const_buffer_sequence<ConstBufferSequence>::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. + * + * @returns The number of bytes transferred. + * + * @throws boost::system::system_error Thrown on failure. + * + * @note This overload is equivalent to calling: + * @code boost::asio::write( + * s, buffers, + * boost::asio::transfer_all()); @endcode + */ +template <typename SyncWriteStream, typename DynamicBuffer> +std::size_t write(SyncWriteStream& s, + BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers, + typename enable_if< + is_dynamic_buffer<DynamicBuffer>::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 boost::asio::write( + * s, buffers, + * boost::asio::transfer_all(), ec); @endcode + */ +template <typename SyncWriteStream, typename DynamicBuffer> +std::size_t write(SyncWriteStream& s, + BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers, + boost::system::error_code& ec, + typename enable_if< + is_dynamic_buffer<DynamicBuffer>::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 boost::system::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 boost::system::system_error Thrown on failure. + */ +template <typename SyncWriteStream, typename DynamicBuffer, + typename CompletionCondition> +std::size_t write(SyncWriteStream& s, + BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers, + CompletionCondition completion_condition, + typename enable_if< + is_dynamic_buffer<DynamicBuffer>::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 boost::system::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, + typename CompletionCondition> +std::size_t write(SyncWriteStream& s, + BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers, + CompletionCondition completion_condition, boost::system::error_code& ec, + typename enable_if< + is_dynamic_buffer<DynamicBuffer>::value + >::type* = 0); +#if !defined(BOOST_ASIO_NO_EXTENSIONS) #if !defined(BOOST_ASIO_NO_IOSTREAM) /// Write all of the supplied data to a stream before returning. @@ -350,6 +527,7 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b, CompletionCondition completion_condition, boost::system::error_code& ec); #endif // !defined(BOOST_ASIO_NO_IOSTREAM) +#endif // !defined(BOOST_ASIO_NO_EXTENSIONS) /*@}*/ /** @@ -401,7 +579,7 @@ std::size_t write(SyncWriteStream& s, basic_streambuf<Allocator>& b, * 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 - * boost::asio::io_service::post(). + * boost::asio::io_context::post(). * * @par Example * To write a single data buffer use the @ref buffer function as follows: @@ -417,7 +595,10 @@ template <typename AsyncWriteStream, typename ConstBufferSequence, BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, void (boost::system::error_code, std::size_t)) async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, - BOOST_ASIO_MOVE_ARG(WriteHandler) handler); + BOOST_ASIO_MOVE_ARG(WriteHandler) handler, + typename enable_if< + is_const_buffer_sequence<ConstBufferSequence>::value + >::type* = 0); /// Start an asynchronous operation to write a certain amount of data to a /// stream. @@ -474,7 +655,7 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, * 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 - * boost::asio::io_service::post(). + * boost::asio::io_context::post(). * * @par Example * To write a single data buffer use the @ref buffer function as follows: @@ -492,8 +673,135 @@ BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, void (boost::system::error_code, std::size_t)) async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, CompletionCondition completion_condition, - BOOST_ASIO_MOVE_ARG(WriteHandler) handler); + BOOST_ASIO_MOVE_ARG(WriteHandler) handler, + typename enable_if< + is_const_buffer_sequence<ConstBufferSequence>::value + >::type* = 0); + +/// 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 boost::system::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. Invocation of + * the handler will be performed in a manner equivalent to using + * boost::asio::io_context::post(). + */ +template <typename AsyncWriteStream, + typename DynamicBuffer, typename WriteHandler> +BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, + void (boost::system::error_code, std::size_t)) +async_write(AsyncWriteStream& s, + BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers, + BOOST_ASIO_MOVE_ARG(WriteHandler) handler, + typename enable_if< + is_dynamic_buffer<DynamicBuffer>::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 boost::system::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 boost::system::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. Invocation of + * the handler will be performed in a manner equivalent to using + * boost::asio::io_context::post(). + */ +template <typename AsyncWriteStream, typename DynamicBuffer, + typename CompletionCondition, typename WriteHandler> +BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, + void (boost::system::error_code, std::size_t)) +async_write(AsyncWriteStream& s, + BOOST_ASIO_MOVE_ARG(DynamicBuffer) buffers, + CompletionCondition completion_condition, + BOOST_ASIO_MOVE_ARG(WriteHandler) handler, + typename enable_if< + is_dynamic_buffer<DynamicBuffer>::value + >::type* = 0); +#if !defined(BOOST_ASIO_NO_EXTENSIONS) #if !defined(BOOST_ASIO_NO_IOSTREAM) /// Start an asynchronous operation to write all of the supplied data to a @@ -535,7 +843,7 @@ async_write(AsyncWriteStream& s, const ConstBufferSequence& buffers, * 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 - * boost::asio::io_service::post(). + * boost::asio::io_context::post(). */ template <typename AsyncWriteStream, typename Allocator, typename WriteHandler> BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, @@ -596,7 +904,7 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b, * 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 - * boost::asio::io_service::post(). + * boost::asio::io_context::post(). */ template <typename AsyncWriteStream, typename Allocator, typename CompletionCondition, typename WriteHandler> @@ -607,6 +915,7 @@ async_write(AsyncWriteStream& s, basic_streambuf<Allocator>& b, BOOST_ASIO_MOVE_ARG(WriteHandler) handler); #endif // !defined(BOOST_ASIO_NO_IOSTREAM) +#endif // !defined(BOOST_ASIO_NO_EXTENSIONS) /*@}*/ |